【C】C语言实现MD5算法

0xAA55

现在MD5已被证实其并不安全了！不过它也还是有些作用的。

1. //=============================================================================
   
2. //作者：0xAA55
   
3. //网站：http://www.0xaa55.com
   
4. //版权所有(C)技术宅的结界 2013-2015
   
5. //请保留原作者信息，否则视为侵权
   
6. //-----------------------------------------------------------------------------
   
7. //rfc1321
   
8. 
   
9. #include"md5.h"
   
10. #include<memory.h>
    
11. 
    
12. //MD5寄存器
    
13. typedef struct
    
14. {
    
15.         uint32_t A;
    
16.         uint32_t B;
    
17.         uint32_t C;
    
18.         uint32_t D;
    
19.         uint32_t AA;
    
20.         uint32_t BB;
    
21.         uint32_t CC;
    
22.         uint32_t DD;
    
23. }MD5Registers,*MD5RegistersP;
    
24. 
    
25. static uint32_t F(uint32_t x,uint32_t y,uint32_t z){return (x&y)|(~x&z);}
    
26. static uint32_t G(uint32_t x,uint32_t y,uint32_t z){return (x&z)|(y&~z);}
    
27. static uint32_t H(uint32_t x,uint32_t y,uint32_t z){return x^y^z;}
    
28. static uint32_t I(uint32_t x,uint32_t y,uint32_t z){return y^(x|~z);}
    
29. 
    
30. static uint32_t Rol(uint32_t v,uint8_t Count){return (v<<Count)|(v>>(32-Count));}
    
31. 
    
32. static uint32_t FF(uint32_t a,uint32_t b,uint32_t c,uint32_t d,
    
33.                                    uint32_t X,uint32_t s,uint32_t T)
    
34. {return b+Rol((a+F(b,c,d)+X+T),s);}
    
35. static uint32_t GG(uint32_t a,uint32_t b,uint32_t c,uint32_t d,
    
36.                                    uint32_t X,uint32_t s,uint32_t T)
    
37. {return b+Rol((a+G(b,c,d)+X+T),s);}
    
38. static uint32_t HH(uint32_t a,uint32_t b,uint32_t c,uint32_t d,
    
39.                                    uint32_t X,uint32_t s,uint32_t T)
    
40. {return b+Rol((a+H(b,c,d)+X+T),s);}
    
41. static uint32_t II(uint32_t a,uint32_t b,uint32_t c,uint32_t d,
    
42.                                    uint32_t X,uint32_t s,uint32_t T)
    
43. {return b+Rol((a+I(b,c,d)+X+T),s);}
    
44. 
    
45. //=============================================================================
    
46. //函数：InitRegs
    
47. //描述：初始化MD5寄存器
    
48. //-----------------------------------------------------------------------------
    
49. static void InitRegs(MD5RegistersP pReg)
    
50. {
    
51.         //初始4个32位寄存器
    
52.         pReg->A=0x67452301;
    
53.         pReg->B=0xEFCDAB89;
    
54.         pReg->C=0x98BADCFE;
    
55.         pReg->D=0x10325476;
    
56. }
    
57. 
    
58. //=============================================================================
    
59. //函数：DigestChunk
    
60. //描述：将一个64字节的“块”作为数据压入计算
    
61. //-----------------------------------------------------------------------------
    
62. static void DigestChunk(MD5RegistersP pReg,void*pData)
    
