aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-10 09:19:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nelns/login_system/nel_launcher_windows_ext/Md5.cpp

487 lines
13 KiB
C++
Raw Blame History

// Md5.cpp: implementation of the CMd5 class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Md5.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define MD5_PAD_FIRST_BYTE 0x80 // The first byte of padding.
#define MD5_PAD_SIZE 56 // The padding function pads out to 56 bytes.
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
#define T1 0xd76aa478
#define T2 0xe8c7b756
#define T3 0x242070db
#define T4 0xc1bdceee
#define T5 0xf57c0faf
#define T6 0x4787c62a
#define T7 0xa8304613
#define T8 0xfd469501
#define T9 0x698098d8
#define T10 0x8b44f7af
#define T11 0xffff5bb1
#define T12 0x895cd7be
#define T13 0x6b901122
#define T14 0xfd987193
#define T15 0xa679438e
#define T16 0x49b40821
#define T17 0xf61e2562
#define T18 0xc040b340
#define T19 0x265e5a51
#define T20 0xe9b6c7aa
#define T21 0xd62f105d
#define T22 0x02441453
#define T23 0xd8a1e681
#define T24 0xe7d3fbc8
#define T25 0x21e1cde6
#define T26 0xc33707d6
#define T27 0xf4d50d87
#define T28 0x455a14ed
#define T29 0xa9e3e905
#define T30 0xfcefa3f8
#define T31 0x676f02d9
#define T32 0x8d2a4c8a
#define T33 0xfffa3942
#define T34 0x8771f681
#define T35 0x6d9d6122
#define T36 0xfde5380c
#define T37 0xa4beea44
#define T38 0x4bdecfa9
#define T39 0xf6bb4b60
#define T40 0xbebfbc70
#define T41 0x289b7ec6
#define T42 0xeaa127fa
#define T43 0xd4ef3085
#define T44 0x04881d05
#define T45 0xd9d4d039
#define T46 0xe6db99e5
#define T47 0x1fa27cf8
#define T48 0xc4ac5665
#define T49 0xf4292244
#define T50 0x432aff97
#define T51 0xab9423a7
#define T52 0xfc93a039
#define T53 0x655b59c3
#define T54 0x8f0ccc92
#define T55 0xffeff47d
#define T56 0x85845dd1
#define T57 0x6fa87e4f
#define T58 0xfe2ce6e0
#define T59 0xa3014314
#define T60 0x4e0811a1
#define T61 0xf7537e82
#define T62 0xbd3af235
#define T63 0x2ad7d2bb
#define T64 0xeb86d391
#define A_INIT 0x67452301
#define B_INIT 0xefcdab89
#define C_INIT 0x98badcfe
#define D_INIT 0x10325476
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CMD5::CMD5()
{
}
CMD5::CMD5(CFile& InputFile)
{
// Initialize the digest.
a = A_INIT;
b = B_INIT;
c = C_INIT;
d = D_INIT;
// Now init the bit length of the input.
count[0] = 0;
count[1] = 0;
// Now perform transformation on every block of input.
do
{
// Read a block from the input.
block_idx = InputFile.Read( manip_block, MD5_BLOCK_SIZE);
if (block_idx == MD5_BLOCK_SIZE)
{
// A full block is ready to be transformed. Do so.
MD5_IncCount( MD5_BLOCK_SIZE );
MD5_Xform();
}
else
{
MD5_IncCount( block_idx );
// If the count of bytes read is not a full block,
// the end of the file has been found, and the ending should be prepared.
if (block_idx < (MD5_PAD_SIZE) )
{
// There is enough room in the block, to pad up to the correct size.
// Pad and then transform.
MD5_Pad( normal );
MD5_Xform();
}
else
{
// The block is already up to or beyond the pad size. Pad to the
// end and of the current block, and then transform it.
MD5_Pad( to_end );
MD5_Xform();
// Now create another block that is empty and pad all the way.
block_idx = 0;
MD5_Pad( finish );
MD5_Xform();
}
}
} while (block_idx == MD5_BLOCK_SIZE);
}
void CMD5::SetContent(CString csContent)
{
int iOffset = 0;
// Initialize the digest.
a = A_INIT;
b = B_INIT;
c = C_INIT;
d = D_INIT;
// Now init the bit length of the input.
count[0] = 0;
count[1] = 0;
// Now perform transformation on every block of input.
do
{
strcpy((char*)manip_block, csContent.Mid(iOffset, MD5_BLOCK_SIZE));
block_idx = strlen((const char*)manip_block);
if (block_idx == MD5_BLOCK_SIZE)
{
// A full block is ready to be transformed. Do so.
MD5_IncCount(MD5_BLOCK_SIZE);
MD5_Xform();
}
else
{
MD5_IncCount( block_idx );
// If the count of bytes read is not a full block,
// the end of the file has been found, and the ending should be prepared.
if (block_idx < (MD5_PAD_SIZE) )
{
// There is enough room in the block, to pad up to the correct size.
// Pad and then transform.
MD5_Pad( normal );
MD5_Xform();
}
else
{
// The block is already up to or beyond the pad size. Pad to the
// end and of the current block, and then transform it.
MD5_Pad( to_end );
MD5_Xform();
// Now create another block that is empty and pad all the way.
block_idx = 0;
MD5_Pad( finish );
MD5_Xform();
}
}
}
while (block_idx == MD5_BLOCK_SIZE);
}
void CMD5::MD5_Pad( MD5_PadMode PadMode )
{
switch( PadMode )
{
case normal:
// Perform normal padding.
manip_block[block_idx++] = MD5_PAD_FIRST_BYTE;
while (block_idx < MD5_PAD_SIZE)
manip_block[block_idx++] = 0;
// Now store count in this last block.
MD5_StoreCnt();
break;
case to_end:
// Pad until the end of the block.
manip_block[block_idx++] = MD5_PAD_FIRST_BYTE;
while (block_idx < MD5_BLOCK_SIZE)
manip_block[block_idx++] = 0;
break;
case finish:
// Finish padding.
while (block_idx < MD5_PAD_SIZE)
manip_block[block_idx++] = 0;
// Now store count in this last block.
MD5_StoreCnt();
break;
}
}
void CMD5::MD5_Xform()
{
// Save orig values of a,b,c,d.
UINT4 a_orig = a;
UINT4 b_orig = b;
UINT4 c_orig = c;
UINT4 d_orig = d;
// Now decode the manip_block into xform_buf;
MD5_Decode();
// Round 1.
// Let [abcd k s i] denote the operation
// a = b + ((a + F(b,c,d) + xform_buf[k] + T[i]) <<< s).
// Do the following 16 operations.
// [ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4]
// [ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8]
// [ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12]
// [ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]
FF (a, b, c, d, xform_buf[ 0], S11, T1);
FF (d, a, b, c, xform_buf[ 1], S12, T2);
FF (c, d, a, b, xform_buf[ 2], S13, T3);
FF (b, c, d, a, xform_buf[ 3], S14, T4);
FF (a, b, c, d, xform_buf[ 4], S11, T5);
FF (d, a, b, c, xform_buf[ 5], S12, T6);
FF (c, d, a, b, xform_buf[ 6], S13, T7);
FF (b, c, d, a, xform_buf[ 7], S14, T8);
FF (a, b, c, d, xform_buf[ 8], S11, T9);
FF (d, a, b, c, xform_buf[ 9], S12, T10);
FF (c, d, a, b, xform_buf[10], S13, T11);
FF (b, c, d, a, xform_buf[11], S14, T12);
FF (a, b, c, d, xform_buf[12], S11, T13);
FF (d, a, b, c, xform_buf[13], S12, T14);
FF (c, d, a, b, xform_buf[14], S13, T15);
FF (b, c, d, a, xform_buf[15], S14, T16);
// Round 2.
// Let [abcd k s i] denote the operation
// a = b + ((a + G(b,c,d) + xform_buf[k] + T[i]) <<< s).
// Do the following 16 operations.
// [ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20]
// [ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24]
// [ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28]
// [ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32]
GG (a, b, c, d, xform_buf[ 1], S21, T17);
GG (d, a, b, c, xform_buf[ 6], S22, T18);
GG (c, d, a, b, xform_buf[11], S23, T19);
GG (b, c, d, a, xform_buf[ 0], S24, T20);
GG (a, b, c, d, xform_buf[ 5], S21, T21);
GG (d, a, b, c, xform_buf[10], S22, T22);
GG (c, d, a, b, xform_buf[15], S23, T23);
GG (b, c, d, a, xform_buf[ 4], S24, T24);
GG (a, b, c, d, xform_buf[ 9], S21, T25);
GG (d, a, b, c, xform_buf[14], S22, T26);
GG (c, d, a, b, xform_buf[ 3], S23, T27);
GG (b, c, d, a, xform_buf[ 8], S24, T28);
GG (a, b, c, d, xform_buf[13], S21, T29);
GG (d, a, b, c, xform_buf[ 2], S22, T30);
GG (c, d, a, b, xform_buf[ 7], S23, T31);
GG (b, c, d, a, xform_buf[12], S24, T32);
// Round 3.
// Let [abcd k s t] denote the operation
// a = b + ((a + H(b,c,d) + xform_buf[k] + T[i]) <<< s).
// Do the following 16 operations.
// [ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36]
// [ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40]
// [ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44]
// [ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]
HH (a, b, c, d, xform_buf[ 5], S31, T33);
HH (d, a, b, c, xform_buf[ 8], S32, T34);
HH (c, d, a, b, xform_buf[11], S33, T35);
HH (b, c, d, a, xform_buf[14], S34, T36);
HH (a, b, c, d, xform_buf[ 1], S31, T37);
HH (d, a, b, c, xform_buf[ 4], S32, T38);
HH (c, d, a, b, xform_buf[ 7], S33, T39);
HH (b, c, d, a, xform_buf[10], S34, T40);
HH (a, b, c, d, xform_buf[13], S31, T41);
HH (d, a, b, c, xform_buf[ 0], S32, T42);
HH (c, d, a, b, xform_buf[ 3], S33, T43);
HH (b, c, d, a, xform_buf[ 6], S34, T44);
HH (a, b, c, d, xform_buf[ 9], S31, T45);
HH (d, a, b, c, xform_buf[12], S32, T46);
HH (c, d, a, b, xform_buf[15], S33, T47);
HH (b, c, d, a, xform_buf[ 2], S34, T48);
// Round 4.
// Let [abcd k s t] denote the operation
// a = b + ((a + I(b,c,d) + xform_buf[k] + T[i]) <<< s).
// Do the following 16 operations.
// [ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52]
// [ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56]
// [ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60]
// [ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64]
II (a, b, c, d, xform_buf[ 0], S41, T49);
II (d, a, b, c, xform_buf[ 7], S42, T50);
II (c, d, a, b, xform_buf[14], S43, T51);
II (b, c, d, a, xform_buf[ 5], S44, T52);
II (a, b, c, d, xform_buf[12], S41, T53);
II (d, a, b, c, xform_buf[ 3], S42, T54);
II (c, d, a, b, xform_buf[10], S43, T55);
II (b, c, d, a, xform_buf[ 1], S44, T56);
II (a, b, c, d, xform_buf[ 8], S41, T57);
II (d, a, b, c, xform_buf[15], S42, T58);
II (c, d, a, b, xform_buf[ 6], S43, T59);
II (b, c, d, a, xform_buf[13], S44, T60);
II (a, b, c, d, xform_buf[ 4], S41, T61);
II (d, a, b, c, xform_buf[11], S42, T62);
II (c, d, a, b, xform_buf[ 2], S43, T63);
II (b, c, d, a, xform_buf[ 9], S44, T64);
// Now perform the following additions. (That is increment each
// of the four registers by the value it had before this block
// was started.)
a += a_orig;
b += b_orig;
c += c_orig;
d += d_orig;
}
void CMD5::MD5_IncCount( int IncAmt)
{
UINT4 old_cnt0 = count[0];
count[0] += IncAmt*8;
if(count[0] < old_cnt0)
count[1]++; // Carry detection.
}
void CMD5::MD5_Decode()
{
unsigned int i, j;
for (i = 0, j = 0; j < MD5_BLOCK_SIZE; i++, j += sizeof(UINT4))
xform_buf[i] = ((UINT4)manip_block[j]) | (((UINT4)manip_block[j+1]) << 8) |
(((UINT4)manip_block[j+2]) << 16) | (((UINT4)manip_block[j+3]) << 24);
}
void CMD5::MD5_StoreCnt()
{
manip_block[MD5_PAD_SIZE+0]= unsigned int( count[0] & 0xff);
manip_block[MD5_PAD_SIZE+1]= unsigned int((count[0] >> 8) & 0xff);
manip_block[MD5_PAD_SIZE+2]= unsigned int((count[0] >> 16) & 0xff);
manip_block[MD5_PAD_SIZE+3]= unsigned int((count[0] >> 24) & 0xff);
manip_block[MD5_PAD_SIZE+4]= unsigned int(count[1] & 0xff);
manip_block[MD5_PAD_SIZE+5]= unsigned int((count[1] >> 8) & 0xff);
manip_block[MD5_PAD_SIZE+6]= unsigned int((count[1] >> 16) & 0xff);
manip_block[MD5_PAD_SIZE+7]= unsigned int((count[1] >> 24) & 0xff);
}
void CMD5::GetDigest( unsigned char* Dest)
{
Dest[0] = unsigned int(a & 0xff);
Dest[1] = unsigned int((a >> 8) & 0xff);
Dest[2] = unsigned int((a >> 16) & 0xff);
Dest[3] = unsigned int((a >> 24) & 0xff);
Dest[4] = unsigned int(b & 0xff);
Dest[5] = unsigned int((b >> 8) & 0xff);
Dest[6] = unsigned int((b >> 16) & 0xff);
Dest[7] = unsigned int((b >> 24) & 0xff);
Dest[8] = unsigned int(c & 0xff);
Dest[9] = unsigned int((c >> 8) & 0xff);
Dest[10] = unsigned int((c >> 16) & 0xff);
Dest[11] = unsigned int((c >> 24) & 0xff);
Dest[12] = unsigned int(d & 0xff);
Dest[13] = unsigned int((d >> 8) & 0xff);
Dest[14] = unsigned int((d >> 16) & 0xff);
Dest[15] = unsigned int((d >> 24) & 0xff);
}
CString CMD5::ConvertToAscii(unsigned char* lpszBuff)
{
CString csRet;
CString csHex = "0123456789abcdef";
int i, j;
unsigned long num;
unsigned long* plBuff = (unsigned long*)lpszBuff;
for(i = 0; i < 4; i++)
{
num = plBuff[i];
for(j = 0; j < 4; j++)
{
csRet += csHex[int((num >> (j * 8 + 4)) & 0x0F)];
csRet += csHex[int((num >> (j * 8)) & 0x0F)];
}
}
return csRet;
}
Reference in a new issue View git blame Copy permalink