C语言实现MD5校验

根据网上资料，整理验证C程序代码。

接口函数：

 /******************************************************
 *函数名称:Compute_data_md5
 *输   入:data 校验数据首地址
         len 校验数据长度
         md5_str 字符串形式的MD5值
 *输   出:无
 *功   能:计算数据MD5值，并以字符串形式返回
 *******************************************************/
 int Compute_data_md5(unsigned char *data, unsigned int len,unsigned char *md5_str)

MD5.h 的内容：

 #ifndef _MD5_H_
 #define _MD5_H_

 #define MD5_SIZE        16
 #define MD5_STR_LEN        (MD5_SIZE * 2)

 typedef struct
 {
   unsigned int count[];
   unsigned int state[];
   unsigned char buffer[];
 } MD5_CTX;

 #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 ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))

 #define FF(a,b,c,d,x,s,ac) \
 { \
   a += F(b,c,d) + x + ac; \
   a = ROTATE_LEFT(a,s); \
   a += b; \
 }
 #define GG(a,b,c,d,x,s,ac) \
 { \
   a += G(b,c,d) + x + ac; \
   a = ROTATE_LEFT(a,s); \
   a += b; \
 }
 #define HH(a,b,c,d,x,s,ac) \
 { \
   a += H(b,c,d) + x + ac; \
   a = ROTATE_LEFT(a,s); \
   a += b; \
 }
 #define II(a,b,c,d,x,s,ac) \
 { \
   a += I(b,c,d) + x + ac; \
   a = ROTATE_LEFT(a,s); \
   a += b; \
 }
 void MD5Init(MD5_CTX *context);
 void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen);
 void MD5Final(MD5_CTX *context, unsigned char digest[]);
 void MD5Transform(unsigned int state[], unsigned char block[]);
 void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);
 void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);

 int Compute_data_md5(unsigned char *data, unsigned int len,unsigned char *md5_str);

 #endif