63. {
    
64. #        define p ((uint32_t*)pData)
    
65.         pReg->AA=pReg->A;
    
66.         pReg->BB=pReg->B;
    
67.         pReg->CC=pReg->C;
    
68.         pReg->DD=pReg->D;
    
69. 
    
70.         pReg->A=FF(pReg->A,pReg->B,pReg->C,pReg->D,p[0x0],0x07,0xD76AA478);
    
71.         pReg->D=FF(pReg->D,pReg->A,pReg->B,pReg->C,p[0x1],0x0C,0xE8C7B756);
    
72.         pReg->C=FF(pReg->C,pReg->D,pReg->A,pReg->B,p[0x2],0x11,0x242070DB);
    
73.         pReg->B=FF(pReg->B,pReg->C,pReg->D,pReg->A,p[0x3],0x16,0xC1BDCEEE);
    
74.         pReg->A=FF(pReg->A,pReg->B,pReg->C,pReg->D,p[0x4],0x07,0xF57C0FAF);
    
75.         pReg->D=FF(pReg->D,pReg->A,pReg->B,pReg->C,p[0x5],0x0C,0x4787C62A);
    
76.         pReg->C=FF(pReg->C,pReg->D,pReg->A,pReg->B,p[0x6],0x11,0xA8304613);
    
77.         pReg->B=FF(pReg->B,pReg->C,pReg->D,pReg->A,p[0x7],0x16,0xFD469501);
    
78.         pReg->A=FF(pReg->A,pReg->B,pReg->C,pReg->D,p[0x8],0x07,0x698098D8);
    
79.         pReg->D=FF(pReg->D,pReg->A,pReg->B,pReg->C,p[0x9],0x0C,0x8B44F7AF);
    
80.         pReg->C=FF(pReg->C,pReg->D,pReg->A,pReg->B,p[0xA],0x11,0xFFFF5BB1);
    
81.         pReg->B=FF(pReg->B,pReg->C,pReg->D,pReg->A,p[0xB],0x16,0x895CD7BE);
    
82.         pReg->A=FF(pReg->A,pReg->B,pReg->C,pReg->D,p[0xC],0x07,0x6B901122);
    
83.         pReg->D=FF(pReg->D,pReg->A,pReg->B,pReg->C,p[0xD],0x0C,0xFD987193);
    
84.         pReg->C=FF(pReg->C,pReg->D,pReg->A,pReg->B,p[0xE],0x11,0xA679438E);
    
85.         pReg->B=FF(pReg->B,pReg->C,pReg->D,pReg->A,p[0xF],0x16,0x49B40821);
    
86. 
    
87.         pReg->A=GG(pReg->A,pReg->B,pReg->C,pReg->D,p[0x1],0x05,0xF61E2562);
    
88.         pReg->D=GG(pReg->D,pReg->A,pReg->B,pReg->C,p[0x6],0x09,0xC040B340);
    
89.         pReg->C=GG(pReg->C,pReg->D,pReg->A,pReg->B,p[0xB],0x0E,0x265E5A51);
    
90.         pReg->B=GG(pReg->B,pReg->C,pReg->D,pReg->A,p[0x0],0x14,0xE9B6C7AA);
    
91.         pReg->A=GG(pReg->A,pReg->B,pReg->C,pReg->D,p[0x5],0x05,0xD62F105D);
    
92.         pReg->D=GG(pReg->D,pReg->A,pReg->B,pReg->C,p[0xA],0x09,0x02441453);
    
93.         pReg->C=GG(pReg->C,pReg->D,pReg->A,pReg->B,p[0xF],0x0E,0xD8A1E681);
    
94.         pReg->B=GG(pReg->B,pReg->C,pReg->D,pReg->A,p[0x4],0x14,0xE7D3FBC8);
    
95.         pReg->A=GG(pReg->A,pReg->B,pReg->C,pReg->D,p[0x9],0x05,0x21E1CDE6);
    
96.         pReg->D=GG(pReg->D,pReg->A,pReg->B,pReg->C,p[0xE],0x09,0xC33707D6);
    
97.         pReg->C=GG(pReg->C,pReg->D,pReg->A,pReg->B,p[0x3],0x0E,0xF4D50D87);
    
98.         pReg->B=GG(pReg->B,pReg->C,pReg->D,pReg->A,p[0x8],0x14,0x455A14ED);
    
99.         pReg->A=GG(pReg->A,pReg->B,pReg->C,pReg->D,p[0xD],0x05,0xA9E3E905);
    
100.         pReg->D=GG(pReg->D,pReg->A,pReg->B,pReg->C,p[0x2],0x09,0xFCEFA3F8);
     
101.         pReg->C=GG(pReg->C,pReg->D,pReg->A,pReg->B,p[0x7],0x0E,0x676F02D9);
     
102.         pReg->B=GG(pReg->B,pReg->C,pReg->D,pReg->A,p[0xC],0x14,0x8D2A4C8A);
     
103. 
     
104.         pReg->A=HH(pReg->A,pReg->B,pReg->C,pReg->D,p[0x5],0x04,0xFFFA3942);
     
105.         pReg->D=HH(pReg->D,pReg->A,pReg->B,pReg->C,p[0x8],0x0B,0x8771F681);
     
106.         pReg->C=HH(pReg->C,pReg->D,pReg->A,pReg->B,p[0xB],0x10,0x6D9D6122);
     
107.         pReg->B=HH(pReg->B,pReg->C,pReg->D,pReg->A,p[0xE],0x17,0xFDE5380C);
     
108.         pReg->A=HH(pReg->A,pReg->B,pReg->C,pReg->D,p[0x1],0x04,0xA4BEEA44);
     
109.         pReg->D=HH(pReg->D,pReg->A,pReg->B,pReg->C,p[0x4],0x0B,0x4BDECFA9);
     
110.         pReg->C=HH(pReg->C,pReg->D,pReg->A,pReg->B,p[0x7],0x10,0xF6BB4B60);
     
111.         pReg->B=HH(pReg->B,pReg->C,pReg->D,pReg->A,p[0xA],0x17,0xBEBFBC70);
     
112.         pReg->A=HH(pReg->A,pReg->B,pReg->C,pReg->D,p[0xD],0x04,0x289B7EC6);
     
113.         pReg->D=HH(pReg->D,pReg->A,pReg->B,pReg->C,p[0x0],0x0B,0xEAA127FA);
     
114.         pReg->C=HH(pReg->C,pReg->D,pReg->A,pReg->B,p[0x3],0x10,0xD4EF3085);
     
115.         pReg->B=HH(pReg->B,pReg->C,pReg->D,pReg->A,p[0x6],0x17,0x04881D05);
     
116.         pReg->A=HH(pReg->A,pReg->B,pReg->C,pReg->D,p[0x9],0x04,0xD9D4D039);
     
117.         pReg->D=HH(pReg->D,pReg->A,pReg->B,pReg->C,p[0xC],0x0B,0xE6DB99E5);
     
118.         pReg->C=HH(pReg->C,pReg->D,pReg->A,pReg->B,p[0xF],0x10,0x1FA27CF8);
     
119.         pReg->B=HH(pReg->B,pReg->C,pReg->D,pReg->A,p[0x2],0x17,0xC4AC5665);
     
120. 
     
121.         pReg->A=II(pReg->A,pReg->B,pReg->C,pReg->D,p[0x0],0x06,0xF4292244);
     
122.         pReg->D=II(pReg->D,pReg->A,pReg->B,pReg->C,p[0x7],0x0A,0x432AFF97);
     
123.         pReg->C=II(pReg->C,pReg->D,pReg->A,pReg->B,p[0xE],0x0F,0xAB9423A7);
     
124.         pReg->B=II(pReg->B,pReg->C,pReg->D,pReg->A,p[0x5],0x15,0xFC93A039);
     
125.         pReg->A=II(pReg->A,pReg->B,pReg->C,pReg->D,p[0xC],0x06,0x655B59C3);
     
126.         pReg->D=II(pReg->D,pReg->A,pReg->B,pReg->C,p[0x3],0x0A,0x8F0CCC92);
     
127.         pReg->C=II(pReg->C,pReg->D,pReg->A,pReg->B,p[0xA],0x0F,0xFFEFF47D);
     
128.         pReg->B=II(pReg->B,pReg->C,pReg->D,pReg->A,p[0x1],0x15,0x85845DD1);
     
129.         pReg->A=II(pReg->A,pReg->B,pReg->C,pReg->D,p[0x8],0x06,0x6FA87E4F);
     
130.         pReg->D=II(pReg->D,pReg->A,pReg->B,pReg->C,p[0xF],0x0A,0xFE2CE6E0);
     
131.         pReg->C=II(pReg->C,pReg->D,pReg->A,pReg->B,p[0x6],0x0F,0xA3014314);
     
132.         pReg->B=II(pReg->B,pReg->C,pReg->D,pReg->A,p[0xD],0x15,0x4E0811A1);
     
133.         pReg->A=II(pReg->A,pReg->B,pReg->C,pReg->D,p[0x4],0x06,0xF7537E82);
     
134.         pReg->D=II(pReg->D,pReg->A,pReg->B,pReg->C,p[0xB],0x0A,0xBD3AF235);
     
135.         pReg->C=II(pReg->C,pReg->D,pReg->A,pReg->B,p[0x2],0x0F,0x2AD7D2BB);
     
136.         pReg->B=II(pReg->B,pReg->C,pReg->D,pReg->A,p[0x9],0x15,0xEB86D391);
     
137. 
     
138.         pReg->A+=pReg->AA;
     
139.         pReg->B+=pReg->BB;
     
140.         pReg->C+=pReg->CC;
     
141.         pReg->D+=pReg->DD;
     
142. }
     
