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