md5.c

在S3C2440上运行的"电子日历“(支持平年,闰年,星期自动调整). 开发环境是RVDS2.2

/**---------------------File Info---------------------------------------------------------***
*** 创 建 人：          颜章健                                                            ***
*** 创建日期：          2008-03-04                                                        ***
*** 创建版本：                                                                            ***
*** 文件描述：          根据RSA数据安全公司MD5算法修改而成，版权归原作者所有              ***
***-------------------- readme -----------------------------------------------------------***
*** 	本软件允许被复制或运用，但必须在所有提及和参考的地方标注"RSA Data Security, Inc.  ***
*** MD5 Message-Digest Algorithm"也允许产生或运用派生软件，但必须在所有提及和参考的地方   ***
*** 标明"derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm"           ***
*** 	RSA数据安全公司（RSA Data Security, Inc.）从来没有出于任何特定目的陈述过关于此软  ***
*** 件的可买性和实用性，它提供了"as is",没有表达或暗示过任何理由。                        ***
*** 	此声明必须在任何此文件和软件的任何拷贝中保留。                                    ***
***---------------------------------------------------------------------------------------**/
#include "config.h"

//MD5_CTX MD5_CONTEXT;		// MD5 context 全局变量

/* Constants for MD5Transform routine. */
#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

static void MD5Transform 	(UINT4 state[4], uint8 block[64]);
static void Encode			(uint8 *output, UINT4 *input, uint32 len);
static void Decode			(UINT4 *output, uint8 *input, uint32 len);
static void MD5_memcpy 		(POINTER output, POINTER input, uint32 len);
static void MD5_memset 		(POINTER output, int32 value, uint32 len);

const uint8 PADDING[64] = 
{
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  
};

// F, G, H 和 I 是基本MD5函数 
#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)))

// ROTATE_LEFT 将x循环左移n位 
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

// 循环从加法中分离出是为了防止重复计算
#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);	}


/********************************************************************************************
*** 函数名称：			MD5Init
*** 函数描述：			MD5 初始化. 开始一个MD5操作写一个新的context			
********************************************************************************************/
void MD5Init (MD5_CTX *context)
{
	context->count[0] = context->count[1] = 0;
	context->state[0] = 0x67452301;
	context->state[1] = 0xefcdab89;
	context->state[2] = 0x98badcfe;
	context->state[3] = 0x10325476;
}

/********************************************************************************************
*** 函数名称：			MD5Update
*** 函数描述：			MD5 分组更新操作. 继续一个MD5操作,处理另一个消息分组并更新context
********************************************************************************************/
void MD5Update (MD5_CTX *context, uint8 *input, uint32 inputLen)
{
	uint32 i, index, partLen;

	// 计算字节数模64的值 
	index = (uint32)((context->count[0] >> 3) & 0x3F);

	// Update number of bits 
	if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3))
		context->count[1]++;
	context->count[1] += ((UINT4)inputLen >> 29);

	partLen = 64 - index;

	// 按能达到的最大次数转换
	if (inputLen >= partLen)
	{
		MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
		MD5Transform (context->state, context->buffer);

		for (i = partLen; i + 63 < inputLen; i += 64)
		MD5Transform (context->state, &input[i]);

		index = 0;
	}
	else	i = 0;

	// 缓冲器保留输入值
	MD5_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],  inputLen-i);
}

/********************************************************************************************
*** 函数名称：			MD5Final
*** 函数描述：			MD5 最终结果. 以一个 MD5 报文摘要操作结束, 写下报文摘要值
********************************************************************************************/
void MD5Final (MD5_CTX *context, uint8 digest[16])
{
	uint8 bits[8];
	uint32 index, padLen;

	// 保存位数值 
	Encode (bits, context->count, 8);
	index = (uint32)((context->count[0] >> 3) & 0x3f);
	padLen = (index < 56) ? (56 - index) : (120 - index);
	MD5Update (context, (uint8*)PADDING, padLen);

	// 附加长度 (在补位之前) 
	MD5Update (context, bits, 8);

	// 将 state 存入 digest 中
	Encode (digest, context->state, 16);
	MD5_memset ((POINTER)context, 0, sizeof (*context));
}

/********************************************************************************************
*** 函数名称：			MD5Check
*** 函数描述：			从原始数据直接计算MD5结果
*** 入    口：			*input：	原始数据指针
***						inputLen：	原始数据长度
***						output[16]:	MD5结果
*** 出    口：			无
*** 全局变量：			MD5_CONTEXT
*** 调用模块：			无
***
*** 创 建 人：			颜章健
*** 创建日期：			2008-03-04
*** 修 改 人：			
*** 修改日期：			
********************************************************************************************/
void MD5Check(uint8 *input, uint32 inputLen, uint8 output[16])
{
	MD5_CTX 	context;
	MD5Init 	(&context);
	MD5Update 	(&context, input, inputLen);
	MD5Final 	(&context, output);
}

