d70bfc3ca44b1f1f36e1276d10bf51d01642a400
[claws.git] / src / common / md5.c
1 /* md5.c - MD5 Message-Digest Algorithm
2  *      Copyright (C) 1995, 1996, 1998, 1999 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 3, 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, see <http://www.gnu.org/licenses/>.
19  */
20 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
21 /* heavily modified for GnuPG by <werner.koch@guug.de> */
22 /* modified again for Sylpheed by <wk@gnupg.org> 2001-02-11 */
23
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 <config.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <assert.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <fcntl.h>
40
41 #include "md5.h"
42 #include "utils.h"
43
44 /****************
45  * Rotate a 32 bit integer by n bytes
46  */
47 #if defined(__GNUC__) && defined(__i386__)
48 static inline u32
49 rol( u32 x, int n)
50 {
51         __asm__("roll %%cl,%0"
52                 :"=r" (x)
53                 :"0" (x),"c" (n));
54         return x;
55 }
56 #else
57 #define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
58 #endif
59
60
61 static void
62 md5_init(MD5_CONTEXT *ctx)
63 {
64         ctx->A = 0x67452301;
65         ctx->B = 0xefcdab89;
66         ctx->C = 0x98badcfe;
67         ctx->D = 0x10325476;
68
69         ctx->nblocks = 0;
70         ctx->count = 0;
71         ctx->finalized = 0;
72 }
73
74 /* These are the four functions used in the four steps of the MD5 algorithm
75    and defined in the RFC 1321.  The first function is a little bit optimized
76    (as found in Colin Plumbs public domain implementation).  */
77 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
78 #define FF(b, c, d) (d ^ (b & (c ^ d)))
79 #define FG(b, c, d) FF (d, b, c)
80 #define FH(b, c, d) (b ^ c ^ d)
81 #define FI(b, c, d) (c ^ (b | ~d))
82
83
84 /****************
85  * transform n*64 bytes
86  */
87 static void
88 transform(MD5_CONTEXT *ctx, const unsigned char *data)
89 {
90         u32 correct_words[16];
91         u32 A = ctx->A;
92         u32 B = ctx->B;
93         u32 C = ctx->C;
94         u32 D = ctx->D;
95         u32 *cwp = correct_words;
96
97 #ifdef BIG_ENDIAN_HOST
98         {
99                 int i;
100                 unsigned char *p2;
101                 const unsigned char *p1;
102
103                 for (i = 0, p1 = data, p2 = (unsigned char*)correct_words;
104                      i < 16; i++, p2 += 4) {
105                         p2[3] = *p1++;
106                         p2[2] = *p1++;
107                         p2[1] = *p1++;
108                         p2[0] = *p1++;
109                 }
110         }
111 #else
112         memcpy(correct_words, data, 64);
113 #endif
114
115
116 #define OP(a, b, c, d, s, T)                            \
117         do {                                            \
118                 a += FF (b, c, d) + (*cwp++) + T;       \
119                 a = rol(a, s);                          \
120                 a += b;                                 \
121         } while (0)
122
123         /* Before we start, one word about the strange constants.
124            They are defined in RFC 1321 as
125
126            T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
127          */
128
129         /* Round 1.  */
130         OP (A, B, C, D,  7, 0xd76aa478);
131         OP (D, A, B, C, 12, 0xe8c7b756);
132         OP (C, D, A, B, 17, 0x242070db);
133         OP (B, C, D, A, 22, 0xc1bdceee);
134         OP (A, B, C, D,  7, 0xf57c0faf);
135         OP (D, A, B, C, 12, 0x4787c62a);
136         OP (C, D, A, B, 17, 0xa8304613);
137         OP (B, C, D, A, 22, 0xfd469501);
138         OP (A, B, C, D,  7, 0x698098d8);
139         OP (D, A, B, C, 12, 0x8b44f7af);
140         OP (C, D, A, B, 17, 0xffff5bb1);
141         OP (B, C, D, A, 22, 0x895cd7be);
142         OP (A, B, C, D,  7, 0x6b901122);
143         OP (D, A, B, C, 12, 0xfd987193);
144         OP (C, D, A, B, 17, 0xa679438e);
145         OP (B, C, D, A, 22, 0x49b40821);
146
147 #undef OP
148 #define OP(f, a, b, c, d, k, s, T)  \
149         do {                                                    \
150                 a += f (b, c, d) + correct_words[k] + T;        \
151                 a = rol(a, s);                                  \
152                 a += b;                                         \
153         } while (0)
154
155         /* Round 2.  */
156         OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
157         OP (FG, D, A, B, C,  6,  9, 0xc040b340);
158         OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
159         OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
160         OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
161         OP (FG, D, A, B, C, 10,  9, 0x02441453);
162         OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
163         OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
164         OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
165         OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
166         OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
167         OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
168         OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
169         OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
170         OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
171         OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
172
173         /* Round 3.  */
174         OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
175         OP (FH, D, A, B, C,  8, 11, 0x8771f681);
176         OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
177         OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
178         OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
179         OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
180         OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
181         OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
182         OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
183         OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
184         OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
185         OP (FH, B, C, D, A,  6, 23, 0x04881d05);
186         OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
187         OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
188         OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
189         OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
190
191         /* Round 4.  */
192         OP (FI, A, B, C, D,  0,  6, 0xf4292244);
193         OP (FI, D, A, B, C,  7, 10, 0x432aff97);
194         OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
195         OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
196         OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
197         OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
198         OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
199         OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
200         OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
201         OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
202         OP (FI, C, D, A, B,  6, 15, 0xa3014314);
203         OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
204         OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
205         OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
206         OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
207         OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
208
209         /* Put checksum in context given as argument.  */
210         ctx->A += A;
211         ctx->B += B;
212         ctx->C += C;
213         ctx->D += D;
214 }
215
216
217
218 /* The routine updates the message-digest context to
219  * account for the presence of each of the characters inBuf[0..inLen-1]
220  * in the message whose digest is being computed.
221  */
222 static void
223 md5_update(MD5_CONTEXT *hd, const unsigned char *inbuf, size_t inlen)
224 {
225         if (hd->count == 64) { /* flush the buffer */
226                 transform( hd, hd->buf );
227                 hd->count = 0;
228                 hd->nblocks++;
229         }
230         if (!inbuf)
231                 return;
232         if (hd->count) {
233                 for (; inlen && hd->count < 64; inlen--)
234                         hd->buf[hd->count++] = *inbuf++;
235                 md5_update(hd, NULL, 0);
236                 if (!inlen)
237                         return;
238         }
239
240         while (inlen >= 64) {
241                 transform(hd, inbuf);
242                 hd->count = 0;
243                 hd->nblocks++;
244                 inlen -= 64;
245                 inbuf += 64;
246         }
247
248         for (; inlen && hd->count < 64; inlen--)
249                 hd->buf[hd->count++] = *inbuf++;
250 }
251
252
253
254 /* The routine final terminates the message-digest computation and
255  * ends with the desired message digest in mdContext->digest[0...15].
256  * The handle is prepared for a new MD5 cycle.
257  * Returns 16 bytes representing the digest.
258  */
259
260 static void
261 do_final(MD5_CONTEXT *hd)
262 {
263         u32 t, msb, lsb;
264         unsigned char *p;
265
266         md5_update(hd, NULL, 0); /* flush */
267
268         msb = 0;
269         t = hd->nblocks;
270         if ((lsb = t << 6) < t) /* multiply by 64 to make a byte count */
271                 msb++;
272         msb += t >> 26;
273         t = lsb;
274         if ((lsb = t + hd->count) < t) /* add the count */
275                 msb++;
276         t = lsb;
277         if ((lsb = t << 3) < t) /* multiply by 8 to make a bit count */
278                 msb++;
279         msb += t >> 29;
280
281         if (hd->count < 56) { /* enough room */
282                 hd->buf[hd->count++] = 0x80; /* pad */
283                 while(hd->count < 56)
284                         hd->buf[hd->count++] = 0;  /* pad */
285         } else { /* need one extra block */
286                 hd->buf[hd->count++] = 0x80; /* pad character */
287                 while (hd->count < 64)
288                         hd->buf[hd->count++] = 0;
289                 md5_update(hd, NULL, 0);  /* flush */
290                 memset(hd->buf, 0, 56); /* fill next block with zeroes */
291         }
292
293         /* append the 64 bit count */
294         hd->buf[56] = lsb      ;
295         hd->buf[57] = lsb >>  8;
296         hd->buf[58] = lsb >> 16;
297         hd->buf[59] = lsb >> 24;
298         hd->buf[60] = msb      ;
299         hd->buf[61] = msb >>  8;
300         hd->buf[62] = msb >> 16;
301         hd->buf[63] = msb >> 24;
302         transform(hd, hd->buf);
303
304         p = hd->buf;
305 #ifdef BIG_ENDIAN_HOST
306 #define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
307                   *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
308 #else /* little endian */
309         /*#define X(a) do { *(u32*)p = hd->##a ; p += 4; } while(0)*/
310         /* Unixware's cpp doesn't like the above construct so we do it his way:
311          * (reported by Allan Clark) */
312 #define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0)
313 #endif
314         X(A);
315         X(B);
316         X(C);
317         X(D);
318 #undef X
319         hd->finalized = 1;
320 }
321
322 static void
323 md5_final(unsigned char *digest, MD5_CONTEXT *ctx)
324 {
325         if (!ctx->finalized)
326                 do_final(ctx);
327         memcpy(digest, ctx->buf, 16);
328 }
329
330 /*
331  * Creates a MD5 digest in hex fomrat (lowercase letters) from the
332  * string S.  hextdigest but be buffer of at lease 33 bytes!
333  */
334 static void
335 md5_hex_digest_binary(char *hexdigest, const unsigned char *s, size_t len)
336 {
337         int i;
338         MD5_CONTEXT context;
339         unsigned char digest[16];
340
341         md5_init(&context);
342         md5_update(&context, s, len);
343         md5_final(digest, &context);
344
345         for (i = 0; i < 16; i++)
346                 sprintf(hexdigest + 2 * i, "%02x", digest[i]);
347 }
348
349 int 
350 md5_hex_digest_file(char *hexdigest, const unsigned char *file)
351 {
352         int READ_BLOCK_SIZE=4096;
353         int len;
354         char *buf = malloc(READ_BLOCK_SIZE); /* alloc the first block */
355         char *lastp = buf; /* point to the start of the buffer */
356         size_t total = 0; /* total length read */
357         int num_alloc = 1; /* number of blocks allocated */
358         int fd = open(file, O_RDONLY);
359
360         if (fd == -1) {
361                 FILE_OP_ERROR(file, "open");
362                 return -1;
363         }
364         
365         while ((len = read(fd, lastp, READ_BLOCK_SIZE)) > 0) { /* read one block (which is allocated) */
366                 total += len; /* update the total length */
367                 num_alloc++; /* increase number of allocs */
368                 buf = realloc(buf, READ_BLOCK_SIZE*num_alloc); /* allocate one more block for next read */
369                 lastp = buf+total; /* point to the end of read stuff to buf */
370         }
371
372         close(fd);
373         md5_hex_digest_binary(hexdigest, buf, total);
374         free(buf);
375         // printf("%s  %s\n", hexdigest, file);
376         return 0;
377 }
378
379 /*
380  * Creates a MD5 digest in hex fomrat (lowercase letters) from the
381  * string S.  hextdigest but be buffer of at lease 33 bytes!
382  */
383 void
384 md5_hex_digest(char *hexdigest, const unsigned char *s)
385 {
386         md5_hex_digest_binary(hexdigest, s, strlen(s));
387 }
388
389 /*
390 ** Function: md5_hmac
391 ** taken from the file rfc2104.txt
392 ** written by Martin Schaaf <mascha@ma-scha.de>
393 */
394 static void
395 md5_hmac(unsigned char *digest,
396          const unsigned char* text, int text_len,
397          const unsigned char* key, int key_len)
398 {
399         MD5_CONTEXT context;
400         unsigned char k_ipad[64];    /* inner padding -
401                                       * key XORd with ipad
402                                       */
403         unsigned char k_opad[64];    /* outer padding -
404                                       * key XORd with opad
405                                       */
406         /* unsigned char tk[16]; */
407         int i;
408
409         /* start out by storing key in pads */
410         memset(k_ipad, 0, sizeof k_ipad);
411         memset(k_opad, 0, sizeof k_opad);
412         if (key_len > 64) {
413                 /* if key is longer than 64 bytes reset it to key=MD5(key) */
414                 MD5_CONTEXT tctx;
415
416                 md5_init(&tctx);
417                 md5_update(&tctx, key, key_len);
418                 md5_final(k_ipad, &tctx);
419                 md5_final(k_opad, &tctx);
420         } else {
421                 memcpy(k_ipad, key, key_len);
422                 memcpy(k_opad, key, key_len);
423         }
424
425         /*
426          * the HMAC_MD5 transform looks like:
427          *
428          * MD5(K XOR opad, MD5(K XOR ipad, text))
429          *
430          * where K is an n byte key
431          * ipad is the byte 0x36 repeated 64 times
432          * opad is the byte 0x5c repeated 64 times
433          * and text is the data being protected
434          */
435
436
437         /* XOR key with ipad and opad values */
438         for (i = 0; i < 64; i++) {
439                 k_ipad[i] ^= 0x36;
440                 k_opad[i] ^= 0x5c;
441         }
442
443         /*
444          * perform inner MD5
445          */
446         md5_init(&context);                   /* init context for 1st
447                                                * pass */
448         md5_update(&context, k_ipad, 64);     /* start with inner pad */
449         md5_update(&context, text, text_len); /* then text of datagram */
450         md5_final(digest, &context);          /* finish up 1st pass */
451         /*
452          * perform outer MD5
453          */
454         md5_init(&context);                   /* init context for 2nd
455                                                * pass */
456         md5_update(&context, k_opad, 64);     /* start with outer pad */
457         md5_update(&context, digest, 16);     /* then results of 1st
458                                                * hash */
459         md5_final(digest, &context);          /* finish up 2nd pass */
460 }
461
462
463 void
464 md5_hex_hmac(char *hexdigest,
465              const unsigned char* text, int text_len,
466              const unsigned char* key, int key_len)
467 {
468         unsigned char digest[16];
469         int i;
470
471         md5_hmac(digest, text, text_len, key, key_len);
472         for (i = 0; i < 16; i++)
473                 sprintf(hexdigest + 2 * i, "%02x", digest[i]);
474 }