MD5算法c语言实现

MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。

MD5的典型应用是对一段信息（Message）产生信息摘要（Message-Digest），以防止被篡改。MD5是基于消息摘要原理的，消息摘要的基本特征就是很难根据摘要推算出消息报文，因此要验证密码是否正确，就必须对输入密码（消息报文）重新计算其摘要，和数据库中存储的摘要进行对比（即数据库中存储的其实为用户密码的摘要），若两个摘要相同，则说明密码正确，不同，则说明密码错误。流程图如下所示：

MD5的应用：

1、一致性验证

MD5可以为任何文件（不管其大小、格式、数量）产生一个同样独一无二的“数字指纹”，如果任何人对文件做了任何改动，其MD5值也就是对应的“数字指纹”都会发生变化。

利用MD5算法来进行文件校验的方案被大量应用到软件下载站、论坛数据库、系统文件安全等方面。

2、数字签名

MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹），以防止被“篡改”。

举个例子，你将一段话写在一个叫 readme.txt文件中，并对这个readme.txt产生一个MD5的值并记录在案，然后你可以传播这个文件给别人，别人如果修改了文件中的任何内容，你对这个文件重新计算MD5时就会发现（两个MD5值不相同）。

如果再有一个第三方的认证机构，用MD5还可以防止文件作者的“抵赖”，这就是所谓的数字签名应用。

3、安全访问认证

MD5还广泛用于操作系统的登陆认证上，如Unix、各类BSD系统登录密码、数字签名等诸多方面。如在Unix系统中用户的密码是以MD5（或其它类似的算法）经Hash运算后存储在文件系统中

 

下面详细说明MD5的具体实现流程

步骤一：

我们是对一个字符串进行MD5加密，所以我们先从字符串的处理开始。首先我们要知道一个字符的长度是8位（bit），即一个字节的长度。

现在我们要做的就是将一个字符串Str1分割成每512位为一个分组，然后每512位为一个分组M[i]进行处理。形如N*512+R，最后多出来的不足512位的R部分先填充一个1，再接无数个0，直到补足512位。这里要注意，R为0时也要补位，这时候补512位，最高位1，形如1000…00；如果R超出448，除了要补满这个分组外，还要再补上一个512位的分组（因为超过448位则不能留64位出来存放字符串的原长）。

接着，讲讲将字符串分块保存部分。一个512位的字符串分组要分成16个32位的子分组，在每个32位中，以字节为单位通过小端规则存入一个32位的变量中，可以考虑用int类型的变量（一个int变量32位），也可以考虑用unsigned int，这样之后涉及的循环移位就不用考虑符号位了，这里还是以int为例。因为一个字符就是一个字节（8位），所以一个int类型变量能存放4个字符，假设一个字符串abcd，那么存在一个int类型变量中就是dcba。因此这里我们将字符串每4个字符分成一块，每一个块都以小端规则存放在一个int类型的变量中。

补充好后的Str2长度为（N+1）*512位（如果R超出448，则是（N+2）*512），str2的最后64位数据用于保存str的长度，所以如果R超过448之后就需要再补充一个512位数据，因为超过448末尾就没有64为空间可用，只能再添加一个512位的数据，此时最低的64位预留，用来存放之前str1的长度length（长度为字符个数*8 bit）的值，如果这个length值的二进制位数大于64位，则只保留最低的64位。将这个64位的length放入之前填充好的str2的最后64位又要注意了：将length的64位分成2个32位，相当于2个字（1个字32位），再将这个2个字用类似小端规则排列，分别填入预留的64位。之前我就是这点没有领悟，估计大家也不是很懂，我具体说明一下：假设64位分成AB（A,B分别表示32位的二进制数，A是高位，B是低位），按小端规则排列后就是BA，将形如BA的64位按B（高位）到A（低位）的顺序填入str2预留的64位,而对A，B内部显示的每个字节则不用做处理。假设长度 0x12，则按A,B两个字来补位可以得：A=0x0000 0000，B=0x0000 0012。

