lib/md5.c

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