addrutil: Re-indent.
[wk-misc.git] / md5sum.c
1 /* md5sum.c - print MD5 Message-Digest Algorithm 
2  * Copyright (C) 1995, 1996, 1998, 1999,
3  *               2000, 2001, 2002 Free Software Foundation, Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; either version 2, or (at your option) any
8  * later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  *
19  * According to the definition of MD5 in RFC 1321 from April 1992.
20  * NOTE: This is *not* the same file as the one from glibc.
21  */
22 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
23 /* Heavily modified for GnuPG by <wk@gnupg.org> */
24
25 /* Test values:
26  * ""                  D4 1D 8C D9 8F 00 B2 04  E9 80 09 98 EC F8 42 7E
27  * "a"                 0C C1 75 B9 C0 F1 B6 A8  31 C3 99 E2 69 77 26 61
28  * "abc                90 01 50 98 3C D2 4F B0  D6 96 3F 7D 28 E1 7F 72
29  * "message digest"    F9 6B 69 7D 7C B7 93 8D  52 5A 2F 31 AA F1 61 D0
30  */
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36 #include <errno.h>
37
38 #undef BIG_ENDIAN_HOST
39 typedef unsigned int u32;
40
41 /****************
42  * Rotate a 32 bit integer by n bytes
43  */
44 #if defined(__GNUC__) && defined(__i386__)
45 static inline u32
46 rol( u32 x, int n)
47 {
48         __asm__("roll %%cl,%0"
49                 :"=r" (x)
50                 :"0" (x),"c" (n));
51         return x;
52 }
53 #else
54 #define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
55 #endif
56
57 typedef struct {
58     u32 A,B,C,D;          /* chaining variables */
59     u32  nblocks;
60     unsigned char buf[64];
61     int  count;
62 } MD5_CONTEXT;
63
64
65 static void
66 md5_init( MD5_CONTEXT *ctx )
67 {
68     ctx->A = 0x67452301;
69     ctx->B = 0xefcdab89;
70     ctx->C = 0x98badcfe;
71     ctx->D = 0x10325476;
72
73     ctx->nblocks = 0;
74     ctx->count = 0;
75 }
76
77
78
79
80 /* These are the four functions used in the four steps of the MD5 algorithm
81    and defined in the RFC 1321.  The first function is a little bit optimized
82    (as found in Colin Plumbs public domain implementation).  */
83 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
84 #define FF(b, c, d) (d ^ (b & (c ^ d)))
85 #define FG(b, c, d) FF (d, b, c)
86 #define FH(b, c, d) (b ^ c ^ d)
87 #define FI(b, c, d) (c ^ (b | ~d))
88
89
90 /****************
91  * transform n*64 bytes
92  */
93 static void
94 transform( MD5_CONTEXT *ctx, unsigned char *data )
95 {
96     u32 correct_words[16];
97     u32 A = ctx->A;
98     u32 B = ctx->B;
99     u32 C = ctx->C;
100     u32 D = ctx->D;
101     u32 *cwp = correct_words;
102
103 #ifdef BIG_ENDIAN_HOST
104     { int i;
105       unsigned char *p2, *p1;
106       for(i=0, p1=data, p2=(unsigned char*)correct_words; i < 16; i++, p2 += 4 ) {
107         p2[3] = *p1++;
108         p2[2] = *p1++;
109         p2[1] = *p1++;
110         p2[0] = *p1++;
111       }
112     }
113 #else
114     memcpy( correct_words, data, 64 );
115 #endif
116
117
118 #define OP(a, b, c, d, s, T)                                        \
119   do                                                                \
120     {                                                               \
121       a += FF (b, c, d) + (*cwp++) + T;             \
122       a = rol(a, s);                                                \
123       a += b;                                                       \
124     }                                                               \
125   while (0)
126
127     /* Before we start, one word about the strange constants.
128        They are defined in RFC 1321 as
129
130        T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
131      */
132
133     /* Round 1.  */
134     OP (A, B, C, D,  7, 0xd76aa478);
135     OP (D, A, B, C, 12, 0xe8c7b756);
136     OP (C, D, A, B, 17, 0x242070db);
137     OP (B, C, D, A, 22, 0xc1bdceee);
138     OP (A, B, C, D,  7, 0xf57c0faf);
139     OP (D, A, B, C, 12, 0x4787c62a);
140     OP (C, D, A, B, 17, 0xa8304613);
141     OP (B, C, D, A, 22, 0xfd469501);
142     OP (A, B, C, D,  7, 0x698098d8);
143     OP (D, A, B, C, 12, 0x8b44f7af);
144     OP (C, D, A, B, 17, 0xffff5bb1);
145     OP (B, C, D, A, 22, 0x895cd7be);
146     OP (A, B, C, D,  7, 0x6b901122);
147     OP (D, A, B, C, 12, 0xfd987193);
148     OP (C, D, A, B, 17, 0xa679438e);
149     OP (B, C, D, A, 22, 0x49b40821);
150
151 #undef OP
152 #define OP(f, a, b, c, d, k, s, T)  \
153     do                                                                \
154       {                                                               \
155         a += f (b, c, d) + correct_words[k] + T;                      \
156         a = rol(a, s);                                                \
157         a += b;                                                       \
158       }                                                               \
159     while (0)
160
161     /* Round 2.  */
162     OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
163     OP (FG, D, A, B, C,  6,  9, 0xc040b340);
164     OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
165     OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
166     OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
167     OP (FG, D, A, B, C, 10,  9, 0x02441453);
168     OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
169     OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
170     OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
171     OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
172     OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
173     OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
174     OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
175     OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
176     OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
177     OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
178
179     /* Round 3.  */
180     OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
181     OP (FH, D, A, B, C,  8, 11, 0x8771f681);
182     OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
183     OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
184     OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
185     OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
186     OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
187     OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
188     OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
189     OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
190     OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
191     OP (FH, B, C, D, A,  6, 23, 0x04881d05);
192     OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
193     OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
194     OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
195     OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
196
197     /* Round 4.  */
198     OP (FI, A, B, C, D,  0,  6, 0xf4292244);
199     OP (FI, D, A, B, C,  7, 10, 0x432aff97);
200     OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
201     OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
202     OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
203     OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
204     OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
205     OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
206     OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
207     OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
208     OP (FI, C, D, A, B,  6, 15, 0xa3014314);
209     OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
210     OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
211     OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
212     OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
213     OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
214
215     /* Put checksum in context given as argument.  */
216     ctx->A += A;
217     ctx->B += B;
218     ctx->C += C;
219     ctx->D += D;
220 }
221
222
223
224 /* The routine updates the message-digest context to
225  * account for the presence of each of the characters inBuf[0..inLen-1]
226  * in the message whose digest is being computed.
227  */
228 static void
229 md5_write( MD5_CONTEXT *hd, unsigned char *inbuf, size_t inlen)
230 {
231     if( hd->count == 64 ) { /* flush the buffer */
232         transform( hd, hd->buf );
233         hd->count = 0;
234         hd->nblocks++;
235     }
236     if( !inbuf )
237         return;
238     if( hd->count ) {
239         for( ; inlen && hd->count < 64; inlen-- )
240             hd->buf[hd->count++] = *inbuf++;
241         md5_write( hd, NULL, 0 );
242         if( !inlen )
243             return;
244     }
245
246     while( inlen >= 64 ) {
247         transform( hd, inbuf );
248         hd->count = 0;
249         hd->nblocks++;
250         inlen -= 64;
251         inbuf += 64;
252     }
253     for( ; inlen && hd->count < 64; inlen-- )
254         hd->buf[hd->count++] = *inbuf++;
255 }
256
257
258
259 /* The routine final terminates the message-digest computation and
260  * ends with the desired message digest in mdContext->digest[0...15].
261  * The handle is prepared for a new MD5 cycle.
262  * Returns 16 bytes representing the digest.
263  */
264
265 static void
266 md5_final( MD5_CONTEXT *hd )
267 {
268     u32 t, msb, lsb;
269     unsigned char *p;
270
271     md5_write(hd, NULL, 0); /* flush */;
272
273     t = hd->nblocks;
274     /* multiply by 64 to make a byte count */
275     lsb = t << 6;
276     msb = t >> 26;
277     /* add the count */
278     t = lsb;
279     if( (lsb += hd->count) < t )
280         msb++;
281     /* multiply by 8 to make a bit count */
282     t = lsb;
283     lsb <<= 3;
284     msb <<= 3;
285     msb |= t >> 29;
286
287     if( hd->count < 56 ) { /* enough room */
288         hd->buf[hd->count++] = 0x80; /* pad */
289         while( hd->count < 56 )
290             hd->buf[hd->count++] = 0;  /* pad */
291     }
292     else { /* need one extra block */
293         hd->buf[hd->count++] = 0x80; /* pad character */
294         while( hd->count < 64 )
295             hd->buf[hd->count++] = 0;
296         md5_write(hd, NULL, 0);  /* flush */;
297         memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
298     }
299     /* append the 64 bit count */
300     hd->buf[56] = lsb      ;
301     hd->buf[57] = lsb >>  8;
302     hd->buf[58] = lsb >> 16;
303     hd->buf[59] = lsb >> 24;
304     hd->buf[60] = msb      ;
305     hd->buf[61] = msb >>  8;
306     hd->buf[62] = msb >> 16;
307     hd->buf[63] = msb >> 24;
308     transform( hd, hd->buf );
309
310     p = hd->buf;
311 #ifdef BIG_ENDIAN_HOST
312 #define X(a) do { *p++ = hd-> a      ; *p++ = hd-> a >> 8;      \
313                   *p++ = hd-> a >> 16; *p++ = hd-> a >> 24; } while(0)
314 #else /* little endian */
315 #define X(a) do { *(u32*)p = hd-> a ; p += 4; } while(0)
316 #endif
317     X(A);
318     X(B);
319     X(C);
320     X(D);
321 #undef X
322
323 }
324
325
326 int 
327 main (int argc, char **argv)
328 {
329   assert (sizeof (u32) == 4);
330
331   if (argc < 2)
332     {
333       fprintf (stderr, "usage: md5sum filenames\n");
334       exit (1);
335     }
336   for (argc--, argv++; argc; argv++, argc--)
337     {
338       FILE *fp;
339       char buffer[4096];
340       size_t n;
341       MD5_CONTEXT ctx;
342       int i;
343       
344       fp = fopen (*argv, "rb");
345       if (!fp)
346         {
347           fprintf (stderr, "can't open `%s': %s\n", *argv, strerror (errno));
348           exit (1);
349         }
350       md5_init (&ctx);
351       while ( (n = fread (buffer, 1, sizeof buffer, fp)))
352         md5_write (&ctx, buffer, n);
353       if (ferror (fp))
354         {
355           fprintf (stderr, "error reading `%s': %s\n", *argv,strerror (errno));
356           exit (1);
357         }
358       md5_final (&ctx);
359       fclose (fp);
360       
361       for (i=0; i < 16; i++)
362         printf ("%02x", ctx.buf[i]);
363       printf ("  %s\n", *argv);
364     }
365   return 0;
366 }
367
368 /*
369 Local Variables:
370 compile-command: "cc -Wall -g -o md5sum md5sum.c"
371 End:
372 */