src/src/md5.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   6 /* Copyright (c) The Exim Maintainers 2020 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8
   9 #ifndef STAND_ALONE
  10 #include "exim.h"
  11
  12 /* For stand-alone testing, we need to have the structure defined, and
  13 to be able to do I/O */
  14
  15 #else
  16 #include <stdio.h>
  17 #include "../mytypes.h"
  18 typedef struct md5 {
  19   unsigned int length;
  20   unsigned int abcd[4];
  21   }
  22 md5;
  23 #endif
  24
  25
  26
  27 /*************************************************
  28 *        Start off a new MD5 computation.        *
  29 *************************************************/
  30
  31 /*
  32 Argument:  pointer to md5 storage structure
  33 Returns:   nothing
  34 */
  35
  36 void
  37 md5_start(md5 *base)
  38 {
  39 base->abcd[0] = 0x67452301;
  40 base->abcd[1] = 0xefcdab89;
  41 base->abcd[2] = 0x98badcfe;
  42 base->abcd[3] = 0x10325476;
  43 base->length = 0;
  44 }
  45
  46
  47
  48 /*************************************************
  49 *       Process another 64-byte block            *
  50 *************************************************/
  51
  52 /* This function implements central part of the algorithm which is described
  53 in RFC 1321.
  54
  55 Arguments:
  56   base       pointer to md5 storage structure
  57   text       pointer to next 64 bytes of subject text
  58
  59 Returns:     nothing
  60 */
  61
  62 void
  63 md5_mid(md5 *base, const uschar *text)
  64 {
  65 register unsigned int a = base->abcd[0];
  66 register unsigned int b = base->abcd[1];
  67 register unsigned int c = base->abcd[2];
  68 register unsigned int d = base->abcd[3];
  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 (int 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 uschar work[64];
 235
 236 /* Process in chunks of 64 until we have less than 64 bytes left. */
 237
 238 while (length >= 64)
 239   {
 240   md5_mid(base, text);
 241   text += 64;
 242   length -= 64;
 243   }
 244
 245 /* If the remaining string contains more than 55 bytes, we must pad it
 246 out to 64, process it, and then set up the final chunk as 56 bytes of
 247 padding. If it has less than 56 bytes, we pad it out to 56 bytes as the
 248 final chunk. */
 249
 250 memcpy(work, text, length);
 251 work[length] = 0x80;
 252
 253 if (length > 55)
 254   {
 255   memset(work+length+1, 0, 63-length);
 256   md5_mid(base, work);
 257   base->length -= 64;
 258   memset(work, 0, 56);
 259   }
 260 else
 261   {
 262   memset(work+length+1, 0, 55-length);
 263   }
 264
 265 /* The final 8 bytes of the final chunk are a 64-bit representation of the
 266 length of the input string *bits*, before padding, low order word first, and
 267 low order bytes first in each word. This implementation is designed for short
 268 strings, and so operates with a single int counter only. */
 269
 270 length += base->length;   /* Total length in bytes */
 271 length <<= 3;             /* Total length in bits */
 272
 273 work[56] = length         & 0xff;
 274 work[57] = (length >>  8) & 0xff;
 275 work[58] = (length >> 16) & 0xff;
 276 work[59] = (length >> 24) & 0xff;
 277
 278 memset(work+60, 0, 4);
 279
 280 /* Process the final 64-byte chunk */
 281
 282 md5_mid(base, work);
 283
 284 /* Pass back the result, low-order byte first in each word. */
 285
 286 for (int i = 0; i < 4; i++)
 287   {
 288   register int x = base->abcd[i];
 289   *digest++ =  x        & 0xff;
 290   *digest++ = (x >>  8) & 0xff;
 291   *digest++ = (x >> 16) & 0xff;
 292   *digest++ = (x >> 24) & 0xff;
 293   }
 294 }
 295
 296
 297
 298 /*************************************************
 299 **************************************************
 300 *             Stand-alone test program           *
 301 **************************************************
 302 *************************************************/
 303
 304 #if defined STAND_ALONE & !defined CRAM_STAND_ALONE
 305
 306 /* Test values */
 307
 308 static uschar *tests[] = {
 309   "", "d41d8cd98f00b204e9800998ecf8427e",
 310
 311   "a", "0cc175b9c0f1b6a831c399e269772661",
 312
 313   "abc", "900150983cd24fb0d6963f7d28e17f72",
 314
 315   "message digest", "f96b697d7cb7938d525a2f31aaf161d0",
 316
 317   "abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b",
 318
 319   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 320      "d174ab98d277d9f5a5611c2c9f419d9f",
 321
 322   "1234567890123456789012345678901234567890123456789012345678901234567890"
 323   "1234567890",
 324     "57edf4a22be3c955ac49da2e2107b67a",
 325
 326   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
 327   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
 328   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
 329     "a0842fcc02167127b0bb9a7c38e71ba8"
 330 };
 331
 332 int main(void)
 333 {
 334 md5 base;
 335 int i = 0x01020304;
 336 uschar *ctest = US (&i);
 337 uschar buffer[256];
 338 uschar digest[16];
 339 printf("Checking md5: %s-endian\n", (ctest[0] == 0x04)? "little" : "big");
 340
 341 for (i = 0; i < sizeof(tests)/sizeof(uschar *); i += 2)
 342   {
 343   uschar s[33];
 344   printf("%s\nShould be: %s\n", tests[i], tests[i+1]);
 345   md5_start(&base);
 346   md5_end(&base, tests[i], strlen(tests[i]), digest);
 347   for (int j = 0; j < 16; j++) sprintf(s+2*j, "%02x", digest[j]);
 348   printf("Computed:  %s\n", s);
 349   if (strcmp(s, tests[i+1]) != 0) printf("*** No match ***\n");
 350   printf("\n");
 351   }
 352 }
 353 #endif
 354
 355 /* End of md5.c */