lib/md5.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2012, 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  ***************************************************************************/
  22
  23 #include "curl_setup.h"
  24
  25 #ifndef CURL_DISABLE_CRYPTO_AUTH
  26
  27 #include "curl_md5.h"
  28 #include "curl_hmac.h"
  29 #include "curl_warnless.h"
  30
  31 #include "curl_memory.h"
  32
  33 #if defined(USE_GNUTLS_NETTLE)
  34
  35 #include <nettle/md5.h>
  36 /* The last #include file should be: */
  37 #include "curl_memdebug.h"
  38
  39 typedef struct md5_ctx MD5_CTX;
  40
  41 static void MD5_Init(MD5_CTX * ctx)
  42 {
  43   md5_init(ctx);
  44 }
  45
  46 static void MD5_Update(MD5_CTX * ctx,
  47                        const unsigned char * input,
  48                        unsigned int inputLen)
  49 {
  50   md5_update(ctx, inputLen, input);
  51 }
  52
  53 static void MD5_Final(unsigned char digest[16], MD5_CTX * ctx)
  54 {
  55   md5_digest(ctx, 16, digest);
  56 }
  57
  58 #elif defined(USE_GNUTLS)
  59
  60 #include <gcrypt.h>
  61 /* The last #include file should be: */
  62 #include "curl_memdebug.h"
  63
  64 typedef gcry_md_hd_t MD5_CTX;
  65
  66 static void MD5_Init(MD5_CTX * ctx)
  67 {
  68   gcry_md_open(ctx, GCRY_MD_MD5, 0);
  69 }
  70
  71 static void MD5_Update(MD5_CTX * ctx,
  72                        const unsigned char * input,
  73                        unsigned int inputLen)
  74 {
  75   gcry_md_write(*ctx, input, inputLen);
  76 }
  77
  78 static void MD5_Final(unsigned char digest[16], MD5_CTX * ctx)
  79 {
  80   memcpy(digest, gcry_md_read(*ctx, 0), 16);
  81   gcry_md_close(*ctx);
  82 }
  83
  84 #elif defined(USE_SSLEAY)
  85 /* When OpenSSL is available we use the MD5-function from OpenSSL */
  86
  87 #  ifdef USE_OPENSSL
  88 #    include <openssl/md5.h>
  89 #  else
  90 #    include <md5.h>
  91 #  endif
  92
  93 #elif defined(__MAC_10_4) || defined(__IPHONE_5_0)
  94
  95 /* For Apple operating systems: CommonCrypto has the functions we need.
  96    The library's headers are even backward-compatible with OpenSSL's
  97    headers as long as we define COMMON_DIGEST_FOR_OPENSSL first.
  98
  99    These functions are available on Tiger and later, as well as iOS 5.0
 100    and later. If you're building for an older cat, well, sorry. */
 101 #  define COMMON_DIGEST_FOR_OPENSSL
 102 #  include <CommonCrypto/CommonDigest.h>
 103
 104 #elif defined(_WIN32)
 105
 106 #include <wincrypt.h>
 107
 108 typedef struct {
 109   HCRYPTPROV hCryptProv;
 110   HCRYPTHASH hHash;
 111 } MD5_CTX;
 112
 113 static void MD5_Init(MD5_CTX *ctx)
 114 {
 115   if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
 116                          PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
 117     CryptCreateHash(ctx->hCryptProv, CALG_MD5, 0, 0, &ctx->hHash);
 118   }
 119 }
 120
 121 static void MD5_Update(MD5_CTX *ctx,
 122                        const unsigned char *input,
 123                        unsigned int inputLen)
 124 {
 125   CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
 126 }
 127
 128 static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
 129 {
 130   unsigned long length;
 131   CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0);
 132   if(length == 16)
 133     CryptGetHashParam(ctx->hHash, HP_HASHVAL, digest, &length, 0);
 134   if(ctx->hHash)
 135     CryptDestroyHash(ctx->hHash);
 136   if(ctx->hCryptProv)
 137     CryptReleaseContext(ctx->hCryptProv, 0);
 138 }
 139
 140 #else
 141 /* When no other crypto library is available we use this code segment */
 142
 143 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
 144 rights reserved.
 145
 146 License to copy and use this software is granted provided that it
 147 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
 148 Algorithm" in all material mentioning or referencing this software
 149 or this function.
 150
 151 License is also granted to make and use derivative works provided
 152 that such works are identified as "derived from the RSA Data
 153 Security, Inc. MD5 Message-Digest Algorithm" in all material
 154 mentioning or referencing the derived work.
 155
 156 RSA Data Security, Inc. makes no representations concerning either
 157 the merchantability of this software or the suitability of this
 158 software for any particular purpose. It is provided "as is"
 159 without express or implied warranty of any kind.
 160
 161 These notices must be retained in any copies of any part of this
 162 documentation and/or software.
 163  */
 164
 165 /* UINT4 defines a four byte word */
 166 typedef unsigned int UINT4;
 167
 168 /* MD5 context. */
 169 struct md5_ctx {
 170   UINT4 state[4];                                   /* state (ABCD) */
 171   UINT4 count[2];        /* number of bits, modulo 2^64 (lsb first) */
 172   unsigned char buffer[64];                         /* input buffer */
 173 };
 174
 175 typedef struct md5_ctx MD5_CTX;
 176
 177 static void MD5_Init(struct md5_ctx *);
 178 static void MD5_Update(struct md5_ctx *, const unsigned char *, unsigned int);
 179 static void MD5_Final(unsigned char [16], struct md5_ctx *);
 180
 181 /* Constants for MD5Transform routine.
 182  */
 183
 184 #define S11 7
 185 #define S12 12
 186 #define S13 17
 187 #define S14 22
 188 #define S21 5
 189 #define S22 9
 190 #define S23 14
 191 #define S24 20
 192 #define S31 4
 193 #define S32 11
 194 #define S33 16
 195 #define S34 23
 196 #define S41 6
 197 #define S42 10
 198 #define S43 15
 199 #define S44 21
 200
 201 static void MD5Transform(UINT4 [4], const unsigned char [64]);
 202 static void Encode(unsigned char *, UINT4 *, unsigned int);
 203 static void Decode(UINT4 *, const unsigned char *, unsigned int);
 204
 205 static const unsigned char PADDING[64] = {
 206   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 207   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 208   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 209 };
 210
 211 /* F, G, H and I are basic MD5 functions.
 212  */
 213 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
 214 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
 215 #define H(x, y, z) ((x) ^ (y) ^ (z))
 216 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 217
 218 /* ROTATE_LEFT rotates x left n bits.
 219  */
 220 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 221
 222 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
 223 Rotation is separate from addition to prevent recomputation.
 224  */
 225 #define FF(a, b, c, d, x, s, ac) { \
 226  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 227  (a) = ROTATE_LEFT ((a), (s)); \
 228  (a) += (b); \
 229   }
 230 #define GG(a, b, c, d, x, s, ac) { \
 231  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 232  (a) = ROTATE_LEFT ((a), (s)); \
 233  (a) += (b); \
 234   }
 235 #define HH(a, b, c, d, x, s, ac) { \
 236  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 237  (a) = ROTATE_LEFT ((a), (s)); \
 238  (a) += (b); \
 239   }
 240 #define II(a, b, c, d, x, s, ac) { \
 241  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 242  (a) = ROTATE_LEFT ((a), (s)); \
 243  (a) += (b); \
 244   }
 245
 246 /* MD5 initialization. Begins an MD5 operation, writing a new context.
 247  */
 248 static void MD5_Init(struct md5_ctx *context)
 249 {
 250   context->count[0] = context->count[1] = 0;
 251   /* Load magic initialization constants. */
 252   context->state[0] = 0x67452301;
 253   context->state[1] = 0xefcdab89;
 254   context->state[2] = 0x98badcfe;
 255   context->state[3] = 0x10325476;
 256 }
 257
 258 /* MD5 block update operation. Continues an MD5 message-digest
 259   operation, processing another message block, and updating the
 260   context.
 261  */
 262 static void MD5_Update (struct md5_ctx *context,    /* context */
 263                         const unsigned char *input, /* input block */
 264                         unsigned int inputLen)      /* length of input block */
 265 {
 266   unsigned int i, bufindex, partLen;
 267
 268   /* Compute number of bytes mod 64 */
 269   bufindex = (unsigned int)((context->count[0] >> 3) & 0x3F);
 270
 271   /* Update number of bits */
 272   if((context->count[0] += ((UINT4)inputLen << 3))
 273       < ((UINT4)inputLen << 3))
 274     context->count[1]++;
 275   context->count[1] += ((UINT4)inputLen >> 29);
 276
 277   partLen = 64 - bufindex;
 278
 279   /* Transform as many times as possible. */
 280   if(inputLen >= partLen) {
 281     memcpy(&context->buffer[bufindex], input, partLen);
 282     MD5Transform(context->state, context->buffer);
 283
 284     for(i = partLen; i + 63 < inputLen; i += 64)
 285       MD5Transform(context->state, &input[i]);
 286
 287     bufindex = 0;
 288   }
 289   else
 290     i = 0;
 291
 292   /* Buffer remaining input */
 293   memcpy(&context->buffer[bufindex], &input[i], inputLen-i);
 294 }
 295
 296 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 297    the message digest and zeroizing the context.
 298 */
 299 static void MD5_Final(unsigned char digest[16], /* message digest */
 300                       struct md5_ctx *context) /* context */
 301 {
 302   unsigned char bits[8];
 303   unsigned int count, padLen;
 304
 305   /* Save number of bits */
 306   Encode (bits, context->count, 8);
 307
 308   /* Pad out to 56 mod 64. */
 309   count = (unsigned int)((context->count[0] >> 3) & 0x3f);
 310   padLen = (count < 56) ? (56 - count) : (120 - count);
 311   MD5_Update (context, PADDING, padLen);
 312
 313   /* Append length (before padding) */
 314   MD5_Update (context, bits, 8);
 315
 316   /* Store state in digest */
 317   Encode (digest, context->state, 16);
 318
 319   /* Zeroize sensitive information. */
 320   memset ((void *)context, 0, sizeof (*context));
 321 }
 322
 323 /* MD5 basic transformation. Transforms state based on block. */
 324 static void MD5Transform(UINT4 state[4],
 325                          const unsigned char block[64])
 326 {
 327   UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 328
 329   Decode (x, block, 64);
 330
 331   /* Round 1 */
 332   FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 333   FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 334   FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 335   FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 336   FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 337   FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 338   FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 339   FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 340   FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 341   FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 342   FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 343   FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 344   FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 345   FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 346   FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 347   FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 348
 349  /* Round 2 */
 350   GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 351   GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 352   GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 353   GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 354   GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 355   GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 356   GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 357   GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 358   GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 359   GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 360   GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 361   GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 362   GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 363   GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 364   GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 365   GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 366
 367   /* Round 3 */
 368   HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 369   HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 370   HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 371   HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 372   HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 373   HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 374   HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 375   HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 376   HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 377   HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 378   HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 379   HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 380   HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 381   HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 382   HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 383   HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 384
 385   /* Round 4 */
 386   II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 387   II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 388   II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 389   II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 390   II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 391   II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 392   II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 393   II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 394   II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 395   II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 396   II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 397   II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 398   II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 399   II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 400   II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 401   II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 402
 403   state[0] += a;
 404   state[1] += b;
 405   state[2] += c;
 406   state[3] += d;
 407
 408   /* Zeroize sensitive information. */
 409   memset((void *)x, 0, sizeof (x));
 410 }
 411
 412 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
 413   a multiple of 4.
 414  */
 415 static void Encode (unsigned char *output,
 416                     UINT4 *input,
 417                     unsigned int len)
 418 {
 419   unsigned int i, j;
 420
 421   for(i = 0, j = 0; j < len; i++, j += 4) {
 422     output[j] = (unsigned char)(input[i] & 0xff);
 423     output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 424     output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 425     output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 426   }
 427 }
 428
 429 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
 430    a multiple of 4.
 431 */
 432 static void Decode (UINT4 *output,
 433                     const unsigned char *input,
 434                     unsigned int len)
 435 {
 436   unsigned int i, j;
 437
 438   for(i = 0, j = 0; j < len; i++, j += 4)
 439     output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 440       (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 441 }
 442
 443 #endif /* CRYPTO LIBS */
 444
 445 /* The last #include file should be: */
 446 #include "curl_memdebug.h"
 447
 448 const HMAC_params Curl_HMAC_MD5[] = {
 449   {
 450     (HMAC_hinit_func) MD5_Init,           /* Hash initialization function. */
 451     (HMAC_hupdate_func) MD5_Update,       /* Hash update function. */
 452     (HMAC_hfinal_func) MD5_Final,         /* Hash computation end function. */
 453     sizeof(MD5_CTX),                      /* Size of hash context structure. */
 454     64,                                   /* Maximum key length. */
 455     16                                    /* Result size. */
 456   }
 457 };
 458
 459 const MD5_params Curl_DIGEST_MD5[] = {
 460   {
 461     (Curl_MD5_init_func) MD5_Init,      /* Digest initialization function */
 462     (Curl_MD5_update_func) MD5_Update,  /* Digest update function */
 463     (Curl_MD5_final_func) MD5_Final,    /* Digest computation end function */
 464     sizeof(MD5_CTX),                    /* Size of digest context struct */
 465     16                                  /* Result size */
 466   }
 467 };
 468
 469 void Curl_md5it(unsigned char *outbuffer, /* 16 bytes */
 470                 const unsigned char *input)
 471 {
 472   MD5_CTX ctx;
 473   MD5_Init(&ctx);
 474   MD5_Update(&ctx, input, curlx_uztoui(strlen((char *)input)));
 475   MD5_Final(outbuffer, &ctx);
 476 }
 477
 478 MD5_context *Curl_MD5_init(const MD5_params *md5params)
 479 {
 480   MD5_context *ctxt;
 481
 482   /* Create MD5 context */
 483   ctxt = malloc(sizeof *ctxt);
 484
 485   if(!ctxt)
 486     return ctxt;
 487
 488   ctxt->md5_hashctx = malloc(md5params->md5_ctxtsize);
 489
 490   if(!ctxt->md5_hashctx) {
 491     free(ctxt);
 492     return NULL;
 493   }
 494
 495   ctxt->md5_hash = md5params;
 496
 497   (*md5params->md5_init_func)(ctxt->md5_hashctx);
 498
 499   return ctxt;
 500 }
 501
 502 int Curl_MD5_update(MD5_context *context,
 503                     const unsigned char *data,
 504                     unsigned int len)
 505 {
 506   (*context->md5_hash->md5_update_func)(context->md5_hashctx, data, len);
 507
 508   return 0;
 509 }
 510
 511 int Curl_MD5_final(MD5_context *context, unsigned char *result)
 512 {
 513   (*context->md5_hash->md5_final_func)(result, context->md5_hashctx);
 514
 515   free(context->md5_hashctx);
 516   free(context);
 517
 518   return 0;
 519 }
 520
 521 #endif /* CURL_DISABLE_CRYPTO_AUTH */