applied Mathews typo and grammar fixes
[gnupg.git] / cipher / md5.c
1 /* md5.c - MD5 Message-Digest Algorithm
2  *      Copyright (C) 1995, 1996, 1998 Free Software Foundation, Inc.
3  *
4  * according to the definition of MD5 in RFC 1321 from April 1992.
5  * NOTE: This is *not* the same file as the one from glibc.
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by the
9  * Free Software Foundation; either version 2, or (at your option) any
10  * later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
22 /* modified for GNUPG by <werner.koch@guug.de> */
23
24 /* Test values:
25  * ""                  D4 1D 8C D9 8F 00 B2 04  E9 80 09 98 EC F8 42 7E
26  * "a"                 0C C1 75 B9 C0 F1 B6 A8  31 C3 99 E2 69 77 26 61
27  * "abc                90 01 50 98 3C D2 4F B0  D6 96 3F 7D 28 E1 7F 72
28  * "message digest"    F9 6B 69 7D 7C B7 93 8D  52 5A 2F 31 AA F1 61 D0
29  */
30
31 #include <config.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36 #include "util.h"
37 #include "md5.h"
38 #include "memory.h"
39
40
41 #ifdef BIG_ENDIAN_HOST
42   #define SWAP(n) \
43     (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
44 #else
45   #define SWAP(n) (n)
46 #endif
47
48 /* This array contains the bytes used to pad the buffer to the next
49    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
50 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
51
52 void
53 md5_init( MD5_CONTEXT *ctx )
54 {
55     ctx->A = 0x67452301;
56     ctx->B = 0xefcdab89;
57     ctx->C = 0x98badcfe;
58     ctx->D = 0x10325476;
59
60     ctx->total[0] = ctx->total[1] = 0;
61     ctx->buflen = 0;
62 }
63
64
65
66
67 /* These are the four functions used in the four steps of the MD5 algorithm
68    and defined in the RFC 1321.  The first function is a little bit optimized
69    (as found in Colin Plumbs public domain implementation).  */
70 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
71 #define FF(b, c, d) (d ^ (b & (c ^ d)))
72 #define FG(b, c, d) FF (d, b, c)
73 #define FH(b, c, d) (b ^ c ^ d)
74 #define FI(b, c, d) (c ^ (b | ~d))
75
76
77 /****************
78  * transform n*64 bytes
79  */
80 static void
81 transform( MD5_CONTEXT *ctx, const void *buffer, size_t len )
82 {
83     u32 correct_words[16];
84     const u32 *words = buffer;
85     size_t nwords = len / sizeof(u32);
86     const u32 *endp = words + nwords;
87     u32 A = ctx->A;
88     u32 B = ctx->B;
89     u32 C = ctx->C;
90     u32 D = ctx->D;
91
92     /* First increment the byte count.  RFC 1321 specifies the possible
93        length of the file up to 2^64 bits.  Here we only compute the
94        number of bytes.  Do a double word increment.  */
95     ctx->total[0] += len;
96     if( ctx->total[0] < len )
97         ++ctx->total[1];
98
99
100     /* Process all bytes in the buffer with 64 bytes in each round of
101        the loop.  */
102     while(words < endp) {
103         u32 *cwp = correct_words;
104         u32 A_save = A;
105         u32 B_save = B;
106         u32 C_save = C;
107         u32 D_save = D;
108
109       /* First round: using the given function, the context and a constant
110          the next context is computed.  Because the algorithm's processing
111          unit is a 32-bit word, and it is determined to work on words in
112          little endian byte order, we perhaps have to change the byte order
113          before the computation.  To reduce the work for the next steps
114          we store the swapped words in the array CORRECT_WORDS.  */
115
116 #define OP(a, b, c, d, s, T)                                            \
117       do                                                                \
118         {                                                               \
119           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
120           ++words;                                                      \
121           CYCLIC (a, s);                                                \
122           a += b;                                                       \
123         }                                                               \
124       while (0)
125
126       /* It is unfortunate that C does not provide an operator for
127          cyclic rotation.  Hope the C compiler is smart enough.  */
128 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
129
130         /* Before we start, one word about the strange constants.
131            They are defined in RFC 1321 as
132
133            T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
134          */
135
136         /* Round 1.  */
137         OP (A, B, C, D,  7, 0xd76aa478);
138         OP (D, A, B, C, 12, 0xe8c7b756);
139         OP (C, D, A, B, 17, 0x242070db);
140         OP (B, C, D, A, 22, 0xc1bdceee);
141         OP (A, B, C, D,  7, 0xf57c0faf);
142         OP (D, A, B, C, 12, 0x4787c62a);
143         OP (C, D, A, B, 17, 0xa8304613);
144         OP (B, C, D, A, 22, 0xfd469501);
145         OP (A, B, C, D,  7, 0x698098d8);
146         OP (D, A, B, C, 12, 0x8b44f7af);
147         OP (C, D, A, B, 17, 0xffff5bb1);
148         OP (B, C, D, A, 22, 0x895cd7be);
149         OP (A, B, C, D,  7, 0x6b901122);
150         OP (D, A, B, C, 12, 0xfd987193);
151         OP (C, D, A, B, 17, 0xa679438e);
152         OP (B, C, D, A, 22, 0x49b40821);
153
154         /* For the second to fourth round we have the possibly swapped words
155            in CORRECT_WORDS.  Redefine the macro to take an additional first
156            argument specifying the function to use.  */
157 #undef OP
158 #define OP(f, a, b, c, d, k, s, T)  \
159         do                                                                \
160           {                                                               \
161             a += f (b, c, d) + correct_words[k] + T;                      \
162             CYCLIC (a, s);                                                \
163             a += b;                                                       \
164           }                                                               \
165         while (0)
166
167         /* Round 2.  */
168         OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
169         OP (FG, D, A, B, C,  6,  9, 0xc040b340);
170         OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
171         OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
172         OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
173         OP (FG, D, A, B, C, 10,  9, 0x02441453);
174         OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
175         OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
176         OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
177         OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
178         OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
179         OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
180         OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
181         OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
182         OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
183         OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
184
185         /* Round 3.  */
186         OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
187         OP (FH, D, A, B, C,  8, 11, 0x8771f681);
188         OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
189         OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
190         OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
191         OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
192         OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
193         OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
194         OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
195         OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
196         OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
197         OP (FH, B, C, D, A,  6, 23, 0x04881d05);
198         OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
199         OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
200         OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
201         OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
202
203         /* Round 4.  */
204         OP (FI, A, B, C, D,  0,  6, 0xf4292244);
205         OP (FI, D, A, B, C,  7, 10, 0x432aff97);
206         OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
207         OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
208         OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
209         OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
210         OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
211         OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
212         OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
213         OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
214         OP (FI, C, D, A, B,  6, 15, 0xa3014314);
215         OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
216         OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
217         OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
218         OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
219         OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
220         /* Add the starting values of the context.  */
221         A += A_save;
222         B += B_save;
223         C += C_save;
224         D += D_save;
225     }
226
227     /* Put checksum in context given as argument.  */
228     ctx->A = A;
229     ctx->B = B;
230     ctx->C = C;
231     ctx->D = D;
232 }
233
234
235
236 /* The routine updates the message-digest context to
237  * account for the presence of each of the characters inBuf[0..inLen-1]
238  * in the message whose digest is being computed.
239  */
240 void
241 md5_write( MD5_CONTEXT *ctx, const void *buffer, size_t len)
242 {
243     /* When we already have some bits in our internal buffer concatenate
244        both inputs first.  */
245     if (ctx->buflen != 0)
246       {
247         size_t left_over = ctx->buflen;
248         size_t add = 128 - left_over > len ? len : 128 - left_over;
249
250         memcpy (&ctx->buffer[left_over], buffer, add);
251         ctx->buflen += add;
252
253         if (left_over + add > 64)
254           {
255             transform(ctx, ctx->buffer, (left_over + add) & ~63);
256             /* The regions in the following copy operation cannot overlap.  */
257             memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
258                     (left_over + add) & 63);
259             ctx->buflen = (left_over + add) & 63;
260           }
261
262         buffer = (const char *) buffer + add;
263         len -= add;
264       }
265
266     /* Process available complete blocks.  */
267     if (len > 64)
268       {
269         transform( ctx, buffer, len & ~63);
270         buffer = (const char *) buffer + (len & ~63);
271         len &= 63;
272       }
273
274     /* Move remaining bytes in internal buffer.  */
275     if (len > 0)
276       {
277         memcpy (ctx->buffer, buffer, len);
278         ctx->buflen = len;
279       }
280 }
281
282
283
284 /* The routine final terminates the message-digest computation and
285  * ends with the desired message digest in mdContext->digest[0...15].
286  * The handle is prepared for a new MD5 cycle.
287  * Returns 16 bytes representing the digest.
288  */
289
290 void
291 md5_final( MD5_CONTEXT *ctx )
292 {
293     /* Take yet unprocessed bytes into account.  */
294     u32 bytes = ctx->buflen;
295     size_t pad;
296
297     /* Now count remaining bytes.  */
298     ctx->total[0] += bytes;
299     if( ctx->total[0] < bytes )
300         ++ctx->total[1];
301
302     pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
303     memcpy (&ctx->buffer[bytes], fillbuf, pad);
304
305     /* Put the 64-bit file length in *bits* at the end of the buffer.  */
306     *(u32 *) &ctx->buffer[bytes + pad] = SWAP (ctx->total[0] << 3);
307     *(u32 *) &ctx->buffer[bytes + pad + 4] = SWAP ((ctx->total[1] << 3) |
308                                                     (ctx->total[0] >> 29));
309
310     /* Process last bytes.  */
311     transform( ctx, ctx->buffer, bytes + pad + 8);
312
313     /* Store the result in buffer */
314     ((u32 *)ctx->buffer)[0] = SWAP (ctx->A);
315     ((u32 *)ctx->buffer)[1] = SWAP (ctx->B);
316     ((u32 *)ctx->buffer)[2] = SWAP (ctx->C);
317     ((u32 *)ctx->buffer)[3] = SWAP (ctx->D);
318 }
319
320
321
322 /* end of file */