至此，补位的思想已经讲完了，这里再讲讲我的具体实现。我的思路是用一个长度为16的int类型的数组int M[16]。因为一个int类型数据有32位，16个加起来刚好一共512位，是一个分组的长度。我刚好就按顺序M[0]…M[15]表示一个512位的数。我再声明一个容器vector，用来存放每个M[16]，因为分组个数不一定只有一个。

最后我举个例子方便大家理解。首先介绍一些常识：a – 61, b – 62, c – 63, d – 64, e – 65。这里“a – 61”表示a的ASCII码十六进制表示是0x61，其他以此类推。

好，假设一个字符串abcde，一共5个字符，长度length 为 5* 8 = 40 = 0x28。512位转化成十六进制就是64位。原字符串十六进制表示：61 62 63 64 65 00 00…00。完成补位后共512位，只有1个分组，形如： 61 62 63 64 65 80 00…00 28 00 00 00 00 00 00 00（“80”的二进制是1000 0000，即之前的先补一个1，再补很多0的做法）。一个int M[16]的数组就够存了，即

M[0] = 64 63 62 61，

M[1] = 00 00 80 65，

M[2] = 0，

M[3] = 0

…

M[14] = 00 00 00 28，

M[15] = 0

步骤二：

MD5有四个32位的被称作链接变量的整数参数，我们进行如下设置：

        A=0x67452301，B=0xefcdab89，C=0x98badcfe，D=0x10325476。

数据这样设置之后，存在内存中就按小端规则排列：01 23 45 67 89 ab cd ef …32 10

再声明四个中间变量a,b,c,d，赋值：a = A, b = B, c = C, d = D。

接着再设置四个非线性函数：

                                    F(X,Y,Z) =(X&Y)|((~X)&Z)

                                    G(X,Y,Z) =(X&Z)|(Y&(~Z))

                                    H(X,Y,Z) =X^Y^Z

                                    I(X,Y,Z)=Y^(X|(~Z))

这四个函数的说明：如果X、Y和Z的对应位是独立和均匀的，那么结果的每一位也应是独立和均匀的。

FF(a,b,c,d,Mj,s,ti)表示a=b+((a+F(b,c,d)+Mj+ti)<<s)  

GG(a,b,c,d,Mj,s,ti)表示a=b+((a+G(b,c,d)+Mj+ti)<<s)  

HH(a,b,c,d,Mj,s,ti)表示a=b+((a+H(b,c,d)+Mj+ti)<<s)  

II(a,b,c,d,Mj,s,ti)表示a=b+((a+I(b,c,d)+Mj+ti)<<s)

 步骤3：接下来就是要进行一个MD5算法的主要循环了，这个循环的循环次数为512位分组的个数（即之前提到的N+1或者N+2）。每次循环执行以下的步骤，我就不用文字表述了，直接用代码展示，相信大家能理解：