/********************************************************************************************
*** 函数名称：			MD5Transform
*** 函数描述：			MD5基本转换. 转换状态基于分组
********************************************************************************************/
static void MD5Transform (UINT4 state[4], uint8 block[64])
{
	UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

	Decode (x, block, 64);

	// Round 1 
	FF (a, b, c, d, x[ 0], S11, 0xd76aa478); // 1 
	FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); // 2 
	FF (c, d, a, b, x[ 2], S13, 0x242070db); // 3 
	FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); // 4 
	FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); // 5 
	FF (d, a, b, c, x[ 5], S12, 0x4787c62a); // 6 
	FF (c, d, a, b, x[ 6], S13, 0xa8304613); // 7 
	FF (b, c, d, a, x[ 7], S14, 0xfd469501); // 8 
	FF (a, b, c, d, x[ 8], S11, 0x698098d8); // 9 
	FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); // 10
	FF (c, d, a, b, x[10], S13, 0xffff5bb1); // 11
	FF (b, c, d, a, x[11], S14, 0x895cd7be); // 12
	FF (a, b, c, d, x[12], S11, 0x6b901122); // 13
	FF (d, a, b, c, x[13], S12, 0xfd987193); // 14
	FF (c, d, a, b, x[14], S13, 0xa679438e); // 15
	FF (b, c, d, a, x[15], S14, 0x49b40821); // 16

	// Round 2
	GG (a, b, c, d, x[ 1], S21, 0xf61e2562); // 17
	GG (d, a, b, c, x[ 6], S22, 0xc040b340); // 18
	GG (c, d, a, b, x[11], S23, 0x265e5a51); // 19
	GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); // 20
	GG (a, b, c, d, x[ 5], S21, 0xd62f105d); // 21
	GG (d, a, b, c, x[10], S22,  0x2441453); // 22
	GG (c, d, a, b, x[15], S23, 0xd8a1e681); // 23
	GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); // 24
	GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); // 25
	GG (d, a, b, c, x[14], S22, 0xc33707d6); // 26
	GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); // 27
	GG (b, c, d, a, x[ 8], S24, 0x455a14ed); // 28
	GG (a, b, c, d, x[13], S21, 0xa9e3e905); // 29
	GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); // 30
	GG (c, d, a, b, x[ 7], S23, 0x676f02d9); // 31
	GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); // 32

	// Round 3
	HH (a, b, c, d, x[ 5], S31, 0xfffa3942); // 33
	HH (d, a, b, c, x[ 8], S32, 0x8771f681); // 34
	HH (c, d, a, b, x[11], S33, 0x6d9d6122); // 35
	HH (b, c, d, a, x[14], S34, 0xfde5380c); // 36
	HH (a, b, c, d, x[ 1], S31, 0xa4beea44); // 37
	HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); // 38
	HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); // 39
	HH (b, c, d, a, x[10], S34, 0xbebfbc70); // 40
	HH (a, b, c, d, x[13], S31, 0x289b7ec6); // 41
	HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); // 42
	HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); // 43
	HH (b, c, d, a, x[ 6], S34,  0x4881d05); // 44
	HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); // 45
	HH (d, a, b, c, x[12], S32, 0xe6db99e5); // 46
	HH (c, d, a, b, x[15], S33, 0x1fa27cf8); // 47
	HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); // 48

	// Round 4
	II (a, b, c, d, x[ 0], S41, 0xf4292244); // 49
	II (d, a, b, c, x[ 7], S42, 0x432aff97); // 50
	II (c, d, a, b, x[14], S43, 0xab9423a7); // 51
	II (b, c, d, a, x[ 5], S44, 0xfc93a039); // 52
	II (a, b, c, d, x[12], S41, 0x655b59c3); // 53
	II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); // 54
	II (c, d, a, b, x[10], S43, 0xffeff47d); // 55
	II (b, c, d, a, x[ 1], S44, 0x85845dd1); // 56
	II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); // 57
	II (d, a, b, c, x[15], S42, 0xfe2ce6e0); // 58
	II (c, d, a, b, x[ 6], S43, 0xa3014314); // 59
	II (b, c, d, a, x[13], S44, 0x4e0811a1); // 60
	II (a, b, c, d, x[ 4], S41, 0xf7537e82); // 61
	II (d, a, b, c, x[11], S42, 0xbd3af235); // 62
	II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); // 63
	II (b, c, d, a, x[ 9], S44, 0xeb86d391); // 64

	state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
  
	MD5_memset ((POINTER)x, 0, sizeof (x));
}

/********************************************************************************************
*** 函数名称：			Encode
*** 函数描述：			将输入（UINT4）编码输出(uint8). 假设len是4的倍数
********************************************************************************************/
static void Encode (uint8 *output, UINT4 *input, uint32 len)
{
	uint32 i, j;

	for (i=0, j=0; j<len; i++, j += 4)
	{
		output[j]   = (uint8)( input[i] &        0xff);
		output[j+1] = (uint8)((input[i] >> 8)  & 0xff);
		output[j+2] = (uint8)((input[i] >> 16) & 0xff);
		output[j+3] = (uint8)((input[i] >> 24) & 0xff);
	}
}

/********************************************************************************************
*** 函数名称：			Decode
*** 函数描述：			将输入(uint8)解码输出 (UINT4). 假设len是4的倍数
********************************************************************************************/
static void Decode (UINT4 *output, uint8 *input, uint32 len)
{
	uint32 i, j;

	for (i = 0, j = 0; j < len; i++, j += 4)
		output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
		(((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}

/********************************************************************************************
*** 函数名称：			MD5_memcpy
*** 函数描述：			缓冲区复制
********************************************************************************************/
static void MD5_memcpy (POINTER output, POINTER input, uint32 len)
{
	uint32 i;
	for (i = 0; i < len; i++)	output[i] = input[i];
}

/********************************************************************************************
*** 函数名称：			MD5_memset
*** 函数描述：			缓冲区清空
********************************************************************************************/
static void MD5_memset (POINTER output, int32 value, uint32 len)
{
	uint32 i;
	for (i = 0; i < len; i++)	((char *)output)[i] = (char)value;
}

/********************************************************************************************
*** 					文件结束														  ***	
********************************************************************************************/