8accdb9e80539133570612ee367b316321ae7b19
[exim.git] / src / src / auths / md5.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #ifndef STAND_ALONE
9 #include "../exim.h"
10
11 /* For stand-alone testing, we need to have the structure defined, and
12 to be able to do I/O */
13
14 #else
15 #include <stdio.h>
16 #include "../mytypes.h"
17 typedef struct md5 {
18   unsigned int length;
19   unsigned int abcd[4];
20   }
21 md5;
22 #endif
23
24
25
26 /*************************************************
27 *        Start off a new MD5 computation.        *
28 *************************************************/
29
30 /*
31 Argument:  pointer to md5 storage structure
32 Returns:   nothing
33 */
34
35 void
36 md5_start(md5 *base)
37 {
38 base->abcd[0] = 0x67452301;
39 base->abcd[1] = 0xefcdab89;
40 base->abcd[2] = 0x98badcfe;
41 base->abcd[3] = 0x10325476;
42 base->length = 0;
43 }
44
45
46
47 /*************************************************
48 *       Process another 64-byte block            *
49 *************************************************/
50
51 /* This function implements central part of the algorithm which is described
52 in RFC 1321.
53
54 Arguments:
55   base       pointer to md5 storage structure
56   text       pointer to next 64 bytes of subject text
57
58 Returns:     nothing
59 */
60
61 void
62 md5_mid(md5 *base, const uschar *text)
63 {
64 register unsigned int a = base->abcd[0];
65 register unsigned int b = base->abcd[1];
66 register unsigned int c = base->abcd[2];
67 register unsigned int d = base->abcd[3];
68 int i;
69 unsigned int X[16];
70 base->length += 64;
71
72 /* Load the 64 bytes into a set of working integers, treating them as 32-bit
73 numbers in little-endian order. */
74
75 for (i = 0; i < 16; i++)
76   {
77   X[i] = (unsigned int)(text[0]) |
78          ((unsigned int)(text[1]) << 8) |
79          ((unsigned int)(text[2]) << 16) |
80          ((unsigned int)(text[3]) << 24);
81   text += 4;
82   }
83
84 /* For each round of processing there is a function to be applied. We define it
85 as a macro each time round. */
86
87 /***********************************************
88 *                    Round 1                   *
89 *            F(X,Y,Z) = XY v not(X) Z          *
90 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
91 ***********************************************/
92
93 #define OP(a, b, c, d, k, s, ti) \
94      a += ((b & c) | (~b & d)) + X[k] + (unsigned int)ti; \
95      a = b + ((a << s) | (a >> (32 - s)))
96
97 OP(a, b, c, d,  0,  7, 0xd76aa478);
98 OP(d, a, b, c,  1, 12, 0xe8c7b756);
99 OP(c, d, a, b,  2, 17, 0x242070db);
100 OP(b, c, d, a,  3, 22, 0xc1bdceee);
101 OP(a, b, c, d,  4,  7, 0xf57c0faf);
102 OP(d, a, b, c,  5, 12, 0x4787c62a);
103 OP(c, d, a, b,  6, 17, 0xa8304613);
104 OP(b, c, d, a,  7, 22, 0xfd469501);
105 OP(a, b, c, d,  8,  7, 0x698098d8);
106 OP(d, a, b, c,  9, 12, 0x8b44f7af);
107 OP(c, d, a, b, 10, 17, 0xffff5bb1);
108 OP(b, c, d, a, 11, 22, 0x895cd7be);
109 OP(a, b, c, d, 12,  7, 0x6b901122);
110 OP(d, a, b, c, 13, 12, 0xfd987193);
111 OP(c, d, a, b, 14, 17, 0xa679438e);
112 OP(b, c, d, a, 15, 22, 0x49b40821);
113
114 #undef OP
115
116 /***********************************************
117 *                    Round 2                   *
118 *            F(X,Y,Z) = XZ v Y not(Z)          *
119 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
120 ***********************************************/
121
122 #define OP(a, b, c, d, k, s, ti) \
123      a += ((b & d) | (c & ~d)) + X[k] + (unsigned int)ti; \
124      a = b + ((a << s) | (a >> (32 - s)))
125
126 OP(a, b, c, d,  1,  5, 0xf61e2562);
127 OP(d, a, b, c,  6,  9, 0xc040b340);
128 OP(c, d, a, b, 11, 14, 0x265e5a51);
129 OP(b, c, d, a,  0, 20, 0xe9b6c7aa);
130 OP(a, b, c, d,  5,  5, 0xd62f105d);
131 OP(d, a, b, c, 10,  9, 0x02441453);
132 OP(c, d, a, b, 15, 14, 0xd8a1e681);
133 OP(b, c, d, a,  4, 20, 0xe7d3fbc8);
134 OP(a, b, c, d,  9,  5, 0x21e1cde6);
135 OP(d, a, b, c, 14,  9, 0xc33707d6);
136 OP(c, d, a, b,  3, 14, 0xf4d50d87);
137 OP(b, c, d, a,  8, 20, 0x455a14ed);
138 OP(a, b, c, d, 13,  5, 0xa9e3e905);
139 OP(d, a, b, c,  2,  9, 0xfcefa3f8);
140 OP(c, d, a, b,  7, 14, 0x676f02d9);
141 OP(b, c, d, a, 12, 20, 0x8d2a4c8a);
142
143 #undef OP
144
145 /***********************************************
146 *                    Round 3                   *
147 *            F(X,Y,Z) = X xor Y xor Z          *
148 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
149 ***********************************************/
150
151 #define OP(a, b, c, d, k, s, ti) \
152      a += (b ^ c ^ d) + X[k] + (unsigned int)ti; \
153      a = b + ((a << s) | (a >> (32 - s)))
154
155 OP(a, b, c, d,  5,  4, 0xfffa3942);
156 OP(d, a, b, c,  8, 11, 0x8771f681);
157 OP(c, d, a, b, 11, 16, 0x6d9d6122);
158 OP(b, c, d, a, 14, 23, 0xfde5380c);
159 OP(a, b, c, d,  1,  4, 0xa4beea44);
160 OP(d, a, b, c,  4, 11, 0x4bdecfa9);
161 OP(c, d, a, b,  7, 16, 0xf6bb4b60);
162 OP(b, c, d, a, 10, 23, 0xbebfbc70);
163 OP(a, b, c, d, 13,  4, 0x289b7ec6);
164 OP(d, a, b, c,  0, 11, 0xeaa127fa);
165 OP(c, d, a, b,  3, 16, 0xd4ef3085);
166 OP(b, c, d, a,  6, 23, 0x04881d05);
167 OP(a, b, c, d,  9,  4, 0xd9d4d039);
168 OP(d, a, b, c, 12, 11, 0xe6db99e5);
169 OP(c, d, a, b, 15, 16, 0x1fa27cf8);
170 OP(b, c, d, a,  2, 23, 0xc4ac5665);
171
172 #undef OP
173
174 /***********************************************
175 *                    Round 4                   *
176 *          F(X,Y,Z) = Y xor (X v not(Z))       *
177 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
178 ***********************************************/
179
180 #define OP(a, b, c, d, k, s, ti) \
181      a += (c ^ (b | ~d)) + X[k] + (unsigned int)ti; \
182      a = b + ((a << s) | (a >> (32 - s)))
183
184 OP(a, b, c, d,  0,  6, 0xf4292244);
185 OP(d, a, b, c,  7, 10, 0x432aff97);
186 OP(c, d, a, b, 14, 15, 0xab9423a7);
187 OP(b, c, d, a,  5, 21, 0xfc93a039);
188 OP(a, b, c, d, 12,  6, 0x655b59c3);
189 OP(d, a, b, c,  3, 10, 0x8f0ccc92);
190 OP(c, d, a, b, 10, 15, 0xffeff47d);
191 OP(b, c, d, a,  1, 21, 0x85845dd1);
192 OP(a, b, c, d,  8,  6, 0x6fa87e4f);
193 OP(d, a, b, c, 15, 10, 0xfe2ce6e0);
194 OP(c, d, a, b,  6, 15, 0xa3014314);
195 OP(b, c, d, a, 13, 21, 0x4e0811a1);
196 OP(a, b, c, d,  4,  6, 0xf7537e82);
197 OP(d, a, b, c, 11, 10, 0xbd3af235);
198 OP(c, d, a, b,  2, 15, 0x2ad7d2bb);
199 OP(b, c, d, a,  9, 21, 0xeb86d391);
200
201 #undef OP
202
203 /* Add the new values back into the accumulators. */
204
205 base->abcd[0] += a;
206 base->abcd[1] += b;
207 base->abcd[2] += c;
208 base->abcd[3] += d;
209 }
210
211
212
213
214 /*************************************************
215 *     Process the final text string              *
216 *************************************************/
217
218 /* The string may be of any length. It is padded out according to the rules
219 for computing MD5 digests. The final result is then converted to text form
220 and returned.
221
222 Arguments:
223   base      pointer to the md5 storage structure
224   text      pointer to the final text vector
225   length    length of the final text vector
226   digest    points to 16 bytes in which to place the result
227
228 Returns:    nothing
229 */
230
231 void
232 md5_end(md5 *base, const uschar *text, int length, uschar *digest)
233 {
234 int i;
235 uschar work[64];
236
237 /* Process in chunks of 64 until we have less than 64 bytes left. */
238
239 while (length >= 64)
240   {
241   md5_mid(base, text);
242   text += 64;
243   length -= 64;
244   }
245
246 /* If the remaining string contains more than 55 bytes, we must pad it
247 out to 64, process it, and then set up the final chunk as 56 bytes of
248 padding. If it has less than 56 bytes, we pad it out to 56 bytes as the
249 final chunk. */
250
251 memcpy(work, text, length);
252 work[length] = 0x80;
253
254 if (length > 55)
255   {
256   memset(work+length+1, 0, 63-length);
257   md5_mid(base, work);
258   base->length -= 64;
259   memset(work, 0, 56);
260   }
261 else
262   {
263   memset(work+length+1, 0, 55-length);
264   }
265
266 /* The final 8 bytes of the final chunk are a 64-bit representation of the
267 length of the input string *bits*, before padding, low order word first, and
268 low order bytes first in each word. This implementation is designed for short
269 strings, and so operates with a single int counter only. */
270
271 length += base->length;   /* Total length in bytes */
272 length <<= 3;             /* Total length in bits */
273
274 work[56] = length         & 0xff;
275 work[57] = (length >>  8) & 0xff;
276 work[58] = (length >> 16) & 0xff;
277 work[59] = (length >> 24) & 0xff;
278
279 memset(work+60, 0, 4);
280
281 /* Process the final 64-byte chunk */
282
283 md5_mid(base, work);
284
285 /* Pass back the result, low-order byte first in each word. */
286
287 for (i = 0; i < 4; i++)
288   {
289   register int x = base->abcd[i];
290   *digest++ =  x        & 0xff;
291   *digest++ = (x >>  8) & 0xff;
292   *digest++ = (x >> 16) & 0xff;
293   *digest++ = (x >> 24) & 0xff;
294   }
295 }
296
297
298
299 /*************************************************
300 **************************************************
301 *             Stand-alone test program           *
302 **************************************************
303 *************************************************/
304
305 #if defined STAND_ALONE & !defined CRAM_STAND_ALONE
306
307 /* Test values */
308
309 static uschar *tests[] = {
310   "", "d41d8cd98f00b204e9800998ecf8427e",
311
312   "a", "0cc175b9c0f1b6a831c399e269772661",
313
314   "abc", "900150983cd24fb0d6963f7d28e17f72",
315
316   "message digest", "f96b697d7cb7938d525a2f31aaf161d0",
317
318   "abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b",
319
320   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
321      "d174ab98d277d9f5a5611c2c9f419d9f",
322
323   "1234567890123456789012345678901234567890123456789012345678901234567890"
324   "1234567890",
325     "57edf4a22be3c955ac49da2e2107b67a",
326
327   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
328   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
329   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
330     "a0842fcc02167127b0bb9a7c38e71ba8"
331 };
332
333 int main(void)
334 {
335 md5 base;
336 int i = 0x01020304;
337 uschar *ctest = US (&i);
338 uschar buffer[256];
339 uschar digest[16];
340 printf("Checking md5: %s-endian\n", (ctest[0] == 0x04)? "little" : "big");
341
342 for (i = 0; i < sizeof(tests)/sizeof(uschar *); i += 2)
343   {
344   int j;
345   uschar s[33];
346   printf("%s\nShould be: %s\n", tests[i], tests[i+1]);
347   md5_start(&base);
348   md5_end(&base, tests[i], strlen(tests[i]), digest);
349   for (j = 0; j < 16; j++) sprintf(s+2*j, "%02x", digest[j]);
350   printf("Computed:  %s\n", s);
351   if (strcmp(s, tests[i+1]) != 0) printf("*** No match ***\n");
352   printf("\n");
353   }
354 }
355 #endif
356
357 /* End of md5.c */