Line data Source code
1 : /* -*- buffer-read-only: t -*- vi: set ro: */
2 : /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
3 : #line 1
4 : /* Functions to compute MD5 message digest of files or memory blocks.
5 : according to the definition of MD5 in RFC 1321 from April 1992.
6 : Copyright (C) 1995,1996,1997,1999,2000,2001,2005,2006,2008
7 : Free Software Foundation, Inc.
8 : This file is part of the GNU C Library.
9 :
10 : This program is free software; you can redistribute it and/or modify it
11 : under the terms of the GNU General Public License as published by the
12 : Free Software Foundation; either version 3, or (at your option) any
13 : later version.
14 :
15 : This program is distributed in the hope that it will be useful,
16 : but WITHOUT ANY WARRANTY; without even the implied warranty of
17 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 : GNU General Public License for more details.
19 :
20 : You should have received a copy of the GNU General Public License
21 : along with this program; if not, write to the Free Software Foundation,
22 : Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
23 :
24 : /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. */
25 :
26 : #include <config.h>
27 :
28 : #include "md5.h"
29 :
30 : #include <stddef.h>
31 : #include <stdlib.h>
32 : #include <string.h>
33 : #include <sys/types.h>
34 :
35 : #if USE_UNLOCKED_IO
36 : # include "unlocked-io.h"
37 : #endif
38 :
39 : #ifdef _LIBC
40 : # include <endian.h>
41 : # if __BYTE_ORDER == __BIG_ENDIAN
42 : # define WORDS_BIGENDIAN 1
43 : # endif
44 : /* We need to keep the namespace clean so define the MD5 function
45 : protected using leading __ . */
46 : # define md5_init_ctx __md5_init_ctx
47 : # define md5_process_block __md5_process_block
48 : # define md5_process_bytes __md5_process_bytes
49 : # define md5_finish_ctx __md5_finish_ctx
50 : # define md5_read_ctx __md5_read_ctx
51 : # define md5_stream __md5_stream
52 : # define md5_buffer __md5_buffer
53 : #endif
54 :
55 : #ifdef WORDS_BIGENDIAN
56 : # define SWAP(n) \
57 : (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
58 : #else
59 : # define SWAP(n) (n)
60 : #endif
61 :
62 : #define BLOCKSIZE 4096
63 : #if BLOCKSIZE % 64 != 0
64 : # error "invalid BLOCKSIZE"
65 : #endif
66 :
67 : /* This array contains the bytes used to pad the buffer to the next
68 : 64-byte boundary. (RFC 1321, 3.1: Step 1) */
69 : static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
70 :
71 :
72 38 : /* Initialize structure containing state of computation.
73 : (RFC 1321, 3.3: Step 3) */
74 38 : void
75 38 : md5_init_ctx (struct md5_ctx *ctx)
76 38 : {
77 38 : ctx->A = 0x67452301;
78 : ctx->B = 0xefcdab89;
79 38 : ctx->C = 0x98badcfe;
80 38 : ctx->D = 0x10325476;
81 38 :
82 : ctx->total[0] = ctx->total[1] = 0;
83 : ctx->buflen = 0;
84 : }
85 :
86 : /* Copy the 4 byte value from v into the memory location pointed to by *cp,
87 140 : If your architecture allows unaligned access this is equivalent to
88 : * (uint32_t *) cp = v */
89 140 : static inline void
90 140 : set_uint32 (char *cp, uint32_t v)
91 : {
92 : memcpy (cp, &v, sizeof v);
93 : }
94 :
95 35 : /* Put result from CTX in first 16 bytes following RESBUF. The result
96 : must be in little endian byte order. */
97 35 : void *
98 35 : md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
99 35 : {
100 35 : char *r = resbuf;
101 35 : set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A));
102 : set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B));
103 35 : set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C));
104 : set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D));
105 :
106 : return resbuf;
107 : }
108 :
109 35 : /* Process the remaining bytes in the internal buffer and the usual
110 : prolog according to the standard and write the result to RESBUF. */
111 : void *
112 35 : md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
113 35 : {
114 : /* Take yet unprocessed bytes into account. */
115 : uint32_t bytes = ctx->buflen;
116 35 : size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
117 35 :
118 0 : /* Now count remaining bytes. */
119 : ctx->total[0] += bytes;
120 : if (ctx->total[0] < bytes)
121 35 : ++ctx->total[1];
122 35 :
123 : /* Put the 64-bit file length in *bits* at the end of the buffer. */
124 35 : ctx->buffer[size - 2] = SWAP (ctx->total[0] << 3);
125 : ctx->buffer[size - 1] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
126 :
127 35 : memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
128 :
129 35 : /* Process last bytes. */
130 : md5_process_block (ctx->buffer, size * 4, ctx);
131 :
132 : return md5_read_ctx (ctx, resbuf);
133 : }
134 :
135 : /* Compute MD5 message digest for bytes read from STREAM. The
136 38 : resulting message digest number will be written into the 16 bytes
137 : beginning at RESBLOCK. */
138 : int
139 : md5_stream (FILE *stream, void *resblock)
140 : {
141 : struct md5_ctx ctx;
142 : char buffer[BLOCKSIZE + 72];
143 38 : size_t sum;
144 :
145 : /* Initialize the computation context. */
146 : md5_init_ctx (&ctx);
147 0 :
148 : /* Iterate over full file contents. */
149 : while (1)
150 : {
151 : /* We read the file in blocks of BLOCKSIZE bytes. One call of the
152 38 : computation function processes the whole buffer so that with the
153 : next round of the loop another block can be read. */
154 : size_t n;
155 : sum = 0;
156 :
157 40 : /* Read block. Take care for partial reads. */
158 : while (1)
159 39 : {
160 : n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
161 39 :
162 0 : sum += n;
163 :
164 39 : if (sum == BLOCKSIZE)
165 : break;
166 :
167 : if (n == 0)
168 : {
169 15 : /* Check for the error flag IFF N == 0, so that we don't
170 3 : exit the loop after a partial read due to e.g., EAGAIN
171 12 : or EWOULDBLOCK. */
172 : if (ferror (stream))
173 : return 1;
174 : goto process_partial_block;
175 : }
176 :
177 24 : /* We've read at least one byte, so ignore errors. But always
178 23 : check for EOF, since feof may be true even though N > 0.
179 : Otherwise, we could end up calling fread after EOF. */
180 : if (feof (stream))
181 : goto process_partial_block;
182 : }
183 :
184 0 : /* Process buffer with BLOCKSIZE bytes. Note that
185 : BLOCKSIZE % 64 == 0
186 : */
187 35 : md5_process_block (buffer, BLOCKSIZE, &ctx);
188 : }
189 :
190 35 : process_partial_block:
191 23 :
192 : /* Process any remaining bytes. */
193 : if (sum > 0)
194 35 : md5_process_bytes (buffer, sum, &ctx);
195 35 :
196 : /* Construct result in desired memory. */
197 : md5_finish_ctx (&ctx, resblock);
198 : return 0;
199 : }
200 :
201 : /* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
202 : result is always in little endian byte order, so that a byte-wise
203 0 : output yields to the wanted ASCII representation of the message
204 : digest. */
205 : void *
206 : md5_buffer (const char *buffer, size_t len, void *resblock)
207 : {
208 0 : struct md5_ctx ctx;
209 :
210 : /* Initialize the computation context. */
211 0 : md5_init_ctx (&ctx);
212 :
213 : /* Process whole buffer but last len % 64 bytes. */
214 0 : md5_process_bytes (buffer, len, &ctx);
215 :
216 : /* Put result in desired memory area. */
217 : return md5_finish_ctx (&ctx, resblock);
218 : }
219 23 :
220 :
221 : void
222 : md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
223 23 : {
224 : /* When we already have some bits in our internal buffer concatenate
225 0 : both inputs first. */
226 0 : if (ctx->buflen != 0)
227 : {
228 0 : size_t left_over = ctx->buflen;
229 0 : size_t add = 128 - left_over > len ? len : 128 - left_over;
230 :
231 0 : memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
232 : ctx->buflen += add;
233 0 :
234 : if (ctx->buflen > 64)
235 0 : {
236 : md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
237 0 :
238 0 : ctx->buflen &= 63;
239 0 : /* The regions in the following copy operation cannot overlap. */
240 : memcpy (ctx->buffer,
241 : &((char *) ctx->buffer)[(left_over + add) & ~63],
242 0 : ctx->buflen);
243 0 : }
244 :
245 : buffer = (const char *) buffer + add;
246 : len -= add;
247 23 : }
248 :
249 : /* Process available complete blocks. */
250 : if (len >= 64)
251 : {
252 0 : #if !_STRING_ARCH_unaligned
253 0 : # define alignof(type) offsetof (struct { char c; type x; }, x)
254 : # define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
255 0 : if (UNALIGNED_P (buffer))
256 0 : while (len > 64)
257 0 : {
258 : md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
259 : buffer = (const char *) buffer + 64;
260 : len -= 64;
261 : }
262 0 : else
263 0 : #endif
264 0 : {
265 : md5_process_block (buffer, len & ~63, ctx);
266 : buffer = (const char *) buffer + (len & ~63);
267 : len &= 63;
268 : }
269 23 : }
270 :
271 23 : /* Move remaining bytes in internal buffer. */
272 : if (len > 0)
273 23 : {
274 23 : size_t left_over = ctx->buflen;
275 23 :
276 : memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
277 0 : left_over += len;
278 0 : if (left_over >= 64)
279 0 : {
280 : md5_process_block (ctx->buffer, 64, ctx);
281 23 : left_over -= 64;
282 : memcpy (ctx->buffer, &ctx->buffer[16], left_over);
283 23 : }
284 : ctx->buflen = left_over;
285 : }
286 : }
287 :
288 :
289 : /* These are the four functions used in the four steps of the MD5 algorithm
290 : and defined in the RFC 1321. The first function is a little bit optimized
291 : (as found in Colin Plumbs public domain implementation). */
292 : /* #define FF(b, c, d) ((b & c) | (~b & d)) */
293 : #define FF(b, c, d) (d ^ (b & (c ^ d)))
294 : #define FG(b, c, d) FF (d, b, c)
295 : #define FH(b, c, d) (b ^ c ^ d)
296 : #define FI(b, c, d) (c ^ (b | ~d))
297 :
298 : /* Process LEN bytes of BUFFER, accumulating context into CTX.
299 35 : It is assumed that LEN % 64 == 0. */
300 :
301 : void
302 35 : md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
303 35 : {
304 35 : uint32_t correct_words[16];
305 35 : const uint32_t *words = buffer;
306 35 : size_t nwords = len / sizeof (uint32_t);
307 35 : const uint32_t *endp = words + nwords;
308 35 : uint32_t A = ctx->A;
309 : uint32_t B = ctx->B;
310 : uint32_t C = ctx->C;
311 : uint32_t D = ctx->D;
312 :
313 35 : /* First increment the byte count. RFC 1321 specifies the possible
314 35 : length of the file up to 2^64 bits. Here we only compute the
315 0 : number of bytes. Do a double word increment. */
316 : ctx->total[0] += len;
317 : if (ctx->total[0] < len)
318 : ++ctx->total[1];
319 105 :
320 : /* Process all bytes in the buffer with 64 bytes in each round of
321 35 : the loop. */
322 35 : while (words < endp)
323 35 : {
324 35 : uint32_t *cwp = correct_words;
325 35 : uint32_t A_save = A;
326 : uint32_t B_save = B;
327 : uint32_t C_save = C;
328 : uint32_t D_save = D;
329 :
330 : /* First round: using the given function, the context and a constant
331 : the next context is computed. Because the algorithms processing
332 : unit is a 32-bit word and it is determined to work on words in
333 : little endian byte order we perhaps have to change the byte order
334 : before the computation. To reduce the work for the next steps
335 : we store the swapped words in the array CORRECT_WORDS. */
336 :
337 : #define OP(a, b, c, d, s, T) \
338 : do \
339 : { \
340 : a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
341 : ++words; \
342 : CYCLIC (a, s); \
343 : a += b; \
344 : } \
345 : while (0)
346 :
347 : /* It is unfortunate that C does not provide an operator for
348 : cyclic rotation. Hope the C compiler is smart enough. */
349 : #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
350 :
351 : /* Before we start, one word to the strange constants.
352 : They are defined in RFC 1321 as
353 :
354 : T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
355 :
356 : Here is an equivalent invocation using Perl:
357 :
358 : perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
359 35 : */
360 35 :
361 35 : /* Round 1. */
362 35 : OP (A, B, C, D, 7, 0xd76aa478);
363 35 : OP (D, A, B, C, 12, 0xe8c7b756);
364 35 : OP (C, D, A, B, 17, 0x242070db);
365 35 : OP (B, C, D, A, 22, 0xc1bdceee);
366 35 : OP (A, B, C, D, 7, 0xf57c0faf);
367 35 : OP (D, A, B, C, 12, 0x4787c62a);
368 35 : OP (C, D, A, B, 17, 0xa8304613);
369 35 : OP (B, C, D, A, 22, 0xfd469501);
370 35 : OP (A, B, C, D, 7, 0x698098d8);
371 35 : OP (D, A, B, C, 12, 0x8b44f7af);
372 35 : OP (C, D, A, B, 17, 0xffff5bb1);
373 35 : OP (B, C, D, A, 22, 0x895cd7be);
374 35 : OP (A, B, C, D, 7, 0x6b901122);
375 : OP (D, A, B, C, 12, 0xfd987193);
376 : OP (C, D, A, B, 17, 0xa679438e);
377 : OP (B, C, D, A, 22, 0x49b40821);
378 :
379 : /* For the second to fourth round we have the possibly swapped words
380 : in CORRECT_WORDS. Redefine the macro to take an additional first
381 : argument specifying the function to use. */
382 : #undef OP
383 : #define OP(f, a, b, c, d, k, s, T) \
384 : do \
385 : { \
386 : a += f (b, c, d) + correct_words[k] + T; \
387 : CYCLIC (a, s); \
388 : a += b; \
389 : } \
390 35 : while (0)
391 35 :
392 35 : /* Round 2. */
393 35 : OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
394 35 : OP (FG, D, A, B, C, 6, 9, 0xc040b340);
395 35 : OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
396 35 : OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
397 35 : OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
398 35 : OP (FG, D, A, B, C, 10, 9, 0x02441453);
399 35 : OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
400 35 : OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
401 35 : OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
402 35 : OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
403 35 : OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
404 35 : OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
405 35 : OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
406 : OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
407 : OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
408 35 : OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
409 35 :
410 35 : /* Round 3. */
411 35 : OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
412 35 : OP (FH, D, A, B, C, 8, 11, 0x8771f681);
413 35 : OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
414 35 : OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
415 35 : OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
416 35 : OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
417 35 : OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
418 35 : OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
419 35 : OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
420 35 : OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
421 35 : OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
422 35 : OP (FH, B, C, D, A, 6, 23, 0x04881d05);
423 35 : OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
424 : OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
425 : OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
426 35 : OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
427 35 :
428 35 : /* Round 4. */
429 35 : OP (FI, A, B, C, D, 0, 6, 0xf4292244);
430 35 : OP (FI, D, A, B, C, 7, 10, 0x432aff97);
431 35 : OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
432 35 : OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
433 35 : OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
434 35 : OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
435 35 : OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
436 35 : OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
437 35 : OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
438 35 : OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
439 35 : OP (FI, C, D, A, B, 6, 15, 0xa3014314);
440 35 : OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
441 35 : OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
442 : OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
443 : OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
444 35 : OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
445 35 :
446 35 : /* Add the starting values of the context. */
447 35 : A += A_save;
448 : B += B_save;
449 : C += C_save;
450 : D += D_save;
451 35 : }
452 35 :
453 35 : /* Put checksum in context given as argument. */
454 35 : ctx->A = A;
455 35 : ctx->B = B;
456 : ctx->C = C;
457 : ctx->D = D;
458 : }
|