{
    a = A; b = B; c = C; d = D;
    //传说中的对M[j]的第一轮循环
    FF(a,b,c,d,M[0],7,0xd76aa478);
    FF(d,a,b,c,M[1],12,0xe8c7b756);
    FF(c,d,a,b,M[2],17,0x242070db);
    FF(b,c,d,a,M[3],22,0xc1bdceee);
    FF(a,b,c,d,M[4],7,0xf57c0faf);
    FF(d,a,b,c,M[5],12,0x4787c62a);
    FF(c,d,a,b,M[6],17,0xa8304613);
    FF(b,c,d,a,M[7],22,0xfd469501) ;
    FF(a,b,c,d,M[8],7,0x698098d8) ;
    FF(d,a,b,c,M[9],12,0x8b44f7af) ;
    FF(c,d,a,b,M[10],17,0xffff5bb1) ;
    FF(b,c,d,a,M[11],22,0x895cd7be) ;
    FF(a,b,c,d,M[12],7,0x6b901122) ;
    FF(d,a,b,c,M[13],12,0xfd987193) ;
    FF(c,d,a,b,M[14],17,0xa679438e) ;
    FF(b,c,d,a,M[15],22,0x49b40821);

    //传说中对M[j]的第二轮循环
    GG(a,b,c,d,M[1],5,0xf61e2562);
    GG(d,a,b,c,M[6],9,0xc040b340);
    GG(c,d,a,b,M[11],14,0x265e5a51);
    GG(b,c,d,a,M[0],20,0xe9b6c7aa) ;
    GG(a,b,c,d,M[5],5,0xd62f105d) ;
    GG(d,a,b,c,M[10],9,0x02441453) ;
    GG(c,d,a,b,M[15],14,0xd8a1e681);
    GG(b,c,d,a,M[4],20,0xe7d3fbc8) ;
    GG(a,b,c,d,M[9],5,0x21e1cde6) ;
    GG(d,a,b,c,M[14],9,0xc33707d6) ;
    GG(c,d,a,b,M[3],14,0xf4d50d87) ;
    GG(b,c,d,a,M[8],20,0x455a14ed);
    GG(a,b,c,d,M[13],5,0xa9e3e905);
    GG(d,a,b,c,M[2],9,0xfcefa3f8) ;
    GG(c,d,a,b,M[7],14,0x676f02d9) ;
    GG(b,c,d,a,M[12],20,0x8d2a4c8a);

    //传说中对M[j]的第三轮循环
    HH(a,b,c,d,M[5],4,0xfffa3942);
    HH(d,a,b,c,M[8],11,0x8771f681);
    HH(c,d,a,b,M[11],16,0x6d9d6122);
    HH(b,c,d,a,M[14],23,0xfde5380c) ;
    HH(a,b,c,d,M[1],4,0xa4beea44) ;
    HH(d,a,b,c,M[4],11,0x4bdecfa9) ;
    HH(c,d,a,b,M[7],16,0xf6bb4b60) ;
    HH(b,c,d,a,M[10],23,0xbebfbc70);
    HH(a,b,c,d,M[13],4,0x289b7ec6);
    HH(d,a,b,c,M[0],11,0xeaa127fa);
    HH(c,d,a,b,M[3],16,0xd4ef3085);
    HH(b,c,d,a,M[6],23,0x04881d05);
    HH(a,b,c,d,M[9],4,0xd9d4d039);
    HH(d,a,b,c,M[12],11,0xe6db99e5);
    HH(c,d,a,b,M[15],16,0x1fa27cf8) ;
    HH(b,c,d,a,M[2],23,0xc4ac5665);

    //传说中对M[j]的第四轮循环
    II(a,b,c,d,M[0],6,0xf4292244) ;
    II(d,a,b,c,M[7],10,0x432aff97) ;
    II(c,d,a,b,M[14],15,0xab9423a7);
    II(b,c,d,a,M[5],21,0xfc93a039) ;
    II(a,b,c,d,M[12],6,0x655b59c3) ;
    II(d,a,b,c,M[3],10,0x8f0ccc92) ;
    II(c,d,a,b,M[10],15,0xffeff47d);
    II(b,c,d,a,M[1],21,0x85845dd1) ;
    II(a,b,c,d,M[8],6,0x6fa87e4f) ;
    II(d,a,b,c,M[15],10,0xfe2ce6e0);
    II(c,d,a,b,M[6],15,0xa3014314) ;
    II(b,c,d,a,M[13],21,0x4e0811a1);
    II(a,b,c,d,M[4],6,0xf7537e82) ;
    II(d,a,b,c,M[11],10,0xbd3af235);
    II(c,d,a,b,M[2],15,0x2ad7d2bb);
    II(b,c,d,a,M[9],21,0xeb86d391);

    A += a;
    B += b;
    C += c;
    D += d;
｝

步骤4：处理完所有的512位的分组后，得到一组新的A,B,C,D的值，将这些值按ABCD的顺序级联，然后输出。这里还要注意，输出的MD5是按内存中数值的排列顺序，所以我们要分别对A,B,C,D的值做一个小端规则的转换。举个例子：A有32位，分成4个字节A1A2A3A4。输出A的时候，要这样输出：A4A3 A2A1。这样就能输出正确的MD5了。

下面贴出md5的代码实现过程

#include <memory.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct
{
    unsigned int count[2];
    unsigned int state[4];
    unsigned char buffer[64];
}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[16]);
void MD5Transform(unsigned int state[4],unsigned char block[64]);
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len);
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len);

