md5.c

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