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