MD5.c 的内容：

 #include "md5.h"
 #include <memory.h>
 #include <stdio.h>

 unsigned char PADDING[] =
 {
   0x80,,,,,,,,,,,,,,,,
   ,,,,,,,,,,,,,,,,
   ,,,,,,,,,,,,,,,,
   ,,,,,,,,,,,,,,,
 };

 void MD5Init(MD5_CTX *context)
 {
   context->count[] = ;
   context->count[] = ;
   context->state[] = 0x67452301;
   context->state[] = 0xEFCDAB89;
   context->state[] = 0x98BADCFE;
   context->state[] = 0x10325476;
 }

 void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)
 {
   unsigned int i = ;
   unsigned int index = ;
   unsigned int partlen = ;

   index = (context->count[] >> ) & 0x3F;
   partlen =  - index;
   context->count[] += inputlen << ;

   if(context->count[] < (inputlen << ))
     context->count[]++;
   context->count[] += inputlen >> ;

   if(inputlen >= partlen)
   {
     memcpy(&context->buffer[index], input,partlen);
     MD5Transform(context->state, context->buffer);

     for(i = partlen; i+ <= inputlen; i+=)
       MD5Transform(context->state, &input[i]);

     index = ;
   }
   else
   {
     i = ;
   }
   memcpy(&context->buffer[index], &input[i], inputlen-i);
 }

 void MD5Final(MD5_CTX *context, unsigned char digest[])
 {
   unsigned int index = ,padlen = ;
   unsigned char bits[];

   index = (context->count[] >> ) & 0x3F;
   padlen = (index < )?(-index):(-index);
   MD5Encode(bits, context->count, );
   MD5Update(context, PADDING, padlen);
   MD5Update(context, bits, );
   MD5Encode(digest, context->state, );
 }

 void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
 {
   unsigned int i = ;
   unsigned int j = ;

   while(j < len)
   {
     output[j] = input[i] & 0xFF;
     output[j+] = (input[i] >> ) & 0xFF;
     output[j+] = (input[i] >> ) & 0xFF;
     output[j+] = (input[i] >> ) & 0xFF;
     i++;
     j += ;
   }
 }

 void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)
 {
   unsigned int i = ;
   unsigned int j = ;

   while(j < len)
   {
     output[i] = (input[j]) |
       (input[j+] << ) |
       (input[j+] << ) |
       (input[j+] << );
     i++;
     j += ;
   }
 }

 void MD5Transform(unsigned int state[], unsigned char block[])
 {
   unsigned int a = state[];
   unsigned int b = state[];
   unsigned int c = state[];
   unsigned int d = state[];
   unsigned int x[];

   MD5Decode(x,block,);

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

   /* Round 2 */
   GG(a, b, c, d, x[ ], , 0xf61e2562); /* 17 */
   GG(d, a, b, c, x[ ], , 0xc040b340); /* 18 */
   GG(c, d, a, b, x[], , 0x265e5a51); /* 19 */
   GG(b, c, d, a, x[ ], , 0xe9b6c7aa); /* 20 */
   GG(a, b, c, d, x[ ], , 0xd62f105d); /* 21 */
   GG(d, a, b, c, x[], ,  0x2441453); /* 22 */
   GG(c, d, a, b, x[], , 0xd8a1e681); /* 23 */
   GG(b, c, d, a, x[ ], , 0xe7d3fbc8); /* 24 */
   GG(a, b, c, d, x[ ], , 0x21e1cde6); /* 25 */
   GG(d, a, b, c, x[], , 0xc33707d6); /* 26 */
   GG(c, d, a, b, x[ ], , 0xf4d50d87); /* 27 */
   GG(b, c, d, a, x[ ], , 0x455a14ed); /* 28 */
   GG(a, b, c, d, x[], , 0xa9e3e905); /* 29 */
   GG(d, a, b, c, x[ ], , 0xfcefa3f8); /* 30 */
   GG(c, d, a, b, x[ ], , 0x676f02d9); /* 31 */
   GG(b, c, d, a, x[], , 0x8d2a4c8a); /* 32 */

   /* Round 3 */
   HH(a, b, c, d, x[ ], , 0xfffa3942); /* 33 */
   HH(d, a, b, c, x[ ], , 0x8771f681); /* 34 */
   HH(c, d, a, b, x[], , 0x6d9d6122); /* 35 */
   HH(b, c, d, a, x[], , 0xfde5380c); /* 36 */
   HH(a, b, c, d, x[ ], , 0xa4beea44); /* 37 */
   HH(d, a, b, c, x[ ], , 0x4bdecfa9); /* 38 */
   HH(c, d, a, b, x[ ], , 0xf6bb4b60); /* 39 */
   HH(b, c, d, a, x[], , 0xbebfbc70); /* 40 */
   HH(a, b, c, d, x[], , 0x289b7ec6); /* 41 */
   HH(d, a, b, c, x[ ], , 0xeaa127fa); /* 42 */
   HH(c, d, a, b, x[ ], , 0xd4ef3085); /* 43 */
   HH(b, c, d, a, x[ ], ,  0x4881d05); /* 44 */
   HH(a, b, c, d, x[ ], , 0xd9d4d039); /* 45 */
   HH(d, a, b, c, x[], , 0xe6db99e5); /* 46 */
   HH(c, d, a, b, x[], , 0x1fa27cf8); /* 47 */
   HH(b, c, d, a, x[ ], , 0xc4ac5665); /* 48 */

   /* Round 4 */
   II(a, b, c, d, x[ ], , 0xf4292244); /* 49 */
   II(d, a, b, c, x[ ], , 0x432aff97); /* 50 */
   II(c, d, a, b, x[], , 0xab9423a7); /* 51 */
   II(b, c, d, a, x[ ], , 0xfc93a039); /* 52 */
   II(a, b, c, d, x[], , 0x655b59c3); /* 53 */
   II(d, a, b, c, x[ ], , 0x8f0ccc92); /* 54 */
   II(c, d, a, b, x[], , 0xffeff47d); /* 55 */
   II(b, c, d, a, x[ ], , 0x85845dd1); /* 56 */
   II(a, b, c, d, x[ ], , 0x6fa87e4f); /* 57 */
   II(d, a, b, c, x[], , 0xfe2ce6e0); /* 58 */
   II(c, d, a, b, x[ ], , 0xa3014314); /* 59 */
   II(b, c, d, a, x[], , 0x4e0811a1); /* 60 */
   II(a, b, c, d, x[ ], , 0xf7537e82); /* 61 */
   II(d, a, b, c, x[], , 0xbd3af235); /* 62 */
   II(c, d, a, b, x[ ], , 0x2ad7d2bb); /* 63 */
   II(b, c, d, a, x[ ], , 0xeb86d391); /* 64 */
   state[] += a;
   state[] += b;
   state[] += c;
   state[] += d;
 }

 /******************************************************
 *函数名称:Compute_data_md5
 *输   入:data 校验数据首地址
         len 校验数据长度
         md5_str 字符串形式的MD5值
 *输   出:无
 *功   能:计算数据MD5值，并以字符串形式返回
 *******************************************************/
 int Compute_data_md5(unsigned char *data, unsigned int len,unsigned char *md5_str)
 {
     unsigned char md5_value[MD5_SIZE];
     unsigned int i = ;

     MD5_CTX md5;

     MD5Init(&md5);
     MD5Update(&md5, data, len);
     MD5Final(&md5, md5_value);
     for(i = ; i < MD5_SIZE; i++)
     {
         snprintf(md5_str + i*, +, "%02x", md5_value[i]);
     }
     md5_str[MD5_STR_LEN] = '\0'; // add end
 }

 #if 0
 int Compute_file_md5(const char *file_path, char *md5_str)
 {
   int i;
   int fd;
   int ret;
   unsigned char data[READ_DATA_SIZE];
   unsigned char md5_value[MD5_SIZE];
   MD5_CTX md5;

   fd = open(file_path, O_RDONLY);
   if (- == fd)
   {
     perror("open");
     return -;
   }

   // init md5
   MD5Init(&md5);

   while ()
   {
     ret = read(fd, data, READ_DATA_SIZE);
     if (- == ret)
     {
       perror("read");
       return -;
     }

     MD5Update(&md5, data, ret);

     if ( == ret || ret < READ_DATA_SIZE)
     {
       break;
     }
   }

   close(fd);

   MD5Final(&md5, md5_value);

   for(i = ; i < MD5_SIZE; i++)
   {
     snprintf(md5_str + i*, +, "%02x", md5_value[i]);
   }
   md5_str[MD5_STR_LEN] = '\0'; // add end

   return ;
 }
 #endif