MD5哈希算法学习

一、哈希函数简介
    信息安全的核心技术是应用密码技术。密码技术的应用远不止局限于提供机密性服务，密码技术也提供数据完整性服务。密码学上的散列函数(Hash Functions)就是能提供数据完整性保障的一个重要工具。Hash函数常用来构造数据的短“指纹”，消息的发送者使用所有的消息产生一个短“指纹”，并将该短“指纹”与消息一起传输给接收者。即使数据存储在不安全的地方，接收者重新计算数据的指纹，并验证指纹是否改变，就能够检测数据的完整性。这是因为一旦数据在中途被破坏或改变，短指纹就不再正确。
    散列函数是一个函数，它以一个变长的报文作为输入，并产生一个定长的散列码，有时也称为报文摘要，作为函数的输出。散列函数最主要的作用是用于鉴别，鉴别在网络安全中起到举足轻重的地位。鉴别的目的有以下两个：第一，验证信息的发送者不是冒充的，同时发信息者也不能抵赖，此为信源识别；第二，验证信息完整性，在传递或存储过程中未被篡改，重放或延迟等。

二、MD5哈希算法流程 
    对于任意长度的明文，MD5首先对其进行分组，使得每一组的长度为512位，然后对这些明文分组反复重复处理。
    对于每个明文分组的摘要生成过程如下：
    （1）将512位的明文分组划分为16个子明文分组，每个子明文分组为32位。
    （2）申请4个32位的链接变量，记为A、B、C、D。
    （3）子明文分组与链接变量进行第1轮运算。
    （4）子明文分组与链接变量进行第2轮运算。
    （5）子明文分组与链接变量进行第3轮运算。
    （6）子明文分组与链接变量进行第4轮运算。
    （7）链接变量与初始链接变量进行求和运算。
    （8）链接变量作为下一个明文分组的输入重复进行以上操作。
    （9）最后，4个链接变量里面的数据就是MD5摘要。
三、MD5分组过程
    对于任意长度的明文，MD5可以产生128位的摘要。任意长度的明文首先需要添加位数，使明文总长度为448（mod512）位。在明文后添加位的方法是第一个添加位是l，其余都是0。然后将真正明文的长度（没有添加位以前的明文长度）以64位表示，附加于前面已添加过位的明文后，此时的明文长度正好是512位的倍数。当明文长度大于2的64次方时，仅仅使用低64位比特填充，附加到最后一个分组的末尾。
    经过添加处理的明文，其长度正好为512位（64个字节）的整数倍，然后按512位的长度进行分组（block），可以划分成L份明文分组，我们用Y0，Y1，……，YL-1表示这些明文分组。对于每一个明文分组，都要重复反复的处理，如图1-1所示。

图1-1  MD5的分组处理方法

四、MD5子明文分组和链接变量
    对于512位的明文分组，MD5将其再分成16份子明文分组（sub-block），每份子明文分组为32位，我们使用M[k]（k= 0, 1,……15）来表示这16份子明文分组。这里的概念要弄清楚，一个添加位后的明文可以划分为L份明文分组，而一个明文分组又可以划分为16份子明文分组。
    MD5有4轮非常相似的运算，每一轮包括16个类似的步骤，每一个步骤的数据处理都是针对4个32位记录单元中的数据进行的。这4个链接变量的初始值以16进位制表示如下（低字节优先）A：0x01234567，B：0x89ABCDEF，C：0xFEDCBA98，D：0x76543210，这时A、B、C、D四个链接变量的值为：A=0x67452301，B=0xEFCDAB89，C=0x98BADCFE，D=0x10325476。链接变量用于存放中间散列函数值，经过4轮运算（共64个步骤）之后，链接变量A，B，C，D中的128位即为中间散列函数值。中间散列函数值作为下一个明文分组的输入继续使用，当所有的明文分组都处理完毕后，链接变量A，B，C，D中的128位数据就是摘要。
