md4.cpp

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

#include "stdafx.h"
#include "MD4.h"

//=====================================================================================
//	Operation macros
//=====================================================================================
#define F(x, y, z)				(((x) & (y)) | ((~x) & (z)))
#define G(x, y, z)				(((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define H(x, y, z)				((x) ^ (y) ^ (z))
#define SHIFTLEFT(x, n)				(((x) << (n)) | ((x) >> (32-(n))))

#define FF(a, b, c, d, x, s)									\
{																\
	(a) += F((b), (c), (d)) + (x);								\
	(a) = SHIFTLEFT((a), (s));									\
}

#define GG(a, b, c, d, x, s)									\
{																\
	(a) += G((b), (c), (d)) + (x) + (U32)0x5A827999;			\
	(a) = SHIFTLEFT((a), (s));									\
}

#define HH(a, b, c, d, x, s)									\
{																\
	(a) += H((b), (c), (d)) + (x) + (U32)0x6ED9EBA1;			\
	(a) = SHIFTLEFT((a), (s));									\
}


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

MD4_CTX MD4_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 MD4_Transform(U32 *pResult, U8 *pData);

void MD4_Init(void)
{
	SetData((void *)(&MD4_Data), 0x00, sizeof(MD4_CTX));
	MD4_Data.state[0] = 0x67452301;
	MD4_Data.state[1] = 0xEFCDAB89;
	MD4_Data.state[2] = 0x98BADCFE;
	MD4_Data.state[3] = 0x10325476;
}

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

	index = (U32)((MD4_Data.count[0] >> 3) & 0x3F);
	if ((MD4_Data.count[0] += (size << 3)) < (size << 3))
	{
		MD4_Data.count[1]++;
	}
	MD4_Data.count[1] += (size >> 29);

	PartLen = 64 - index;

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

void MD4_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, MD4_Data.count, 8);

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

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

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

static void MD4_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);
	
	//Round 1
	FF(a, b, c, d, x[ 0],  3);
	FF(d, a, b, c, x[ 1],  7);
	FF(c, d, a, b, x[ 2], 11);
	FF(b, c, d, a, x[ 3], 19);
	FF(a, b, c, d, x[ 4],  3);
	FF(d, a, b, c, x[ 5],  7);
	FF(c, d, a, b, x[ 6], 11);
	FF(b, c, d, a, x[ 7], 19);
	FF(a, b, c, d, x[ 8],  3);
	FF(d, a, b, c, x[ 9],  7);
	FF(c, d, a, b, x[10], 11);
	FF(b, c, d, a, x[11], 19);
	FF(a, b, c, d, x[12],  3);
	FF(d, a, b, c, x[13],  7);
	FF(c, d, a, b, x[14], 11);
	FF(b, c, d, a, x[15], 19);

	//Round 2
	GG(a, b, c, d, x[ 0],  3);
	GG(d, a, b, c, x[ 4],  5);
	GG(c, d, a, b, x[ 8],  9);
	GG(b, c, d, a, x[12], 13);
	GG(a, b, c, d, x[ 1],  3);
	GG(d, a, b, c, x[ 5],  5);
	GG(c, d, a, b, x[ 9],  9);
	GG(b, c, d, a, x[13], 13);
	GG(a, b, c, d, x[ 2],  3);
	GG(d, a, b, c, x[ 6],  5);
	GG(c, d, a, b, x[10],  9);
	GG(b, c, d, a, x[14], 13);
	GG(a, b, c, d, x[ 3],  3);
	GG(d, a, b, c, x[ 7],  5);
	GG(c, d, a, b, x[11],  9);
	GG(b, c, d, a, x[15], 13);

	//Round 3
	HH(a, b, c, d, x[ 0],  3);
	HH(d, a, b, c, x[ 8],  9);
	HH(c, d, a, b, x[ 4], 11);
	HH(b, c, d, a, x[12], 15);
	HH(a, b, c, d, x[ 2],  3);
	HH(d, a, b, c, x[10],  9);
	HH(c, d, a, b, x[ 6], 11);
	HH(b, c, d, a, x[14], 15);
	HH(a, b, c, d, x[ 1],  3);
	HH(d, a, b, c, x[ 9],  9);
	HH(c, d, a, b, x[ 5], 11);
	HH(b, c, d, a, x[13], 15);
	HH(a, b, c, d, x[ 3],  3);
	HH(d, a, b, c, x[11],  9);
	HH(c, d, a, b, x[ 7], 11);
	HH(b, c, d, a, x[15], 15);
	
	pResult[0] += a;
	pResult[1] += b;
	pResult[2] += c;
	pResult[3] += d;

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