4 * MD5 implementation for PuTTY. Written directly from the spec by
8 /* ----------------------------------------------------------------------
9 * Core MD5 algorithm: processes 16-word blocks into a message digest.
12 #define F(x,y,z) ( ((x) & (y)) | ((~(x)) & (z)) )
13 #define G(x,y,z) ( ((x) & (z)) | ((~(z)) & (y)) )
14 #define H(x,y,z) ( (x) ^ (y) ^ (z) )
15 #define I(x,y,z) ( (y) ^ ( (x) | ~(z) ) )
17 #define rol(x,y) ( ((x) << (y)) | (((uint32)x) >> (32-y)) )
19 #define subround(f,w,x,y,z,k,s,ti) \
20 w = x + rol(w + f(x,y,z) + block[k] + ti, s)
22 void MD5_Core_Init(MD5_Core_State
*s
) {
29 void MD5_Block(MD5_Core_State
*s
, uint32
*block
) {
32 a
= s
->h
[0]; b
= s
->h
[1]; c
= s
->h
[2]; d
= s
->h
[3];
34 subround(F
, a
, b
, c
, d
, 0, 7, 0xd76aa478);
35 subround(F
, d
, a
, b
, c
, 1, 12, 0xe8c7b756);
36 subround(F
, c
, d
, a
, b
, 2, 17, 0x242070db);
37 subround(F
, b
, c
, d
, a
, 3, 22, 0xc1bdceee);
38 subround(F
, a
, b
, c
, d
, 4, 7, 0xf57c0faf);
39 subround(F
, d
, a
, b
, c
, 5, 12, 0x4787c62a);
40 subround(F
, c
, d
, a
, b
, 6, 17, 0xa8304613);
41 subround(F
, b
, c
, d
, a
, 7, 22, 0xfd469501);
42 subround(F
, a
, b
, c
, d
, 8, 7, 0x698098d8);
43 subround(F
, d
, a
, b
, c
, 9, 12, 0x8b44f7af);
44 subround(F
, c
, d
, a
, b
, 10, 17, 0xffff5bb1);
45 subround(F
, b
, c
, d
, a
, 11, 22, 0x895cd7be);
46 subround(F
, a
, b
, c
, d
, 12, 7, 0x6b901122);
47 subround(F
, d
, a
, b
, c
, 13, 12, 0xfd987193);
48 subround(F
, c
, d
, a
, b
, 14, 17, 0xa679438e);
49 subround(F
, b
, c
, d
, a
, 15, 22, 0x49b40821);
50 subround(G
, a
, b
, c
, d
, 1, 5, 0xf61e2562);
51 subround(G
, d
, a
, b
, c
, 6, 9, 0xc040b340);
52 subround(G
, c
, d
, a
, b
, 11, 14, 0x265e5a51);
53 subround(G
, b
, c
, d
, a
, 0, 20, 0xe9b6c7aa);
54 subround(G
, a
, b
, c
, d
, 5, 5, 0xd62f105d);
55 subround(G
, d
, a
, b
, c
, 10, 9, 0x02441453);
56 subround(G
, c
, d
, a
, b
, 15, 14, 0xd8a1e681);
57 subround(G
, b
, c
, d
, a
, 4, 20, 0xe7d3fbc8);
58 subround(G
, a
, b
, c
, d
, 9, 5, 0x21e1cde6);
59 subround(G
, d
, a
, b
, c
, 14, 9, 0xc33707d6);
60 subround(G
, c
, d
, a
, b
, 3, 14, 0xf4d50d87);
61 subround(G
, b
, c
, d
, a
, 8, 20, 0x455a14ed);
62 subround(G
, a
, b
, c
, d
, 13, 5, 0xa9e3e905);
63 subround(G
, d
, a
, b
, c
, 2, 9, 0xfcefa3f8);
64 subround(G
, c
, d
, a
, b
, 7, 14, 0x676f02d9);
65 subround(G
, b
, c
, d
, a
, 12, 20, 0x8d2a4c8a);
66 subround(H
, a
, b
, c
, d
, 5, 4, 0xfffa3942);
67 subround(H
, d
, a
, b
, c
, 8, 11, 0x8771f681);
68 subround(H
, c
, d
, a
, b
, 11, 16, 0x6d9d6122);
69 subround(H
, b
, c
, d
, a
, 14, 23, 0xfde5380c);
70 subround(H
, a
, b
, c
, d
, 1, 4, 0xa4beea44);
71 subround(H
, d
, a
, b
, c
, 4, 11, 0x4bdecfa9);
72 subround(H
, c
, d
, a
, b
, 7, 16, 0xf6bb4b60);
73 subround(H
, b
, c
, d
, a
, 10, 23, 0xbebfbc70);
74 subround(H
, a
, b
, c
, d
, 13, 4, 0x289b7ec6);
75 subround(H
, d
, a
, b
, c
, 0, 11, 0xeaa127fa);
76 subround(H
, c
, d
, a
, b
, 3, 16, 0xd4ef3085);
77 subround(H
, b
, c
, d
, a
, 6, 23, 0x04881d05);
78 subround(H
, a
, b
, c
, d
, 9, 4, 0xd9d4d039);
79 subround(H
, d
, a
, b
, c
, 12, 11, 0xe6db99e5);
80 subround(H
, c
, d
, a
, b
, 15, 16, 0x1fa27cf8);
81 subround(H
, b
, c
, d
, a
, 2, 23, 0xc4ac5665);
82 subround(I
, a
, b
, c
, d
, 0, 6, 0xf4292244);
83 subround(I
, d
, a
, b
, c
, 7, 10, 0x432aff97);
84 subround(I
, c
, d
, a
, b
, 14, 15, 0xab9423a7);
85 subround(I
, b
, c
, d
, a
, 5, 21, 0xfc93a039);
86 subround(I
, a
, b
, c
, d
, 12, 6, 0x655b59c3);
87 subround(I
, d
, a
, b
, c
, 3, 10, 0x8f0ccc92);
88 subround(I
, c
, d
, a
, b
, 10, 15, 0xffeff47d);
89 subround(I
, b
, c
, d
, a
, 1, 21, 0x85845dd1);
90 subround(I
, a
, b
, c
, d
, 8, 6, 0x6fa87e4f);
91 subround(I
, d
, a
, b
, c
, 15, 10, 0xfe2ce6e0);
92 subround(I
, c
, d
, a
, b
, 6, 15, 0xa3014314);
93 subround(I
, b
, c
, d
, a
, 13, 21, 0x4e0811a1);
94 subround(I
, a
, b
, c
, d
, 4, 6, 0xf7537e82);
95 subround(I
, d
, a
, b
, c
, 11, 10, 0xbd3af235);
96 subround(I
, c
, d
, a
, b
, 2, 15, 0x2ad7d2bb);
97 subround(I
, b
, c
, d
, a
, 9, 21, 0xeb86d391);
99 s
->h
[0] += a
; s
->h
[1] += b
; s
->h
[2] += c
; s
->h
[3] += d
;
102 /* ----------------------------------------------------------------------
103 * Outer MD5 algorithm: take an arbitrary length byte string,
104 * convert it into 16-word blocks with the prescribed padding at
105 * the end, and pass those blocks to the core MD5 algorithm.
110 void MD5Init(struct MD5Context
*s
) {
111 MD5_Core_Init(&s
->core
);
113 s
->lenhi
= s
->lenlo
= 0;
116 void MD5Update(struct MD5Context
*s
, unsigned char const *p
,
118 unsigned char *q
= (unsigned char *)p
;
119 uint32 wordblock
[16];
124 * Update the length field.
127 s
->lenhi
+= (s
->lenlo
< lenw
);
129 if (s
->blkused
+len
< BLKSIZE
) {
131 * Trivial case: just add to the block.
133 memcpy(s
->block
+ s
->blkused
, q
, len
);
137 * We must complete and process at least one block.
139 while (s
->blkused
+ len
>= BLKSIZE
) {
140 memcpy(s
->block
+ s
->blkused
, q
, BLKSIZE
- s
->blkused
);
141 q
+= BLKSIZE
- s
->blkused
;
142 len
-= BLKSIZE
- s
->blkused
;
143 /* Now process the block. Gather bytes little-endian into words */
144 for (i
= 0; i
< 16; i
++) {
146 ( ((uint32
)s
->block
[i
*4+3]) << 24 ) |
147 ( ((uint32
)s
->block
[i
*4+2]) << 16 ) |
148 ( ((uint32
)s
->block
[i
*4+1]) << 8 ) |
149 ( ((uint32
)s
->block
[i
*4+0]) << 0 );
151 MD5_Block(&s
->core
, wordblock
);
154 memcpy(s
->block
, q
, len
);
159 void MD5Final(unsigned char output
[16], struct MD5Context
*s
) {
165 if (s
->blkused
>= 56)
166 pad
= 56 + 64 - s
->blkused
;
168 pad
= 56 - s
->blkused
;
170 lenhi
= (s
->lenhi
<< 3) | (s
->lenlo
>> (32-3));
171 lenlo
= (s
->lenlo
<< 3);
175 MD5Update(s
, c
, pad
);
177 c
[7] = (lenhi
>> 24) & 0xFF;
178 c
[6] = (lenhi
>> 16) & 0xFF;
179 c
[5] = (lenhi
>> 8) & 0xFF;
180 c
[4] = (lenhi
>> 0) & 0xFF;
181 c
[3] = (lenlo
>> 24) & 0xFF;
182 c
[2] = (lenlo
>> 16) & 0xFF;
183 c
[1] = (lenlo
>> 8) & 0xFF;
184 c
[0] = (lenlo
>> 0) & 0xFF;
188 for (i
= 0; i
< 4; i
++) {
189 output
[4*i
+3] = (s
->core
.h
[i
] >> 24) & 0xFF;
190 output
[4*i
+2] = (s
->core
.h
[i
] >> 16) & 0xFF;
191 output
[4*i
+1] = (s
->core
.h
[i
] >> 8) & 0xFF;
192 output
[4*i
+0] = (s
->core
.h
[i
] >> 0) & 0xFF;