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