五、MD5第1轮运算
    MD5有4轮非常相似的运算，每一轮包括16个类似的步骤，当第1轮运算中的第1步骤开始处理时，A、B、C、D四个链接变量中的值先赋值到另外4个记录单元A′，B′，C′，D′中。这4个值将保留，用于在第4轮的最后一个步骤完成之后与A，B，C，D进行求和操作。
    第1轮的操作程序为FF(a,b,c,d,M[k],S,T[i])
    它表示的逻辑为：a←b+((a+F(b,c,d)+M[k]+T[i])<<<S)
    其中，a、b、c、d为32位的变量，M[k]表示相应的子明文分组，对于4轮共64步的MD5算法中T[i]是64个不同的固定的数值，S为循环左移的位数，F（x，y，z）是第一轮的逻辑函数，最后将结果存放在链接变量A中，固定值T[i]，循环左移位数和逻辑函数将在以后讨论。
    第1轮16步的固定值T[i]的取值如表1-2所示。

表8-1-2  MD5第1轮固定数T

T[1]=D76AA478

T[5]=F57C0FAF

T[9]=698098D8

T[13]=6B901122

T[2]=E8C7B756

T[6]=4787C62A

T[10]=8B44F7AF

T[14]=FD987193

T[3]=242070DB

T[7]=A8304613

T[11]=FFFF5BB1

T[15]=A679438E

T[4]=C1BDCEEE

T[8]=FD469501

T[12]=895CD7BE

T[16]=49B40821

    MD5规定，第一轮的16步的操作程序如表1-3所示。

表1-3  MD5第1轮16步运算

步骤数

运算

1

FF(A,B,C,D,M[0],7,0xD76AA478)

2

FF(D,A,B,C,M[1],12,0xE8C7B756)

3

FF(C,D,A,B,M[2],17,0x242070DB)

4

FF(B,C,D,A,M[3],22,0xC1BDCEEE)

5

FF(A,B,C,D,M[4],7,0xF57C0FAF)

6

FF(D,A,B,C,M[5],12,0x4787C62A)

7

FF(C,D,A,B,M[6],17,0xA8304613)

8

FF(B,C,D,A,M[7],22,0xFD469501)

9

FF(A,B,C,D,M[8],7,0x698098D8)

10

FF(D,A,B,C,M[9],12,0x8B44F7AF)

11

FF(C,D,A,B,M[10],17,0xFFFF5BB1)

12

FF(B,C,D,A,M[11],22,0x895CD7BE)

13

FF(A,B,C,D,M[12],7,0x6B901122)

14

FF(D,A,B,C,M[13],12,0xFD987193)

15

FF(C,D,A,B,M[14],17,0xA6794383)

16

FF(B,C,D,A,M[15],22,0x49B40821)

    MD5算法中，第一轮的逻辑函数为F（x，y，z）= ( x & y )|( ~x & z )，MD5的算法比较复杂，每一轮包括16步类似的运算，下面我们以第1轮的第1步和第2步为例来展示每一步的运算。
    例如，子明文分组M[0] = 0x4368696E，第1轮的操作程序为FF(a,b,c,d,M[k],S,T[i])，它表示的逻辑为：
    a←b+((a+F(b,c,d)+M[k]+T[i])<<<S)
    第一轮的逻辑函数F（x，y，z）= ( x & y )|( ~x & z )，由表1-3知，第1轮第1步的运算为：FF(A,B,C,D,M[0],7,0xD76AA478)，注意到这里的0xD76AA478就是T[1]的值，变量a、b、c、d分别代表链接变量A、B、C、D。首先，b、c、d要经过逻辑函数F，即:

    然后得到的值要与A、M[0]和T[1]相加得0x67452301+0x98BADCFE+0x6E696843+0xD76AA478 = 0x45D40CBA，0x45D40CBA要循环左移7位，得到结果：0xEA065D22，0xEA065D22与b相加得：0xEA065D22 + 0xEFCDAB89 = 0xD9D408AB，最后，将这个结果赋值给a，第1步的计算就完成了，只有链接变量A发生了改变，这时链接标量的值为：
    A = 0xD9D408AB
    B = 0x89ABCDEF
    C = 0xFEDCBA98
    D = 0x76543210
    经过16个步骤之后，MD5的第一轮运算就完成了，链接变量A、B、C、D将携带第1轮运算后的数值进入第二轮运算。
