md5.cpp

MD4数字指纹算法的实现...天可怜见

#include "stdafx.h"
#include "MD5.h"

//=====================================================================================
//	Operation macros
//=====================================================================================
#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 SHIFTLEFT(X, s)		(((X) << (s)) | ((X) >> (32-(s))))

#define FF(A, B, C, D, X, s, M)						\
{													\
	(A) += F((B), (C), (D)) + (X) + (U32)(M);		\
	(A)  = SHIFTLEFT((A), (s));						\
	(A) += (B);										\
}

#define GG(A, B, C, D, X, s, M)						\
{													\
	(A) += G((B), (C), (D)) + (X) + (U32)(M);		\
	(A)  = SHIFTLEFT((A), (s));						\
	(A) += (B);										\
}

#define HH(A, B, C, D, X, s, M)						\
{													\
	(A) += H((B), (C), (D)) + (X) + (U32)(M);		\
	(A)  = SHIFTLEFT((A), (s));						\
	(A) += (B);										\
}

#define II(A, B, C, D, X, s, M)						\
{													\
	(A) += I((B), (C), (D)) + (X) + (U32)(M);		\
	(A)  = SHIFTLEFT((A), (s));						\
	(A) += (B);										\
}

//=====================================================================================
//	Global variable
//=====================================================================================
typedef struct
{
	U32 state[4];
	U32 count[2];
	U8  buffer[64];
} MD5_CTX, *PMD5_CTX;

static MD5_CTX MD5_Data;

//=====================================================================================
//	Base functions
//=====================================================================================
static void Encode(U8 *pData, U32 *pCode, U32 size)
{
	U32 i;
	U32 j;
	for (i=0, j=0; j<size; i++, j+=4)
	{
		pData[j]   = (U8)(pCode[i] & 0xff);
		pData[j+1] = (U8)((pCode[i] >> 8) & 0xff);
		pData[j+2] = (U8)((pCode[i] >> 16) & 0xff);
		pData[j+3] = (U8)((pCode[i] >> 24) & 0xff);
	}
	return;
}

static void Decode(U32 *pCode, U8 *pData, U32 size)
{
	U32 i;
	U32 j;
	for (i=0, j=0; j<size; i++, j+=4)
	{
		pCode[i] = (((U32)pData[j]) | (((U32)pData[j+1]) << 8) |
			(((U32)pData[j+2]) << 16) | (((U32)pData[j+3]) << 24));
	}
	return;
}

static void CopyData(void *dst, void *src, U32 size)
{
	while (size--)
	{
		((U8 *)dst)[size] = ((U8 *)src)[size];
	}
}

static void SetData(void *src, U8 Data, U32 size)
{
	while (size--)
	{
		((U8 *)src)[size] = Data;
	}
}

//=====================================================================================
//	MD4 operation functions
//=====================================================================================
static void MD5_Transform(U32 *pResult, U8 *pData);

void MD5_Init(void)
{
	SetData((void *)(&MD5_Data), 0x00, sizeof(MD5_CTX));
	MD5_Data.state[0] = 0x67452301;
	MD5_Data.state[1] = 0xefcdab89;
	MD5_Data.state[2] = 0x98badcfe;
	MD5_Data.state[3] = 0x10325476;
}

void MD5_Update(U8 *pData, U32 size)
{
	U32 i;
	U32 index;
	U32 PartLen;

	index = (U32)((MD5_Data.count[0] >> 3) & 0x3F);				//count record the bit number
	if ((MD5_Data.count[0] += (size << 3)) < (size << 3))
	{
		MD5_Data.count[1]++;
	}
	MD5_Data.count[1] += (size >> 29);

	PartLen = 64 - index;

	i = 0;
	if (size >= PartLen)
	{
		CopyData((void *)(&MD5_Data.buffer[index]), (void *)pData, PartLen);
		MD5_Transform(MD5_Data.state, MD5_Data.buffer);
		for (i=PartLen; (i+63)<size; i+=64)
		{
			MD5_Transform(MD5_Data.state, &pData[i]);
		}
		index = 0;
	}
	CopyData((void *)(&MD5_Data.buffer[index]), (void *)&pData[i], size-i);
}

void MD5_Final(U8 *pResult, const U8 size)
{
	U8  bits[8];
	U8  Padding[64];
	U32 index;
	U32 PadLen;

	SetData(Padding, 0x00, 64);
	Padding[0] = 0x80;

	Encode(bits, MD5_Data.count, 8);

	index  = (U32)((MD5_Data.count[0] >> 3) & 0x3f);
	PadLen = (index < 56) ? (56 - index) : (120 - index);

	MD5_Update(Padding, PadLen);
	MD5_Update(bits, 8);

	Encode(pResult, MD5_Data.state, size);
	SetData((void *)(&MD5_Data), 0x00, sizeof(MD5_Data));
}

