Mercurial > dropbear

comparison libtomcrypt/src/hashes/md5.c @ 285:1b9e69c058d2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
propagate from branch 'au.asn.ucc.matt.ltc.dropbear' (head 20dccfc09627970a312d77fb41dc2970b62689c3) to branch 'au.asn.ucc.matt.dropbear' (head fdf4a7a3b97ae5046139915de7e40399cceb2c01)
author Matt Johnston <matt@ucc.asn.au>
date Wed, 08 Mar 2006 13:23:58 +0000
parents
children 0cbe8f6dbf9e
comparison
equal deleted inserted replaced
281:997e6f7dc01e 285:1b9e69c058d2
1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
2 *
3 * LibTomCrypt is a library that provides various cryptographic
4 * algorithms in a highly modular and flexible manner.
5 *
6 * The library is free for all purposes without any express
7 * guarantee it works.
8 *
9 * Tom St Denis, [email protected], http://libtomcrypt.org
10 */
11 #include "tomcrypt.h"
12
13
14 /**
15 @file md5.c
16 MD5 hash function by Tom St Denis
17 */
18
19 #ifdef MD5
20
21 const struct ltc_hash_descriptor md5_desc =
22 {
23 "md5",
24 3,
25 16,
26 64,
27
28 /* OID */
29 { 1, 2, 840, 113549, 2, 5, },
30 6,
31
32 &md5_init,
33 &md5_process,
34 &md5_done,
35 &md5_test
36 };
37
38 #define F(x,y,z) (z ^ (x & (y ^ z)))
39 #define G(x,y,z) (y ^ (z & (y ^ x)))
40 #define H(x,y,z) (x^y^z)
41 #define I(x,y,z) (y^(x|(~z)))
42
43 #ifdef LTC_SMALL_CODE
44
45 #define FF(a,b,c,d,M,s,t) \
46 a = (a + F(b,c,d) + M + t); a = ROL(a, s) + b;
47
48 #define GG(a,b,c,d,M,s,t) \
49 a = (a + G(b,c,d) + M + t); a = ROL(a, s) + b;
50
51 #define HH(a,b,c,d,M,s,t) \
52 a = (a + H(b,c,d) + M + t); a = ROL(a, s) + b;
53
54 #define II(a,b,c,d,M,s,t) \
55 a = (a + I(b,c,d) + M + t); a = ROL(a, s) + b;
56
57 static const unsigned char Worder[64] = {
58 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
59 1,6,11,0,5,10,15,4,9,14,3,8,13,2,7,12,
60 5,8,11,14,1,4,7,10,13,0,3,6,9,12,15,2,
61 0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9
62 };
63
64 static const unsigned char Rorder[64] = {
65 7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22,
66 5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
67 4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,
68 6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21
69 };
70
71 static const ulong32 Korder[64] = {
72 0xd76aa478UL, 0xe8c7b756UL, 0x242070dbUL, 0xc1bdceeeUL, 0xf57c0fafUL, 0x4787c62aUL, 0xa8304613UL, 0xfd469501UL,
73 0x698098d8UL, 0x8b44f7afUL, 0xffff5bb1UL, 0x895cd7beUL, 0x6b901122UL, 0xfd987193UL, 0xa679438eUL, 0x49b40821UL,
74 0xf61e2562UL, 0xc040b340UL, 0x265e5a51UL, 0xe9b6c7aaUL, 0xd62f105dUL, 0x02441453UL, 0xd8a1e681UL, 0xe7d3fbc8UL,
75 0x21e1cde6UL, 0xc33707d6UL, 0xf4d50d87UL, 0x455a14edUL, 0xa9e3e905UL, 0xfcefa3f8UL, 0x676f02d9UL, 0x8d2a4c8aUL,
76 0xfffa3942UL, 0x8771f681UL, 0x6d9d6122UL, 0xfde5380cUL, 0xa4beea44UL, 0x4bdecfa9UL, 0xf6bb4b60UL, 0xbebfbc70UL,
77 0x289b7ec6UL, 0xeaa127faUL, 0xd4ef3085UL, 0x04881d05UL, 0xd9d4d039UL, 0xe6db99e5UL, 0x1fa27cf8UL, 0xc4ac5665UL,
78 0xf4292244UL, 0x432aff97UL, 0xab9423a7UL, 0xfc93a039UL, 0x655b59c3UL, 0x8f0ccc92UL, 0xffeff47dUL, 0x85845dd1UL,
79 0x6fa87e4fUL, 0xfe2ce6e0UL, 0xa3014314UL, 0x4e0811a1UL, 0xf7537e82UL, 0xbd3af235UL, 0x2ad7d2bbUL, 0xeb86d391UL
80 };
81
82 #else
83
84 #define FF(a,b,c,d,M,s,t) \
85 a = (a + F(b,c,d) + M + t); a = ROLc(a, s) + b;
86
87 #define GG(a,b,c,d,M,s,t) \
88 a = (a + G(b,c,d) + M + t); a = ROLc(a, s) + b;
89
90 #define HH(a,b,c,d,M,s,t) \
91 a = (a + H(b,c,d) + M + t); a = ROLc(a, s) + b;
92
93 #define II(a,b,c,d,M,s,t) \
94 a = (a + I(b,c,d) + M + t); a = ROLc(a, s) + b;
95
96
97 #endif
98
99 #ifdef LTC_CLEAN_STACK
100 static int _md5_compress(hash_state *md, unsigned char *buf)
101 #else
102 static int md5_compress(hash_state *md, unsigned char *buf)
103 #endif
104 {
105 ulong32 i, W[16], a, b, c, d;
106 #ifdef LTC_SMALL_CODE
107 ulong32 t;
108 #endif
109
110 /* copy the state into 512-bits into W[0..15] */
111 for (i = 0; i < 16; i++) {
112 LOAD32L(W[i], buf + (4*i));
113 }
114
115 /* copy state */
116 a = md->md5.state[0];
117 b = md->md5.state[1];
118 c = md->md5.state[2];
119 d = md->md5.state[3];
120
121 #ifdef LTC_SMALL_CODE
122 for (i = 0; i < 16; ++i) {
123 FF(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]);
124 t = d; d = c; c = b; b = a; a = t;
125 }
126
127 for (; i < 32; ++i) {
128 GG(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]);
129 t = d; d = c; c = b; b = a; a = t;
130 }
131
132 for (; i < 48; ++i) {
133 HH(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]);
134 t = d; d = c; c = b; b = a; a = t;
135 }
136
137 for (; i < 64; ++i) {
138 II(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]);
139 t = d; d = c; c = b; b = a; a = t;
140 }
141
142 #else
143 FF(a,b,c,d,W[0],7,0xd76aa478UL)
144 FF(d,a,b,c,W[1],12,0xe8c7b756UL)
145 FF(c,d,a,b,W[2],17,0x242070dbUL)
146 FF(b,c,d,a,W[3],22,0xc1bdceeeUL)
147 FF(a,b,c,d,W[4],7,0xf57c0fafUL)
148 FF(d,a,b,c,W[5],12,0x4787c62aUL)
149 FF(c,d,a,b,W[6],17,0xa8304613UL)
150 FF(b,c,d,a,W[7],22,0xfd469501UL)
151 FF(a,b,c,d,W[8],7,0x698098d8UL)
152 FF(d,a,b,c,W[9],12,0x8b44f7afUL)
153 FF(c,d,a,b,W[10],17,0xffff5bb1UL)
154 FF(b,c,d,a,W[11],22,0x895cd7beUL)
155 FF(a,b,c,d,W[12],7,0x6b901122UL)
156 FF(d,a,b,c,W[13],12,0xfd987193UL)
157 FF(c,d,a,b,W[14],17,0xa679438eUL)
158 FF(b,c,d,a,W[15],22,0x49b40821UL)
159 GG(a,b,c,d,W[1],5,0xf61e2562UL)
160 GG(d,a,b,c,W[6],9,0xc040b340UL)
161 GG(c,d,a,b,W[11],14,0x265e5a51UL)
162 GG(b,c,d,a,W[0],20,0xe9b6c7aaUL)
163 GG(a,b,c,d,W[5],5,0xd62f105dUL)
164 GG(d,a,b,c,W[10],9,0x02441453UL)
165 GG(c,d,a,b,W[15],14,0xd8a1e681UL)
166 GG(b,c,d,a,W[4],20,0xe7d3fbc8UL)
167 GG(a,b,c,d,W[9],5,0x21e1cde6UL)
168 GG(d,a,b,c,W[14],9,0xc33707d6UL)
169 GG(c,d,a,b,W[3],14,0xf4d50d87UL)
170 GG(b,c,d,a,W[8],20,0x455a14edUL)
171 GG(a,b,c,d,W[13],5,0xa9e3e905UL)
172 GG(d,a,b,c,W[2],9,0xfcefa3f8UL)
173 GG(c,d,a,b,W[7],14,0x676f02d9UL)
174 GG(b,c,d,a,W[12],20,0x8d2a4c8aUL)
175 HH(a,b,c,d,W[5],4,0xfffa3942UL)
176 HH(d,a,b,c,W[8],11,0x8771f681UL)
177 HH(c,d,a,b,W[11],16,0x6d9d6122UL)
178 HH(b,c,d,a,W[14],23,0xfde5380cUL)
179 HH(a,b,c,d,W[1],4,0xa4beea44UL)
180 HH(d,a,b,c,W[4],11,0x4bdecfa9UL)
181 HH(c,d,a,b,W[7],16,0xf6bb4b60UL)
182 HH(b,c,d,a,W[10],23,0xbebfbc70UL)
183 HH(a,b,c,d,W[13],4,0x289b7ec6UL)
184 HH(d,a,b,c,W[0],11,0xeaa127faUL)
185 HH(c,d,a,b,W[3],16,0xd4ef3085UL)
186 HH(b,c,d,a,W[6],23,0x04881d05UL)
187 HH(a,b,c,d,W[9],4,0xd9d4d039UL)
188 HH(d,a,b,c,W[12],11,0xe6db99e5UL)
189 HH(c,d,a,b,W[15],16,0x1fa27cf8UL)
190 HH(b,c,d,a,W[2],23,0xc4ac5665UL)
191 II(a,b,c,d,W[0],6,0xf4292244UL)
192 II(d,a,b,c,W[7],10,0x432aff97UL)
193 II(c,d,a,b,W[14],15,0xab9423a7UL)
194 II(b,c,d,a,W[5],21,0xfc93a039UL)
195 II(a,b,c,d,W[12],6,0x655b59c3UL)
196 II(d,a,b,c,W[3],10,0x8f0ccc92UL)
197 II(c,d,a,b,W[10],15,0xffeff47dUL)
198 II(b,c,d,a,W[1],21,0x85845dd1UL)
199 II(a,b,c,d,W[8],6,0x6fa87e4fUL)
200 II(d,a,b,c,W[15],10,0xfe2ce6e0UL)
201 II(c,d,a,b,W[6],15,0xa3014314UL)
202 II(b,c,d,a,W[13],21,0x4e0811a1UL)
203 II(a,b,c,d,W[4],6,0xf7537e82UL)
204 II(d,a,b,c,W[11],10,0xbd3af235UL)
205 II(c,d,a,b,W[2],15,0x2ad7d2bbUL)
206 II(b,c,d,a,W[9],21,0xeb86d391UL)
207 #endif
208
209 md->md5.state[0] = md->md5.state[0] + a;
210 md->md5.state[1] = md->md5.state[1] + b;
211 md->md5.state[2] = md->md5.state[2] + c;
212 md->md5.state[3] = md->md5.state[3] + d;
213
214 return CRYPT_OK;
215 }
216
217 #ifdef LTC_CLEAN_STACK
218 static int md5_compress(hash_state *md, unsigned char *buf)
219 {
220 int err;
221 err = _md5_compress(md, buf);
222 burn_stack(sizeof(ulong32) * 21);
223 return err;
224 }
225 #endif
226
227 /**
228 Initialize the hash state
229 @param md The hash state you wish to initialize
230 @return CRYPT_OK if successful
231 */
232 int md5_init(hash_state * md)
233 {
234 LTC_ARGCHK(md != NULL);
235 md->md5.state[0] = 0x67452301UL;
236 md->md5.state[1] = 0xefcdab89UL;
237 md->md5.state[2] = 0x98badcfeUL;
238 md->md5.state[3] = 0x10325476UL;
239 md->md5.curlen = 0;
240 md->md5.length = 0;
241 return CRYPT_OK;
242 }
243
244 /**
245 Process a block of memory though the hash
246 @param md The hash state
247 @param in The data to hash
248 @param inlen The length of the data (octets)
249 @return CRYPT_OK if successful
250 */
251 HASH_PROCESS(md5_process, md5_compress, md5, 64)
252
253 /**
254 Terminate the hash to get the digest
255 @param md The hash state
256 @param out [out] The destination of the hash (16 bytes)
257 @return CRYPT_OK if successful
258 */
259 int md5_done(hash_state * md, unsigned char *out)
260 {
261 int i;
262
263 LTC_ARGCHK(md != NULL);
264 LTC_ARGCHK(out != NULL);
265
266 if (md->md5.curlen >= sizeof(md->md5.buf)) {
267 return CRYPT_INVALID_ARG;
268 }
269
270
271 /* increase the length of the message */
272 md->md5.length += md->md5.curlen * 8;
273
274 /* append the '1' bit */
275 md->md5.buf[md->md5.curlen++] = (unsigned char)0x80;
276
277 /* if the length is currently above 56 bytes we append zeros
278 * then compress. Then we can fall back to padding zeros and length
279 * encoding like normal.
280 */
281 if (md->md5.curlen > 56) {
282 while (md->md5.curlen < 64) {
283 md->md5.buf[md->md5.curlen++] = (unsigned char)0;
284 }
285 md5_compress(md, md->md5.buf);
286 md->md5.curlen = 0;
287 }
288
289 /* pad upto 56 bytes of zeroes */
290 while (md->md5.curlen < 56) {
291 md->md5.buf[md->md5.curlen++] = (unsigned char)0;
292 }
293
294 /* store length */
295 STORE64L(md->md5.length, md->md5.buf+56);
296 md5_compress(md, md->md5.buf);
297
298 /* copy output */
299 for (i = 0; i < 4; i++) {
300 STORE32L(md->md5.state[i], out+(4*i));
301 }
302 #ifdef LTC_CLEAN_STACK
303 zeromem(md, sizeof(hash_state));
304 #endif
305 return CRYPT_OK;
306 }
307
308 /**
309 Self-test the hash
310 @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
311 */
312 int md5_test(void)
313 {
314 #ifndef LTC_TEST
315 return CRYPT_NOP;
316 #else
317 static const struct {
318 char *msg;
319 unsigned char hash[16];
320 } tests[] = {
321 { "",
322 { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
323 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e } },
324 { "a",
325 {0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8,
326 0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 } },
327 { "abc",
328 { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
329 0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 } },
330 { "message digest",
331 { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d,
332 0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 } },
333 { "abcdefghijklmnopqrstuvwxyz",
334 { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00,
335 0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b } },
336 { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
337 { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5,
338 0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f } },
339 { "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
340 { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55,
341 0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a } },
342 { NULL, { 0 } }
343 };
344
345 int i;
346 unsigned char tmp[16];
347 hash_state md;
348
349 for (i = 0; tests[i].msg != NULL; i++) {
350 md5_init(&md);
351 md5_process(&md, (unsigned char *)tests[i].msg, (unsigned long)strlen(tests[i].msg));
352 md5_done(&md, tmp);
353 if (memcmp(tmp, tests[i].hash, 16) != 0) {
354 return CRYPT_FAIL_TESTVECTOR;
355 }
356 }
357 return CRYPT_OK;
358 #endif
359 }
360
361 #endif
362
363
364
365 /* $Source: /cvs/libtom/libtomcrypt/src/hashes/md5.c,v $ */
366 /* $Revision: 1.5 $ */
367 /* $Date: 2005/05/23 02:42:07 $ */