六、MD5后3轮运算
    MD5第2轮、第3轮和第4轮算运与第一轮运算相似，这里给出相应的操作程序、固定数T、每一步运算和逻辑函数。
    第2轮的逻辑函数为：G( x, y, z ) = ( x & z )|( y & ~z )。
    第3轮的逻辑函数为：H( x, y, z ) = x⊕y⊕z。
    第4轮的逻辑函数为：I( x, y, z ) = y⊕( x & ~z )。
    第2轮的操作程序为：GG(A,B,C,D,M[k],S,T[i])。
    它表示的逻辑为：a←b+((a+G(B,C,D)+M[k]+T[i])<<<S)。
    第3轮的操作程序为：HH(A,B,C,D,M[k],S,T[i])。
    它表示的逻辑为：a←b+((a+H(B,C,D)+M[k]+T[i])<<<S)。
    第4轮的操作程序为：II(A,B,C,D,M[k],S,T[i])。
    它表示的逻辑为：a←b+((a+I(B,C,D)+M[k]+T[i])<<<S)。
    后3轮的每个步骤的运算如表1-4所示。

表1-4  MD5后3轮16步运算

第二轮

1

GG(A,B,C,D,M[1],5,0xF61E2562)

2

GG(D,A,B,C,M[6],9,0xC040B340)

3

GG(C,D,A,B,M[11],14,0x275E5A51)

4

GG(B,C,D,A,M[0],20,0xE9B6C7AA)

5

GG(A,B,C,D,M[5],5,0xD62F105D)

6

GG(D,A,B,C,M[10],9,0x02441453)

7

GG(C,D,A,B,M[15],14,0xD8A1E681)

8

GG(B,C,D,A,M[4],20,0xE7D3FBC8)

9

GG(A,B,C,D,M[9],5,0x21E1CDE6)

10

GG(D,A,B,C,M[14],9,0xC33707D6)

11

GG(C,D,A,B,M[3],14,0xF4D50D87)

12

GG(B,C,D,A,M[8],20,0x455A14ED)

13

GG(A,B,C,D,M[13],5,0xA9E3E905)

14

GG(D,A,B,C,M[2],9,0xFCEFA3F8)

15

GG(C,D,A,B,M[7],14,0x676F02D9)

16

GG(B,C,D,A,M[12],20,0x8D2A4C8A)

第三轮

1

HH(A,B,C,D,M[5],4,0xFFFA3942)

2

HH(D,A,B,C,M[8],11,0x8771F681)

3

HH(C,D,A,B,M[11],16,0x6D9D6122)

4

HH(B,C,D,A,M[14],23,0xFDE5380C)

5

HH(A,B,C,D,M[1],4,0xA4BEEA44)

6

HH(D,A,B,C,M[4],11,0x4BDECFA9)

7

HH(C,D,A,B,M[7],16,0xF6BB4B60)

8

HH(B,C,D,A,M[10],23,0xBEBFBC70)

9

HH(A,B,C,D,M[13],4,0x289B7EC6)

10

HH(D,A,B,C,M[0],11,0xEAA127FA)

11

HH(C,D,A,B,M[3],16,0xD4EF3085)

12

HH(B,C,D,A,M[6],23,0x04881D05)

13

HH(A,B,C,D,M[9],4,0xD9D4D039)

14

HH(D,A,B,C,M[12],11,0xE6DB99E5)

15

HH(C,D,A,B,M[15],16,0x1FA27CF8)

16

HH(B,C,D,A,M[2],23,0xC4AC5665)

第四轮

1

II(A,B,C,D,M[0],6,0xF4292244)

2

II(D,A,B,C,M[7],10,0x411AFF97)

3

II(C,D,A,B,M[14],15,0xAB9423A7)

4

II(B,C,D,A,M[5],21,0xFC93A039)

5

II(A,B,C,D,M[12],6,0x655B59C3)

6

II(D,A,B,C,M[3],10,0x8F0CCC92)

7

II(C,D,A,B,M[10],15,0xFFEFF47D)

8

II(B,C,D,A,M[1],21,0x85845DD1)

9

II(A,B,C,D,M[8],6,0x6AFA87E4F)

10

II(D,A,B,C,M[15],10,0xFE2CE6E0)

11

II(C,D,A,B,M[6],15,0xA3014314)

12

II(B,C,D,A,M[13],21,0x4E0811A1)

13

II(A,B,C,D,M[4],6,0xF7537E82)

14

II(D,A,B,C,M[11],10,0xBD3AF235)

15

II(C,D,A,B,M[2],15,0x2AD7D2BB)

16