static void MD5_Transform(U32 *pResult, U8 *pData)
{
	U32 a;
	U32 b;
	U32 c;
	U32 d;
	U32 x[16];

	a = pResult[0];
	b = pResult[1];
	c = pResult[2];
	d = pResult[3];

	Decode(x, pData, 64);
	FF(a, b, c, d, x[ 0],  7, 0xD76AA478); FF(d, a, b, c, x[ 1], 12, 0xE8C7B756);	// 1、 2
	FF(c, d, a, b, x[ 2], 17, 0x242070DB); FF(b, c, d, a, x[ 3], 22, 0xC1BDCEEE);	// 3、 4
	FF(a, b, c, d, x[ 4],  7, 0xF57C0FAF); FF(d, a, b, c, x[ 5], 12, 0x4787C62A);	// 5、 6
	FF(c, d, a, b, x[ 6], 17, 0xA8304613); FF(b, c, d, a, x[ 7], 22, 0xFD469501);	// 7、 8
	FF(a, b, c, d, x[ 8],  7, 0x698098D8); FF(d, a, b, c, x[ 9], 12, 0x8B44F7AF);	// 9、10
	FF(c, d, a, b, x[10], 17, 0xFFFF5BB1); FF(b, c, d, a, x[11], 22, 0x895CD7BE);	//11、12
	FF(a, b, c, d, x[12],  7, 0x6B901122); FF(d, a, b, c, x[13], 12, 0xFD987193);	//13、14
	FF(c, d, a, b, x[14], 17, 0xA679438E); FF(b, c, d, a, x[15], 22, 0x49B40821);	//15、16

	GG(a, b, c, d, x[ 1],  5, 0xF61E2562); GG(d, a, b, c, x[ 6],  9, 0xC040B340);	//17、18
	GG(c, d, a, b, x[11], 14, 0x265E5A51); GG(b, c, d, a, x[ 0], 20, 0xE9B6C7AA);	//19、20
	GG(a, b, c, d, x[ 5],  5, 0xD62F105D); GG(d, a, b, c, x[10],  9, 0x02441453);	//21、22
	GG(c, d, a, b, x[15], 14, 0xD8A1E681); GG(b, c, d, a, x[ 4], 20, 0xE7D3FBC8);	//23、24
	GG(a, b, c, d, x[ 9],  5, 0x21E1CDE6); GG(d, a, b, c, x[14],  9, 0xC33707D6);	//25、26
	GG(c, d, a, b, x[ 3], 14, 0xF4D50D87); GG(b, c, d, a, x[ 8], 20, 0x455A14ED);	//27、28
	GG(a, b, c, d, x[13],  5, 0xA9E3E905); GG(d, a, b, c, x[ 2],  9, 0xFCEFA3F8);	//29、30
	GG(c, d, a, b, x[ 7], 14, 0x676F02D9); GG(b, c, d, a, x[12], 20, 0x8D2A4C8A);	//31、32

	HH(a, b, c, d, x[ 5],  4, 0xFFFA3942); HH(d, a, b, c, x[ 8], 11, 0x8771F681);	//33、34
	HH(c, d, a, b, x[11], 16, 0x6D9D6122); HH(b, c, d, a, x[14], 23, 0xFDE5380C);	//35、36
	HH(a, b, c, d, x[ 1],  4, 0xA4BEEA44); HH(d, a, b, c, x[ 4], 11, 0x4BDECFA9);	//37、38
	HH(c, d, a, b, x[ 7], 16, 0xF6BB4B60); HH(b, c, d, a, x[10], 23, 0xBEBFBC70);	//39、40
	HH(a, b, c, d, x[13],  4, 0x289B7EC6); HH(d, a, b, c, x[ 0], 11, 0xEAA127FA);	//41、42
	HH(c, d, a, b, x[ 3], 16, 0xD4EF3085); HH(b, c, d, a, x[ 6], 23, 0x04881D05);	//43、44
	HH(a, b, c, d, x[ 9],  4, 0xD9D4D039); HH(d, a, b, c, x[12], 11, 0xE6DB99E5);	//45、46
	HH(c, d, a, b, x[15], 16, 0x1FA27CF8); HH(b, c, d, a, x[ 2], 23, 0xC4AC5665);	//47、48

	II(a, b, c, d, x[ 0],  6, 0xF4292244); II(d, a, b, c, x[ 7], 10, 0x432AFF97);	//49、50
	II(c, d, a, b, x[14], 15, 0xAB9423A7); II(b, c, d, a, x[ 5], 21, 0xFC93A039);	//51、52
	II(a, b, c, d, x[12],  6, 0x655B59C3); II(d, a, b, c, x[ 3], 10, 0x8F0CCC92);	//53、54
	II(c, d, a, b, x[10], 15, 0xFFEFF47D); II(b, c, d, a, x[ 1], 21, 0x85845DD1);	//55、56
	II(a, b, c, d, x[ 8],  6, 0x6FA87E4F); II(d, a, b, c, x[15], 10, 0xFE2CE6E0);	//57、58
	II(c, d, a, b, x[ 6], 15, 0xA3014314); II(b, c, d, a, x[13], 21, 0x4E0811A1);	//59、60
	II(a, b, c, d, x[ 4],  6, 0xF7537E82); II(d, a, b, c, x[11], 10, 0xBD3AF235);	//61、62
	II(c, d, a, b, x[ 2], 15, 0x2AD7D2BB); II(b, c, d, a, x[ 9], 21, 0xEB86D391);	//63、64

	pResult[0] += a;
	pResult[1] += b;
	pResult[2] += c;
	pResult[3] += d;

	SetData((void *)x, 0, sizeof(x));
}