md5.c

   1 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
   2  */
   3
   4 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
   5 rights reserved.
   6
   7 License to copy and use this software is granted provided that it
   8 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
   9 Algorithm" in all material mentioning or referencing this software
  10 or this function.
  11
  12 License is also granted to make and use derivative works provided
  13 that such works are identified as "derived from the RSA Data
  14 Security, Inc. MD5 Message-Digest Algorithm" in all material
  15 mentioning or referencing the derived work.
  16
  17 RSA Data Security, Inc. makes no representations concerning either
  18 the merchantability of this software or the suitability of this
  19 software for any particular purpose. It is provided "as is"
  20 without express or implied warranty of any kind.
  21
  22 These notices must be retained in any copies of any part of this
  23 documentation and/or software.
  24  */
  25
  26 #include "md5.h"
  27
  28 /* Constants for MD5Transform routine.
  29  */
  30
  31 #define S11 7
  32 #define S12 12
  33 #define S13 17
  34 #define S14 22
  35 #define S21 5
  36 #define S22 9
  37 #define S23 14
  38 #define S24 20
  39 #define S31 4
  40 #define S32 11
  41 #define S33 16
  42 #define S34 23
  43 #define S41 6
  44 #define S42 10
  45 #define S43 15
  46 #define S44 21
  47
  48 static void MD5Transform PROTO_LIST((UINT4[4], unsigned char[64]));
  49 static void Encode PROTO_LIST((unsigned char *, UINT4 *, unsigned int));
  50 static void Decode PROTO_LIST((UINT4 *, unsigned char *, unsigned int));
  51 static void MD5_memcpy PROTO_LIST((POINTER, POINTER, unsigned int));
  52 static void MD5_memset PROTO_LIST((POINTER, int, unsigned int));
  53
  54 static unsigned char PADDING[64] = {
  55    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  56    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  57    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  58 };
  59
  60 /* F, G, H and I are basic MD5 functions.
  61  */
  62 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  63 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  64 #define H(x, y, z) ((x) ^ (y) ^ (z))
  65 #define I(x, y, z) ((y) ^ ((x) | (~z)))
  66
  67 /* ROTATE_LEFT rotates x left n bits.
  68  */
  69 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  70
  71 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
  72 Rotation is separate from addition to prevent recomputation.
  73  */
  74 #define FF(a, b, c, d, x, s, ac) { \
  75  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
  76  (a) = ROTATE_LEFT ((a), (s)); \
  77  (a) += (b); \
  78   }
  79 #define GG(a, b, c, d, x, s, ac) { \
  80  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
  81  (a) = ROTATE_LEFT ((a), (s)); \
  82  (a) += (b); \
  83   }
  84 #define HH(a, b, c, d, x, s, ac) { \
  85  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
  86  (a) = ROTATE_LEFT ((a), (s)); \
  87  (a) += (b); \
  88   }
  89 #define II(a, b, c, d, x, s, ac) { \
  90  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
  91  (a) = ROTATE_LEFT ((a), (s)); \
  92  (a) += (b); \
  93   }
  94
  95 /* MD5 initialization. Begins an MD5 operation, writing a new context.
  96  */
  97 void
  98 MD5Init(context)
  99      MD5_CTX *context;          /* context */
 100 {
 101    context->count[0] = context->count[1] = 0;
 102    /* Load magic initialization constants.
 103     */
 104    context->state[0] = 0x67452301;
 105    context->state[1] = 0xefcdab89;
 106    context->state[2] = 0x98badcfe;
 107    context->state[3] = 0x10325476;
 108 }
 109
 110 /* MD5 block update operation. Continues an MD5 message-digest
 111   operation, processing another message block, and updating the
 112   context.
 113  */
 114 void
 115 MD5Update(context, input, inputLen)
 116      MD5_CTX *context;          /* context */
 117      unsigned char *input;      /* input block */
 118      unsigned int inputLen;     /* length of input block */
 119 {
 120    unsigned int i,
 121             index,
 122             partLen;
 123
 124    /* Compute number of bytes mod 64 */
 125    index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
 126
 127    /* Update number of bits */
 128    if ((context->count[0] += ((UINT4) inputLen << 3)) < ((UINT4) inputLen << 3))
 129       context->count[1]++;
 130    context->count[1] += ((UINT4) inputLen >> 29);
 131
 132    partLen = 64 - index;
 133
 134    /* Transform as many times as possible.
 135     */
 136    if (inputLen >= partLen)
 137      {
 138         MD5_memcpy((POINTER) & context->buffer[index], (POINTER) input, partLen);
 139         MD5Transform(context->state, context->buffer);
 140
 141         for (i = partLen; i + 63 < inputLen; i += 64)
 142            MD5Transform(context->state, &input[i]);
 143
 144         index = 0;
 145      }
 146    else
 147       i = 0;
 148
 149    /* Buffer remaining input */
 150    MD5_memcpy((POINTER) & context->buffer[index], (POINTER) & input[i], inputLen - i);
 151 }
 152
 153 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 154   the message digest and zeroizing the context.
 155  */
 156 void
 157 MD5Final(digest, context)
 158      unsigned char digest[16];  /* message digest */
 159      MD5_CTX *context;          /* context */
 160 {
 161    unsigned char bits[8];
 162    unsigned int index,
 163             padLen;
 164
 165    /* Save number of bits */
 166    Encode(bits, context->count, 8);
 167
 168    /* Pad out to 56 mod 64.
 169     */
 170    index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
 171    padLen = (index < 56) ? (56 - index) : (120 - index);
 172    MD5Update(context, PADDING, padLen);
 173
 174    /* Append length (before padding) */
 175    MD5Update(context, bits, 8);
 176
 177    /* Store state in digest */
 178    Encode(digest, context->state, 16);
 179
 180    /* Zeroize sensitive information.
 181     */
 182    MD5_memset((POINTER) context, 0, sizeof(*context));
 183 }
 184
 185 /* MD5 basic transformation. Transforms state based on block.
 186  */
 187 static void
 188 MD5Transform(state, block)
 189      UINT4    state[4];
 190      unsigned char block[64];
 191 {
 192    UINT4    a = state[0],
 193             b = state[1],
 194             c = state[2],
 195             d = state[3],
 196             x[16];
 197
 198    Decode(x, block, 64);
 199
 200    /* Round 1 */
 201    FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
 202    FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
 203    FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
 204    FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
 205    FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
 206    FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
 207    FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
 208    FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
 209    FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
 210    FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
 211    FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 212    FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 213    FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 214    FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 215    FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 216    FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 217
 218    /* Round 2 */
 219    GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
 220    GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
 221    GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 222    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
 223    GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
 224    GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
 225    GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 226    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
 227    GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
 228    GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 229    GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
 230
 231    GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
 232    GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 233    GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
 234    GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
 235    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 236
 237    /* Round 3 */
 238    HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
 239    HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
 240    HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 241    HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 242    HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
 243    HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
 244    HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
 245    HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 246    HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 247    HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
 248    HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
 249    HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
 250    HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
 251    HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 252    HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 253    HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
 254
 255    /* Round 4 */
 256    II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
 257    II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
 258    II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 259    II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
 260    II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 261    II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
 262    II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 263    II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
 264    II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
 265    II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 266    II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
 267    II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 268    II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
 269    II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 270    II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
 271    II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
 272
 273    state[0] += a;
 274    state[1] += b;
 275    state[2] += c;
 276    state[3] += d;
 277
 278    /* Zeroize sensitive information.
 279
 280     */
 281    MD5_memset((POINTER) x, 0, sizeof(x));
 282 }
 283
 284 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
 285   a multiple of 4.
 286  */
 287 static void
 288 Encode(output, input, len)
 289      unsigned char *output;
 290      UINT4   *input;
 291      unsigned int len;
 292 {
 293    unsigned int i,
 294             j;
 295
 296    for (i = 0, j = 0; j < len; i++, j += 4)
 297      {
 298         output[j] = (unsigned char) (input[i] & 0xff);
 299         output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
 300         output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
 301         output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
 302      }
 303 }
 304
 305 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
 306   a multiple of 4.
 307  */
 308 static void
 309 Decode(output, input, len)
 310      UINT4   *output;
 311      unsigned char *input;
 312      unsigned int len;
 313 {
 314    unsigned int i,
 315             j;
 316
 317    for (i = 0, j = 0; j < len; i++, j += 4)
 318       output[i] = ((UINT4) input[j]) | (((UINT4) input[j + 1]) << 8) | (((UINT4) input[j + 2]) << 16) | (((UINT4) input[j + 3]) << 24);
 319 }
 320
 321 /* Note: Replace "for loop" with standard memcpy if possible.
 322  */
 323
 324 static void
 325 MD5_memcpy(output, input, len)
 326      POINTER  output;
 327      POINTER  input;
 328      unsigned int len;
 329 {
 330    unsigned int i;
 331
 332    for (i = 0; i < len; i++)
 333
 334       output[i] = input[i];
 335 }
 336
 337 /* Note: Replace "for loop" with standard memset if possible.
 338  */
 339 static void
 340 MD5_memset(output, value, len)
 341      POINTER  output;
 342      int      value;
 343      unsigned int len;
 344 {
 345    unsigned int i;
 346
 347    for (i = 0; i < len; i++)
 348       ((char *) output)[i] = (char) value;
 349 }