II(B,C,D,A,M[9],21,0xEB86D391

    后3轮的固定数T[i]的值如表1-5所示。

表1-5  后3轮的固定数T[i]

T[17]=F61E2562

T[33]=FFFA3942

T[49]=F4292244

T[18]=C040B340

T[34]=8771F681

T[50]=432AFF97

T[19]=265E5A51

T[35]=699D6122

T[51]=AB9423A7

T[20]=E9B6C7AA

T[36]=FDE5380C

T[52]=FC93A039

T[21]=D62F105D

T[37]=A4BEEA44

T[53]=655B59C3

T[22]=02441453

T[38]=4BDECFA9

T[54]=8F0CCC92

T[23]=D8A1E681

T[39]=F6BB4B60

T[55]=FFEFF47D

T[24]=E7D3FBC8

T[40]=BEBFBC70

T[56]=85845DD1

T[25]=21E1CDE6

T[41]=289B7EC6

T[57]=6FA87E4F

T[26]=C33707D6

T[42]=EAA127FA

T[58]=FE2CE6E0

T[27]=F4D50D87

T[43]=D4EF3085

T[59]=A3014314

T[28]=455A14ED

T[44]=04881D05

T[60]=4E0811A1

T[29]=A9E3E905

T[45]=D9D4D039

T[61]=F7657E82

T[30]=FCEEA3F8

T[46]=E6DB99E5

T[62]=BD3AF235

T[31]=676F02D9

T[47]=1FA27CF8

T[63]=2AD7D2BB

T[32]=8D2A4C8A

T[48]=C4AC5665

T[64]=EB86D391

七、求和运算
    第四轮最后一步骤的A，B，C，D输出，将分别与A′，B′，C′，D′记录单元中数值进行求和操作。其结果将成为处理下一个512位明文分组时记录单元A，B，C，D的初始值。当完成了最后一个明文分组运算时，A，B，C，D中的数值就是最后的散列函数值。

八、程序的实现

补充说明：

明文信息的读取、填充：
（1）将需加密的信件信息（如一份文件）分次读取到缓冲区中，一次最好读取64*n 个字节，这样就是n 组，方便处理。
（2） 判断信息是否已全部读完，没有则对刚才读取的信息分组进行计算，如果已经读完了就要在信息尾部进行适当的填充。
（3）对信息进行填充，使其字节数除以64 （512位）时余数为56（448位）。比如在处理一个文件时,
（4）最后一次读取为70 字节，70％64＝6 小于56，则需在尾部填充56－6＝50 个字节，得（70＋50）％64＝56。注：若消息为64n 倍数字节，则最后一次读取0 字节，据本规则将填充56 字节。
（5）最后一次读取为124 字节，124％64＝60 大于56 了，则先将这一组填满（此处为4 字节）再
在下一组空间上填56 个字节，得（124＋4＋56）％64＝56。（64-124%64+56）

#include <stdio.h>#include <string.h>#include <stdlib.h>//! 定义MD5状态数据结构类型typedef struct{    unsigned   int      state[4];// 初始链接变量;保存16字节摘要    unsigned   int      count[2];// 明文位数(用64位保存，count[0]表示低32位，count[1]表示高32位)    unsigned charPADDING[64];// 填充位，最大64*8位    unsigned charbuffer[64];// 输入缓冲（暂存512位明文）}MD5_State;//! F, G, H and 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)))//! 将x循环左移n位#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))//! 4轮运算中FF(第1轮), GG(第2轮), HH(第3轮), and II(第4轮)转换void FF(unsigned int &a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,unsigned int s,unsigned ac){    a += F ((b), (c), (d)) + (x) + (unsigned  int)(ac);    a = ROTATE_LEFT ((a), (s));    a+= (b);}void GG(unsigned int &a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,unsigned int s,unsigned ac){    a += G ((b), (c), (d)) + (x) + (unsigned  int)(ac);    a = ROTATE_LEFT ((a), (s));    a += (b);}void HH(unsigned int &a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,unsigned int s,unsigned ac){    a += H ((b), (c), (d)) + (x) + (unsigned  int)(ac);    a = ROTATE_LEFT ((a), (s));    a+= (b);}void II(unsigned int &a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,unsigned int s,unsigned ac){    a += I ((b), (c), (d)) + (x) + (unsigned  int)(ac);    a = ROTATE_LEFT ((a), (s));    a += (b);}/******************************************************************************///名称：Encode//功能：数据类型轮换(unsigned  long int -> unsigned char)(未处理前明文的长度转换)//  参数：output:指向unsigned char类型输出缓冲区// input:指向unsigned long int/******************************************************************************/void Encode( unsigned char *output, unsigned   int *input, unsigned int len ){    //unsigned   int为32位，需要转换存到指定char数组中    unsigned int i, j;    for(i = 0, j = 0; j < len; i++, j += 4)    {        output[j] =   (unsigned char)(input[i] & 0xff);        //长度的低8位（一个字节）        output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); //长度的中间8位        output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);//次高8位        output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);//高8位    }}/******************************************************************************///功能：数据类型转换(unsigned char -> unsigned  int)（进行子明文分组（512位分成16组，每组32位））//参数： output:指向unsigned int类型输入缓冲区//input:指向unsigned char/******************************************************************************/void Decode( unsigned  int *output, unsigned char *input, unsigned int len ){    //将明文（char 数组）的每32位为一组存到一个32位的unsigned  int数组中，后面将会用来做运算    unsigned int i, j;    for( i=0, j=0; j<len; i++, j+=4 )    {        output[i] = ((unsigned  int)input[j]) | (((unsigned  int)input[j+1]) << 8) |                    (((unsigned  int)input[j+2]) << 16) | (((unsigned  int)input[j+3]) << 24);    }}/******************************************************************************///名称：MD5Init//功能：初始链接变量赋值；初始化填充位//   参数：指向MD5状态数据变量//返回：无//   备注：填充位第1位为1,其余位为0/******************************************************************************/void MD5_Init( MD5_State *s ){    s->count[0] = s->count[1] = 0;    //! 初始链接变量    s->state[0] = 0x67452301;    s->state[1] = 0xefcdab89;    s->state[2] = 0x98badcfe;    s->state[3] = 0x10325476;        //! 初始填充位(目标形式: 0x80000000......，共计512位)    memset( s->PADDING, 0, sizeof(s->PADDING) );    *(s->PADDING)=0x80;  //第一位为1，其余为0（1000 0000 0000 0000 0000 0000 ....）    //  s->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};}/******************************************************************************///名称：MD5Transform//功能：MD5 4轮运算//  参数：state: 链接变量；block: 子明文分组//返回：无//  备注：4轮共计64步运算/******************************************************************************/void MD5_Transform( unsigned   int state[4], unsigned char block[64] ){    unsigned  int a = state[0], b = state[1], c = state[2], d = state[3], x[16];        Decode( x, block, 64 );  //对512位明文分成16组        //! 第1轮        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        //! 第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        //! 第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        //! 第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;        memset( (unsigned char*)x, 0, sizeof (x) );}/******************************************************************************///名称：MD5_Update//功能：明文填充，明文分组，16个子明文分组//  参数：指向SHA状态变量//返回：无/******************************************************************************/void MD5_Update( MD5_State *s, unsigned char *input, unsigned int inputLen ){    unsigned int i, index, partLen;        //! 明文填充        //! 字节数 mod 64（当前拥有的明文字节数）    index = (unsigned int)((s->count[0] >> 3) & 0x3F);//一个字符一个字节占8位（count里面存的是位数，所以需要转换为字节数）    //index = (unsigned int)((s->count[0] >> 3)%64);        //! 更新位数    if((unsigned long int)(s->count[0] += ((unsigned long int)inputLen <<3))< ((unsigned long int)inputLen << 3))//inputLen是字节数，转换为位数比较    {        //发生溢出，则需要进位(无符号数其Max值+1==0)        s->count[1]++; //进位    }    s->count[1] += ((unsigned  int)inputLen >> 29);    //输入的高位字节数 inputlen*8 >> 32    partLen = 64 - index; //还差的明文字节数        //! MD5 4轮运算    if (inputLen >= partLen) //如果明文字符串长度能提供还差的字符长度，则继续执行    {        memcpy( (unsigned char*)&s->buffer[index],  (unsigned char*)input, partLen ); //将还差的明文拷到缓冲区，等待处理        MD5_Transform( s->state, s->buffer );   //处理                for( i = partLen; i + 63 < inputLen; i += 64 ) //查找是否存在下一个64字节的明文            MD5_Transform( s->state, &input[i] );      //有则继续处理                index = 0;    }    else        i = 0;        memcpy ((unsigned char*)&s->buffer[index], (unsigned char*)&input[i], inputLen-i); //对不够64字节的明文字符串，先拷到缓冲区等待构建完整的512位明文}/******************************************************************************///名称：MD5_Final//功能：MD5最后变换//  参数：strContent:指向文件内容缓冲区; iLength:文件内容长度; output:摘要输出缓冲区//返回：无/******************************************************************************/void MD5_Final( MD5_State *s, unsigned char digest[16] ){    unsigned char bits[8];      //记录未处理前的明文的长度    unsigned int index, padLen;        Encode (bits, s->count, 8); //将未处理前的明文长度转换到bits数组中        //! 长度小于448位(mod 512（64个字节）),对明文进行填充(448位为56个字节)    index = (unsigned int)((s->count[0] >> 3) & 0x3f);   //计算已有的位数    padLen = (index < 56) ? (56 - index) : (120 - index);//补充说明（5）(计算还差的位数 64-index+56=120-index)    MD5_Update( s, s->PADDING, padLen );                 //填充还差位数的明文        MD5_Update( s, bits, 8);         //加入未处理前的明文的长度    Encode( digest, s->state, 16 );  //将MD5摘要转换到输出缓冲区里        //初始化到最开始的状态，处理下一个明文    memset ((unsigned char*)s, 0, sizeof (*s));    MD5_Init( s );}/******************************************************************************///名称：SHA_digest//功能：生成文件摘要//  参数：strContent:指向文件内容缓冲区; iLength:文件内容长度; output:摘要输出缓冲区//返回：无/******************************************************************************/void md5_digest( void const *strContent, unsigned int iLength, unsigned char output[16] ){    unsigned char *q = (unsigned char*)strContent;    MD5_State s;    MD5_Init( &s );               //初始化MD5状态数据结构    MD5_Update( &s, q, iLength ); //处理64*n个字节的明文，对每512位的明文进行处理（有可能没有64个字节）    MD5_Final( &s, output );      //处理最后需要填充的明文}int main( int argc, char **argv ){    unsigned char buff[16];  //  unsigned int x=4294967295;  //  printf("%u\n",(unsigned int)(x+1));        //需加密的明文    char str[4][100] =    {                "a",        "ab",        "md5",        "hello word!",    };    for(int i=0;i<4;i++)    {        md5_digest(str[i],(unsigned int)strlen(str[i]),buff);        printf("MD5(%s) = \n",str[i]);                //MD5摘要是128位，以16进制的形式输出        for(int j=0;j<16;j++)        {            printf("%x",(buff[j] & 0xF0)>>4);            printf("%x",buff[j] & 0x0F);        }        printf("\n\n");    }    return 0;}//http://www.cmd5.com上测试的数据进行验证/*  md5(a,32) = 0cc175b9c0f1b6a831c399e269772661  md5(ab,32) = 187ef4436122d1cc2f40dc2b92f0eba0  md5(md5,32) = 1bc29b36f623ba82aaf6724fd3b16718  md5(hello word!,32) = 39505368546302be2704b3d53b24203c*/

九、MD5总结

写这篇文章的原因是在课程学习中，学习到了散列函数（简单讲了MD5和SHA1）,课程也没要求掌握你实现方式，但是自己更喜欢把学习的东西就学好一些，掌握的更多一些，在实验的时候，其它同学都在用提供的实验完成实验报告，而我更倾向于原理的理解，上面一些原理的东西都摘自于实验原理的介绍文章中，同时也提供了部分源代码，也需要自己动手补充一部分，当然这是选做，上面很多代码就源于那个地方，但是当时并没有充分的注释，说得也不是很清楚，自己拷贝下来后也琢磨了很久，同时也网上找了一些资料，但是有趣的是网上的代码很多都是和这个一样的，而且都没有很好的注释，实在是太多了，我想说都理解了吗，为什么没有一些自己的注释，基本是都是一个模板，当时也许是自己太愚笨了，觉得比较难的部分，别人觉得其实很简单，完全没有必要再注释了。

上面的全部代码，我都自己琢磨过，也进行了相应的注释，自认为注释的还是比较清楚了吧，给以后研究学习的同学作为参考，很多注释是自己慢慢调试，思考后得出来的，但是表述不是很精炼，也许自己明白了，但是写出来的时候却没有说明白，感兴趣的可以互相学习，共同进步，当然其中可能自己也理解错了，还望指教一二。