143. 
     
144. //=============================================================================
     
145. //函数：MD5Sum
     
146. //描述：计算MD5校验和，其中pMD5Out接收结果（函数将写入16个字节到pMD5Out）
     
147. //-----------------------------------------------------------------------------
     
148. void MD5Sum
     
149. (
     
150.         void                *pData,        //数据指针
     
151.         size_t                cbData,        //数据大小(Bytes)
     
152.         uint32_t        *pMD5Out//输出MD5
     
153. )
     
154. {
     
155.         MD5Registers Regs={0};
     
156.         uint8_t PadBuf[64]={0};//用于计算最后的填充内容的缓冲区
     
157.         size_t i;
     
158.         size_t cbLast=cbData;
     
159. 
     
160.         //=========================================================================
     
161.         //MD5算法：
     
162.         //第一：数据补充
     
163.         //1、将数据看成是bit流，在最后一个bit的后面添加一个1。
     
164.         //2、再在数据的后面不断补充0，直到数据的总位数与512求余==448
     
165.         //3、将数据的总位数以uint64_t格式补充到最后
     
166.         //第二：运算
     
167.         //1、初始化MD5寄存器
     
168.         //2、将数据划分为n个512 bit的块，对每个块进行DigestChunk运算
     
169.         //3、最后将MD5寄存器的值返回
     
170. 
     
171.         //初始化MD5寄存器
     
172.         InitRegs(&Regs);
     
173. 
     
174.         //将数据拆成64字节一个块，先分析逐个块，直到最后一个块（然后再来处理“补齐”）
     
175.         for(i=0;i+64<=cbData;i+=64)
     
176.         {
     
177.                 DigestChunk(&Regs,pData);
     
178.                 (uint8_t*)pData+=64;
     
179.                 cbLast-=64;
     
180.         }
     
181. 
     
182.         //如果最后一个块有内容则复制到最后的填充内容的缓冲区
     
183.         if(cbData)
     
184.                 memcpy(PadBuf,pData,cbLast);
     
185. 
     
186.         //补充1
     
187.         PadBuf[cbLast++]=0x80;
     
188. 
     
189.         //然后在这个填充数据块的结尾补充[数据的总位数]。
     
190. 
     
191.         //如果有空余的空间可用于补充，则补充
     
192.         if(cbLast<56)
     
193.         {
     
194.                 *(uint64_t*)&(PadBuf[56])=(uint64_t)cbData*8;
     
195.                 DigestChunk(&Regs,PadBuf);
     
196.         }
     
197.         else//否则再补充56个，然后再补充
     
198.         {
     
199.                 DigestChunk(&Regs,PadBuf);
     
200.                 memset(PadBuf,0,sizeof(PadBuf));
     
201.                 *(uint64_t*)&(PadBuf[56])=(uint64_t)cbData*8;
     
202.                 DigestChunk(&Regs,PadBuf);
     
203.         }
     
204. 
     
205.         //最后返回MD5寄存器的值
     
206.         pMD5Out[0]=Regs.A;
     
207.         pMD5Out[1]=Regs.B;
     
208.         pMD5Out[2]=Regs.C;
     
209.         pMD5Out[3]=Regs.D;
     
210. }

复制代码

以下程序用于计算一个字符串的MD5值。
命令：md5 <string>
BIN: md5.exe (64.5 KB, 下载次数: 8)

2015-2-28 02:54 上传

点击文件名下载附件

SRC: md5.7z (134.16 KB, 下载次数: 16)

2015-2-28 02:54 上传

点击文件名下载附件