unsigned char PADDING[]={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};

void MD5Init(MD5_CTX *context)
{
     context->count[0] = 0;
     context->count[1] = 0;
     context->state[0] = 0x67452301;
     context->state[1] = 0xEFCDAB89;
     context->state[2] = 0x98BADCFE;
     context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen)
{
    unsigned int i = 0,index = 0,partlen = 0;
    index = (context->count[0] >> 3) & 0x3F;
    partlen = 64 - index;

    context->count[0] += inputlen << 3;
    if(context->count[0] < (inputlen << 3))
       context->count[1]++;
    context->count[1] += inputlen >> 29;

    if(inputlen >= partlen){
       memcpy(&context->buffer[index],input,partlen);
       MD5Transform(context->state,context->buffer);
       for(i = partlen;i+64 <= inputlen;i+=64)
           MD5Transform(context->state,&input[i]);
       index = 0;
    }else {
        i = 0;
    }
    memcpy(&context->buffer[index],&input[i],inputlen-i);
}
void MD5Final(MD5_CTX *context,unsigned char digest[16])
{
    unsigned int index = 0,padlen = 0;
    unsigned char bits[8];
    index = (context->count[0] >> 3) & 0x3F;
    padlen = (index < 56)?(56-index):(120-index);
    MD5Encode(bits,context->count,8);
    MD5Update(context,PADDING,padlen);
    MD5Update(context,bits,8);
    MD5Encode(digest,context->state,16);
}
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
    unsigned int i = 0,j = 0;
    while(j < len) {
         output[j] = input[i] & 0xFF;
         output[j+1] = (input[i] >> 8) & 0xFF;
         output[j+2] = (input[i] >> 16) & 0xFF;
         output[j+3] = (input[i] >> 24) & 0xFF;
         i++;
         j+=4;
    }
}
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len)
{
     unsigned int i = 0,j = 0;
     while(j < len){
           output[i] = (input[j]) |
                       (input[j+1] << 8) |
                       (input[j+2] << 16) |
                       (input[j+3] << 24);
           i++;
           j+=4;
     }
}
void MD5Transform(unsigned int state[4],unsigned char block[64])
{
     unsigned int a = state[0];
     unsigned int b = state[1];
     unsigned int c = state[2];
     unsigned int d = state[3];
     unsigned int x[64];
     MD5Decode(x,block,64);
     FF(a, b, c, d, x[ 0], 7, 0xd76aa478); /* 1 */
     FF(d, a, b, c, x[ 1], 12, 0xe8c7b756); /* 2 */
     FF(c, d, a, b, x[ 2], 17, 0x242070db); /* 3 */
     FF(b, c, d, a, x[ 3], 22, 0xc1bdceee); /* 4 */
     FF(a, b, c, d, x[ 4], 7, 0xf57c0faf); /* 5 */
     FF(d, a, b, c, x[ 5], 12, 0x4787c62a); /* 6 */
     FF(c, d, a, b, x[ 6], 17, 0xa8304613); /* 7 */
     FF(b, c, d, a, x[ 7], 22, 0xfd469501); /* 8 */
     FF(a, b, c, d, x[ 8], 7, 0x698098d8); /* 9 */
     FF(d, a, b, c, x[ 9], 12, 0x8b44f7af); /* 10 */
     FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */
     FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */
     FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */
     FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */
     FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */
     FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 */

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

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

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

int main(int argc, char *argv[])
{
	int i;
	unsigned char encrypt[] ="admin";//21232f297a57a5a743894a0e4a801fc3
	unsigned char decrypt[16];
	MD5_CTX md5;
	MD5Init(&md5);
	MD5Update(&md5,encrypt,strlen((char *)encrypt));
	MD5Final(&md5,decrypt);
	printf("Before encryption:%s\nAfter encryption:",encrypt);
	for(i=0;i<16;i++){
		printf("%02x",decrypt[i]);
	}

	return 0;
}