** Warning: Cannot open xref database.
1 /*
2 * Functions to compute MD5 message digest of files or memory blocks
3 * according to the definition of MD5 in RFC 1321 from April 1992.
4 * Copyright (C) 1995, 1996 Free Software Foundation, Inc. NOTE: The
5 * canonical source of this file is maintained with the GNU C Library.
6 * Bugs can be reported to bug-glibc@prep.ai.mit.edu.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published
10 * by the Free Software Foundation; either version 2, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21 * 02111-1307, USA.
22 *
23 * Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
24 * Modified by Gray Watson <http://256.com/gray/>, 1997.
25 *
26 * $Id: md5.c,v 1.1 2002/05/24 19:28:45 wingo Exp $
27 */
28
29 /*
30 * NOTE: during quick performance tests on a Sun Sparc Ultra 1 and an
31 * Alpha 255 300, these functions performed upwards of 3mb/sec
32 * including disk I/O time.
33 */
34
35 /*
36 * MD5 Test Suite from RFC1321: http://ds.internic.net:/rfc/rfc1321.txt
37 *
38 * MD5 ("") = d41d8cd98f00b204e9800998ecf8427e
39 * MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661
40 * MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
41 * MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
42 * MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
43 * MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") =
44 * d174ab98d277d9f5a5611c2c9f419d9f
45 * MD5 ("123456789012345678901234567890123456789012345678901234567890123456
46 * 78901234567890") = 57edf4a22be3c955ac49da2e2107b67a
47 */
48
49 #include <stdlib.h>
50 #include <string.h>
51 #include <sys/types.h>
52
53 #include "md5.h"
54 #include "md5_loc.h"
55
56 /* static char *rcs_id =
57 "$Id: md5.c,v 1.1 2002/05/24 19:28:45 wingo Exp $"; */
58
59 /* version id for the library */
60 /* static char *version_id = "$MD5Version: 1.0.0 November-19-1997 $"; */
61
62 /****************************** local routines *******************************/
63
64 /*
65 * process_block
66 *
67 * DESCRIPTION:
68 *
69 * Process a block of bytes into a MD5 state structure.
70 *
71 * RETURNS:
72 *
73 * None.
74 *
75 * ARGUMENTS:
76 *
77 * md5_p - Pointer to MD5 structure from which we are getting the result.
78 *
79 * buffer - A buffer of bytes whose MD5 signature we are calculating.
80 *
81 * buf_len - The length of the buffer.
82 */
83 static void process_block(md5_t *md5_p, const void *buffer,
84 const unsigned int buf_len)
85 {
86 md5_uint32 correct[16];
87 const void *buf_p = buffer, *end_p;
88 unsigned int words_n;
89 md5_uint32 A, B, C, D;
90
91 words_n = buf_len / sizeof(md5_uint32);
92 end_p = (char *)buf_p + words_n * sizeof(md5_uint32);
93
94 A = md5_p->md_A;
95 B = md5_p->md_B;
96 C = md5_p->md_C;
97 D = md5_p->md_D;
98
99 /*
100 * First increment the byte count. RFC 1321 specifies the possible
101 * length of the file up to 2^64 bits. Here we only compute the
102 * number of bytes with a double word increment. Modified to do
103 * this to better avoid overflows in the lower word -- Gray 10/97.
104 */
105 if (md5_p->md_total[0] > MAX_MD5_UINT32 - buf_len) {
106 md5_p->md_total[1]++;
107 md5_p->md_total[0] -= (MAX_MD5_UINT32 - buf_len);
108 }
109 else {
110 md5_p->md_total[0] += buf_len;
111 }
112
113 /*
114 * Process all bytes in the buffer with MD5_BLOCK bytes in each
115 * round of the loop.
116 */
117 while (buf_p < end_p) {
118 md5_uint32 A_save, B_save, C_save, D_save;
119 md5_uint32 *corr_p = correct;
120
121 A_save = A;
122 B_save = B;
123 C_save = C;
124 D_save = D;
125
126 /*
127 * Before we start, one word to the strange constants. They are
128 * defined in RFC 1321 as
129 *
130 * T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..MD5_BLOCK
131 */
132
133 /* Round 1. */
134 OP1 (A, B, C, D, buf_p, corr_p, 7, 0xd76aa478);
135 OP1 (D, A, B, C, buf_p, corr_p, 12, 0xe8c7b756);
136 OP1 (C, D, A, B, buf_p, corr_p, 17, 0x242070db);
137 OP1 (B, C, D, A, buf_p, corr_p, 22, 0xc1bdceee);
138 OP1 (A, B, C, D, buf_p, corr_p, 7, 0xf57c0faf);
139 OP1 (D, A, B, C, buf_p, corr_p, 12, 0x4787c62a);
140 OP1 (C, D, A, B, buf_p, corr_p, 17, 0xa8304613);
141 OP1 (B, C, D, A, buf_p, corr_p, 22, 0xfd469501);
142 OP1 (A, B, C, D, buf_p, corr_p, 7, 0x698098d8);
143 OP1 (D, A, B, C, buf_p, corr_p, 12, 0x8b44f7af);
144 OP1 (C, D, A, B, buf_p, corr_p, 17, 0xffff5bb1);
145 OP1 (B, C, D, A, buf_p, corr_p, 22, 0x895cd7be);
146 OP1 (A, B, C, D, buf_p, corr_p, 7, 0x6b901122);
147 OP1 (D, A, B, C, buf_p, corr_p, 12, 0xfd987193);
148 OP1 (C, D, A, B, buf_p, corr_p, 17, 0xa679438e);
149 OP1 (B, C, D, A, buf_p, corr_p, 22, 0x49b40821);
150
151 /* Round 2. */
152 OP234 (FG, A, B, C, D, correct[ 1], 5, 0xf61e2562);
153 OP234 (FG, D, A, B, C, correct[ 6], 9, 0xc040b340);
154 OP234 (FG, C, D, A, B, correct[ 11], 14, 0x265e5a51);
155 OP234 (FG, B, C, D, A, correct[ 0], 20, 0xe9b6c7aa);
156 OP234 (FG, A, B, C, D, correct[ 5], 5, 0xd62f105d);
157 OP234 (FG, D, A, B, C, correct[ 10], 9, 0x02441453);
158 OP234 (FG, C, D, A, B, correct[ 15], 14, 0xd8a1e681);
159 OP234 (FG, B, C, D, A, correct[ 4], 20, 0xe7d3fbc8);
160 OP234 (FG, A, B, C, D, correct[ 9], 5, 0x21e1cde6);
161 OP234 (FG, D, A, B, C, correct[ 14], 9, 0xc33707d6);
162 OP234 (FG, C, D, A, B, correct[ 3], 14, 0xf4d50d87);
163 OP234 (FG, B, C, D, A, correct[ 8], 20, 0x455a14ed);
164 OP234 (FG, A, B, C, D, correct[ 13], 5, 0xa9e3e905);
165 OP234 (FG, D, A, B, C, correct[ 2], 9, 0xfcefa3f8);
166 OP234 (FG, C, D, A, B, correct[ 7], 14, 0x676f02d9);
167 OP234 (FG, B, C, D, A, correct[ 12], 20, 0x8d2a4c8a);
168
169 /* Round 3. */
170 OP234 (FH, A, B, C, D, correct[ 5], 4, 0xfffa3942);
171 OP234 (FH, D, A, B, C, correct[ 8], 11, 0x8771f681);
172 OP234 (FH, C, D, A, B, correct[ 11], 16, 0x6d9d6122);
173 OP234 (FH, B, C, D, A, correct[ 14], 23, 0xfde5380c);
174 OP234 (FH, A, B, C, D, correct[ 1], 4, 0xa4beea44);
175 OP234 (FH, D, A, B, C, correct[ 4], 11, 0x4bdecfa9);
176 OP234 (FH, C, D, A, B, correct[ 7], 16, 0xf6bb4b60);
177 OP234 (FH, B, C, D, A, correct[ 10], 23, 0xbebfbc70);
178 OP234 (FH, A, B, C, D, correct[ 13], 4, 0x289b7ec6);
179 OP234 (FH, D, A, B, C, correct[ 0], 11, 0xeaa127fa);
180 OP234 (FH, C, D, A, B, correct[ 3], 16, 0xd4ef3085);
181 OP234 (FH, B, C, D, A, correct[ 6], 23, 0x04881d05);
182 OP234 (FH, A, B, C, D, correct[ 9], 4, 0xd9d4d039);
183 OP234 (FH, D, A, B, C, correct[ 12], 11, 0xe6db99e5);
184 OP234 (FH, C, D, A, B, correct[ 15], 16, 0x1fa27cf8);
185 OP234 (FH, B, C, D, A, correct[ 2], 23, 0xc4ac5665);
186
187 /* Round 4. */
188 OP234 (FI, A, B, C, D, correct[ 0], 6, 0xf4292244);
189 OP234 (FI, D, A, B, C, correct[ 7], 10, 0x432aff97);
190 OP234 (FI, C, D, A, B, correct[ 14], 15, 0xab9423a7);
191 OP234 (FI, B, C, D, A, correct[ 5], 21, 0xfc93a039);
192 OP234 (FI, A, B, C, D, correct[ 12], 6, 0x655b59c3);
193 OP234 (FI, D, A, B, C, correct[ 3], 10, 0x8f0ccc92);
194 OP234 (FI, C, D, A, B, correct[ 10], 15, 0xffeff47d);
195 OP234 (FI, B, C, D, A, correct[ 1], 21, 0x85845dd1);
196 OP234 (FI, A, B, C, D, correct[ 8], 6, 0x6fa87e4f);
197 OP234 (FI, D, A, B, C, correct[ 15], 10, 0xfe2ce6e0);
198 OP234 (FI, C, D, A, B, correct[ 6], 15, 0xa3014314);
199 OP234 (FI, B, C, D, A, correct[ 13], 21, 0x4e0811a1);
200 OP234 (FI, A, B, C, D, correct[ 4], 6, 0xf7537e82);
201 OP234 (FI, D, A, B, C, correct[ 11], 10, 0xbd3af235);
202 OP234 (FI, C, D, A, B, correct[ 2], 15, 0x2ad7d2bb);
203 OP234 (FI, B, C, D, A, correct[ 9], 21, 0xeb86d391);
204
205 /* Add the starting values of the context. */
206 A += A_save;
207 B += B_save;
208 C += C_save;
209 D += D_save;
210 }
211
212 /* Put checksum in context given as argument. */
213 md5_p->md_A = A;
214 md5_p->md_B = B;
215 md5_p->md_C = C;
216 md5_p->md_D = D;
217 }
218
219 /*
220 * md5_get_result
221 *
222 * DESCRIPTION:
223 *
224 * Copy the resulting MD5 signature from MD5_P into the first 16 bytes
225 * (MD5_SIZE) of the result buffer.
226 *
227 * RETURNS:
228 *
229 * None.
230 *
231 * ARGUMENTS:
232 *
233 * md5_p - Pointer to MD5 structure from which we are getting the result.
234 *
235 * result - A 16 byte buffer that will contain the MD5 signature.
236 */
237 static void md5_get_result(const md5_t *md5_p, void *result)
238 {
239 md5_uint32 hold;
240 void *res_p = result;
241
242 hold = SWAP(md5_p->md_A);
243 memcpy(res_p, &hold, sizeof(md5_uint32));
244 res_p = (char *)res_p + sizeof(md5_uint32);
245
246 hold = SWAP(md5_p->md_B);
247 memcpy(res_p, &hold, sizeof(md5_uint32));
248 res_p = (char *)res_p + sizeof(md5_uint32);
249
250 hold = SWAP(md5_p->md_C);
251 memcpy(res_p, &hold, sizeof(md5_uint32));
252 res_p = (char *)res_p + sizeof(md5_uint32);
253
254 hold = SWAP(md5_p->md_D);
255 memcpy(res_p, &hold, sizeof(md5_uint32));
256 }
257
258 /***************************** exported routines *****************************/
259
260 /*
261 * md5_init
262 *
263 * DESCRIPTION:
264 *
265 * Initialize structure containing state of MD5 computation. (RFC 1321,
266 * 3.3: Step 3). This is for progressive MD5 calculations only. If
267 * you have the complete string available, md5_buffer should be used.
268 * md5_process should be called for each bunch of bytes and after the
269 * last process call, md5_finish should be called to get the
270 * signature.
271 *
272 * RETURNS:
273 *
274 * None.
275 *
276 * ARGUMENTS:
277 *
278 * md5_p - Pointer to md5 structure that we are initializing.
279 */
280 void md5_init(md5_t *md5_p)
281 {
282 md5_p->md_A = 0x67452301;
283 md5_p->md_B = 0xefcdab89;
284 md5_p->md_C = 0x98badcfe;
285 md5_p->md_D = 0x10325476;
286
287 md5_p->md_total[0] = 0;
288 md5_p->md_total[1] = 0;
289 md5_p->md_buf_len = 0;
290 }
291
292 /*
293 * md5_process
294 *
295 * DESCRIPTION:
296 *
297 * This function is used to progressively calculate a MD5 signature some
298 * number of bytes at a time. If you have the complete string
299 * available, md5_buffer should be used. The MD5 structure should
300 * have been initialized with md5_init and after the last process
301 * call, md5_finish should be called to get the results.
302 *
303 * RETURNS:
304 *
305 * None.
306 *
307 * ARGUMENTS:
308 *
309 * md5_p - Pointer to MD5 structure which we are progressively updating.
310 *
311 * buffer - A buffer of bytes whose MD5 signature we are calculating.
312 *
313 * buf_len - The length of the buffer.
314 */
315 void md5_process(md5_t *md5_p, const void *buffer,
316 const unsigned int buf_len)
317 {
318 unsigned int len = buf_len;
319 unsigned int in_block, add;
320
321 /*
322 * When we already have some bytes in our internal buffer, copy some
323 * from the user to fill the block.
324 */
325 if (md5_p->md_buf_len > 0) {
326
327 in_block = md5_p->md_buf_len;
328 if (in_block + len > sizeof(md5_p->md_buffer)) {
329 add = sizeof(md5_p->md_buffer) - in_block;
330 }
331 else {
332 add = len;
333 }
334
335 memcpy (md5_p->md_buffer + in_block, buffer, add);
336 md5_p->md_buf_len += add;
337 in_block += add;
338
339 if (in_block > MD5_BLOCK_SIZE) {
340 process_block (md5_p, md5_p->md_buffer, in_block & ~BLOCK_SIZE_MASK);
341 /* the regions in the following copy operation will not overlap. */
342 memcpy (md5_p->md_buffer,
343 md5_p->md_buffer + (in_block & ~BLOCK_SIZE_MASK),
344 in_block & BLOCK_SIZE_MASK);
345 md5_p->md_buf_len = in_block & BLOCK_SIZE_MASK;
346 }
347
348 buffer = (const char *)buffer + add;
349 len -= add;
350 }
351
352 /* process available complete blocks right from the user buffer */
353 if (len > MD5_BLOCK_SIZE) {
354 process_block (md5_p, buffer, len & ~BLOCK_SIZE_MASK);
355 buffer = (const char *) buffer + (len & ~BLOCK_SIZE_MASK);
356 len &= BLOCK_SIZE_MASK;
357 }
358
359 /* copy remaining bytes into the internal buffer */
360 if (len > 0) {
361 memcpy (md5_p->md_buffer, buffer, len);
362 md5_p->md_buf_len = len;
363 }
364 }
365
366 /*
367 * md5_finish
368 *
369 * DESCRIPTION:
370 *
371 * Finish a progressing MD5 calculation and copy the resulting MD5
372 * signature into the result buffer which should be 16 bytes
373 * (MD5_SIZE). After this call, the MD5 structure is invalid.
374 *
375 * RETURNS:
376 *
377 * None.
378 *
379 * ARGUMENTS:
380 *
381 * md5_p - Pointer to MD5 structure which we are finishing.
382 *
383 * signature - A 16 byte buffer that will contain the MD5 signature.
384 */
385 void md5_finish(md5_t *md5_p, void *signature)
386 {
387 md5_uint32 bytes, hold;
388 int pad;
389
390 /* take yet unprocessed bytes into account */
391 bytes = md5_p->md_buf_len;
392
393 /*
394 * Count remaining bytes. Modified to do this to better avoid
395 * overflows in the lower word -- Gray 10/97.
396 */
397 if (md5_p->md_total[0] > MAX_MD5_UINT32 - bytes) {
398 md5_p->md_total[1]++;
399 md5_p->md_total[0] -= (MAX_MD5_UINT32 - bytes);
400 }
401 else {
402 md5_p->md_total[0] += bytes;
403 }
404
405 /*
406 * Pad the buffer to the next MD5_BLOCK-byte boundary. (RFC 1321,
407 * 3.1: Step 1). We need enough room for two size words and the
408 * bytes left in the buffer. For some reason even if we are equal
409 * to the block-size, we add an addition block of pad bytes.
410 */
411 pad = MD5_BLOCK_SIZE - (sizeof(md5_uint32) * 2) - bytes;
412 if (pad <= 0) {
413 pad += MD5_BLOCK_SIZE;
414 }
415
416 /*
417 * Modified from a fixed array to this assignment and memset to be
418 * more flexible with block-sizes -- Gray 10/97.
419 */
420 if (pad > 0) {
421 /* some sort of padding start byte */
422 md5_p->md_buffer[bytes] = (unsigned char)0x80;
423 if (pad > 1) {
424 memset (md5_p->md_buffer + bytes + 1, 0, pad - 1);
425 }
426 bytes += pad;
427 }
428
429 /* put the 64-bit file length in _bits_ (i.e. *8) at the end of the buffer */
430 hold = SWAP(md5_p->md_total[0] << 3);
431 memcpy(md5_p->md_buffer + bytes, &hold, sizeof(md5_uint32));
432 bytes += sizeof(md5_uint32);
433
434 /* shift the high word over by 3 and add in the top 3 bits from the low */
435 hold = SWAP((md5_p->md_total[1] << 3) | (md5_p->md_total[0] >> 29));
436 memcpy(md5_p->md_buffer + bytes, &hold, sizeof(md5_uint32));
437 bytes += sizeof(md5_uint32);
438
439 /* process last bytes, the padding chars, and size words */
440 process_block(md5_p, md5_p->md_buffer, bytes);
441 md5_get_result(md5_p, signature);
442 }
443
444 /*
445 * md5_buffer
446 *
447 * DESCRIPTION:
448 *
449 * This function is used to calculate a MD5 signature for a buffer of
450 * bytes. If you only have part of a buffer that you want to process
451 * then md5_init, md5_process, and md5_finish should be used.
452 *
453 * RETURNS:
454 *
455 * None.
456 *
457 * ARGUMENTS:
458 *
459 * buffer - A buffer of bytes whose MD5 signature we are calculating.
460 *
461 * buf_len - The length of the buffer.
462 *
463 * signature - A 16 byte buffer that will contain the MD5 signature.
464 */
465 void md5_buffer(const char *buffer, const unsigned int buf_len,
466 void *signature)
467 {
468 md5_t md5;
469
470 /* initialize the computation context */
471 md5_init(&md5);
472
473 /* process whole buffer but last buf_len % MD5_BLOCK bytes */
474 md5_process(&md5, buffer, buf_len);
475
476 /* put result in desired memory area */
477 md5_finish(&md5, signature);
478 }
479
480 /*
481 * md5_sig_to_string
482 *
483 * DESCRIPTION:
484 *
485 * Convert a MD5 signature in a 16 byte buffer into a hexadecimal string
486 * representation.
487 *
488 * RETURNS:
489 *
490 * None.
491 *
492 * ARGUMENTS:
493 *
494 * signature - a 16 byte buffer that contains the MD5 signature.
495 *
496 * str - a string of charactes which should be at least 33 bytes long (2
497 * characters per MD5 byte and 1 for the \0).
498 *
499 * str_len - the length of the string.
500 */
501 void md5_sig_to_string(void *signature, char *str, const int str_len)
502 {
503 unsigned char *sig_p;
504 char *str_p, *max_p;
505 unsigned int high, low;
506
507 str_p = str;
508 max_p = str + str_len;
509
510 for (sig_p = (unsigned char *)signature;
511 sig_p < (unsigned char *)signature + MD5_SIZE;
512 sig_p++) {
513 high = *sig_p / 16;
514 low = *sig_p % 16;
515 /* account for 2 chars */
516 if (str_p + 1 >= max_p) {
517 break;
518 }
519 *str_p++ = HEX_STRING[high];
520 *str_p++ = HEX_STRING[low];
521 }
522 /* account for 2 chars */
523 if (str_p < max_p) {
524 *str_p++ = '\0';
525 }
526 }
527
528 /*
529 * md5_sig_from_string
530 *
531 * DESCRIPTION:
532 *
533 * Convert a MD5 signature from a hexadecimal string representation into
534 * a 16 byte buffer.
535 *
536 * RETURNS:
537 *
538 * None.
539 *
540 * ARGUMENTS:
541 *
542 * signature - A 16 byte buffer that will contain the MD5 signature.
543 *
544 * str - A string of charactes which _must_ be at least 32 bytes long (2
545 * characters per MD5 byte).
546 */
547 void md5_sig_from_string(void *signature, const char *str)
548 {
549 unsigned char *sig_p;
550 const char *str_p;
551 char *hex;
552 unsigned int high, low, val;
553
554 hex = HEX_STRING;
555 sig_p = signature;
556
557 for (str_p = str; str_p < str + MD5_SIZE * 2; str_p += 2) {
558 high = strchr(hex, *str_p) - hex;
559 low = strchr(hex, *(str_p + 1)) - hex;
560 val = high * 16 + low;
561 *sig_p++ = val;
562 }
563 }
564
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.