1/***************************************************************************
2 *                                  _   _ ____  _
3 *  Project                     ___| | | |  _ \| |
4 *                             / __| | | | |_) | |
5 *                            | (__| |_| |  _ <| |___
6 *                             \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2016, 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 https://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/curl.h>
28
29#include "curl_md5.h"
30#include "curl_hmac.h"
31#include "warnless.h"
32
33#if defined(USE_GNUTLS_NETTLE)
34
35#include <nettle/md5.h>
36#include "curl_memory.h"
37/* The last #include file should be: */
38#include "memdebug.h"
39
40typedef struct md5_ctx MD5_CTX;
41
42static void MD5_Init(MD5_CTX * ctx)
43{
44  md5_init(ctx);
45}
46
47static void MD5_Update(MD5_CTX * ctx,
48                       const unsigned char *input,
49                       unsigned int inputLen)
50{
51  md5_update(ctx, inputLen, input);
52}
53
54static void MD5_Final(unsigned char digest[16], MD5_CTX * ctx)
55{
56  md5_digest(ctx, 16, digest);
57}
58
59#elif defined(USE_GNUTLS)
60
61#include <gcrypt.h>
62#include "curl_memory.h"
63/* The last #include file should be: */
64#include "memdebug.h"
65
66typedef gcry_md_hd_t MD5_CTX;
67
68static void MD5_Init(MD5_CTX * ctx)
69{
70  gcry_md_open(ctx, GCRY_MD_MD5, 0);
71}
72
73static void MD5_Update(MD5_CTX * ctx,
74                       const unsigned char *input,
75                       unsigned int inputLen)
76{
77  gcry_md_write(*ctx, input, inputLen);
78}
79
80static void MD5_Final(unsigned char digest[16], MD5_CTX * ctx)
81{
82  memcpy(digest, gcry_md_read(*ctx, 0), 16);
83  gcry_md_close(*ctx);
84}
85
86#elif defined(USE_OPENSSL)
87/* When OpenSSL is available we use the MD5-function from OpenSSL */
88#include <openssl/md5.h>
89#include "curl_memory.h"
90/* The last #include file should be: */
91#include "memdebug.h"
92
93#elif (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \
94              (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1040)) || \
95      (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
96              (__IPHONE_OS_VERSION_MAX_ALLOWED >= 20000))
97
98/* For Apple operating systems: CommonCrypto has the functions we need.
99   These functions are available on Tiger and later, as well as iOS 2.0
100   and later. If you're building for an older cat, well, sorry.
101
102   Declaring the functions as static like this seems to be a bit more
103   reliable than defining COMMON_DIGEST_FOR_OPENSSL on older cats. */
104#  include <CommonCrypto/CommonDigest.h>
105#  define MD5_CTX CC_MD5_CTX
106#include "curl_memory.h"
107/* The last #include file should be: */
108#include "memdebug.h"
109
110static void MD5_Init(MD5_CTX *ctx)
111{
112  CC_MD5_Init(ctx);
113}
114
115static void MD5_Update(MD5_CTX *ctx,
116                       const unsigned char *input,
117                       unsigned int inputLen)
118{
119  CC_MD5_Update(ctx, input, inputLen);
120}
121
122static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
123{
124  CC_MD5_Final(digest, ctx);
125}
126
127#elif defined(_WIN32) && !defined(CURL_WINDOWS_APP)
128
129#include <wincrypt.h>
130#include "curl_memory.h"
131/* The last #include file should be: */
132#include "memdebug.h"
133
134typedef struct {
135  HCRYPTPROV hCryptProv;
136  HCRYPTHASH hHash;
137} MD5_CTX;
138
139static void MD5_Init(MD5_CTX *ctx)
140{
141  if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
142                         PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
143    CryptCreateHash(ctx->hCryptProv, CALG_MD5, 0, 0, &ctx->hHash);
144  }
145}
146
147static void MD5_Update(MD5_CTX *ctx,
148                       const unsigned char *input,
149                       unsigned int inputLen)
150{
151  CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
152}
153
154static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
155{
156  unsigned long length = 0;
157  CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0);
158  if(length == 16)
159    CryptGetHashParam(ctx->hHash, HP_HASHVAL, digest, &length, 0);
160  if(ctx->hHash)
161    CryptDestroyHash(ctx->hHash);
162  if(ctx->hCryptProv)
163    CryptReleaseContext(ctx->hCryptProv, 0);
164}
165
166#elif defined(USE_AXTLS)
167#include <axTLS/config.h>
168#include <axTLS/os_int.h>
169#include <axTLS/crypto.h>
170#include "curl_memory.h"
171/* The last #include file should be: */
172#include "memdebug.h"
173#else
174/* When no other crypto library is available we use this code segment */
175/*
176 * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
177 * MD5 Message-Digest Algorithm (RFC 1321).
178 *
179 * Homepage:
180 http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
181 *
182 * Author:
183 * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
184 *
185 * This software was written by Alexander Peslyak in 2001.  No copyright is
186 * claimed, and the software is hereby placed in the public domain.
187 * In case this attempt to disclaim copyright and place the software in the
188 * public domain is deemed null and void, then the software is
189 * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
190 * general public under the following terms:
191 *
192 * Redistribution and use in source and binary forms, with or without
193 * modification, are permitted.
194 *
195 * There's ABSOLUTELY NO WARRANTY, express or implied.
196 *
197 * (This is a heavily cut-down "BSD license".)
198 *
199 * This differs from Colin Plumb's older public domain implementation in that
200 * no exactly 32-bit integer data type is required (any 32-bit or wider
201 * unsigned integer data type will do), there's no compile-time endianness
202 * configuration, and the function prototypes match OpenSSL's.  No code from
203 * Colin Plumb's implementation has been reused; this comment merely compares
204 * the properties of the two independent implementations.
205 *
206 * The primary goals of this implementation are portability and ease of use.
207 * It is meant to be fast, but not as fast as possible.  Some known
208 * optimizations are not included to reduce source code size and avoid
209 * compile-time configuration.
210 */
211
212#include <string.h>
213
214/* The last #include files should be: */
215#include "curl_memory.h"
216#include "memdebug.h"
217
218/* Any 32-bit or wider unsigned integer data type will do */
219typedef unsigned int MD5_u32plus;
220
221typedef struct {
222  MD5_u32plus lo, hi;
223  MD5_u32plus a, b, c, d;
224  unsigned char buffer[64];
225  MD5_u32plus block[16];
226} MD5_CTX;
227
228static void MD5_Init(MD5_CTX *ctx);
229static void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size);
230static void MD5_Final(unsigned char *result, MD5_CTX *ctx);
231
232/*
233 * The basic MD5 functions.
234 *
235 * F and G are optimized compared to their RFC 1321 definitions for
236 * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
237 * implementation.
238 */
239#define F(x, y, z)                      ((z) ^ ((x) & ((y) ^ (z))))
240#define G(x, y, z)                      ((y) ^ ((z) & ((x) ^ (y))))
241#define H(x, y, z)                      (((x) ^ (y)) ^ (z))
242#define H2(x, y, z)                     ((x) ^ ((y) ^ (z)))
243#define I(x, y, z)                      ((y) ^ ((x) | ~(z)))
244
245/*
246 * The MD5 transformation for all four rounds.
247 */
248#define STEP(f, a, b, c, d, x, t, s) \
249        (a) += f((b), (c), (d)) + (x) + (t); \
250        (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
251        (a) += (b);
252
253/*
254 * SET reads 4 input bytes in little-endian byte order and stores them
255 * in a properly aligned word in host byte order.
256 *
257 * The check for little-endian architectures that tolerate unaligned
258 * memory accesses is just an optimization.  Nothing will break if it
259 * doesn't work.
260 */
261#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
262#define SET(n) \
263        (*(MD5_u32plus *)(void *)&ptr[(n) * 4])
264#define GET(n) \
265        SET(n)
266#else
267#define SET(n) \
268        (ctx->block[(n)] = \
269        (MD5_u32plus)ptr[(n) * 4] | \
270        ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
271        ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
272        ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
273#define GET(n) \
274        (ctx->block[(n)])
275#endif
276
277/*
278 * This processes one or more 64-byte data blocks, but does NOT update
279 * the bit counters.  There are no alignment requirements.
280 */
281static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
282{
283  const unsigned char *ptr;
284  MD5_u32plus a, b, c, d;
285  MD5_u32plus saved_a, saved_b, saved_c, saved_d;
286
287  ptr = (const unsigned char *)data;
288
289  a = ctx->a;
290  b = ctx->b;
291  c = ctx->c;
292  d = ctx->d;
293
294  do {
295    saved_a = a;
296    saved_b = b;
297    saved_c = c;
298    saved_d = d;
299
300/* Round 1 */
301    STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
302      STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
303      STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
304      STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
305      STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
306      STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
307      STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
308      STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
309      STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
310      STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
311      STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
312      STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
313      STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
314      STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
315      STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
316      STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
317
318/* Round 2 */
319      STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
320      STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
321      STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
322      STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
323      STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
324      STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
325      STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
326      STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
327      STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
328      STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
329      STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
330      STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
331      STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
332      STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
333      STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
334      STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
335
336/* Round 3 */
337      STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
338      STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
339      STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
340      STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
341      STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
342      STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
343      STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
344      STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
345      STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
346      STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
347      STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
348      STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
349      STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
350      STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
351      STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
352      STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
353
354/* Round 4 */
355      STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
356      STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
357      STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
358      STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
359      STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
360      STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
361      STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
362      STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
363      STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
364      STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
365      STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
366      STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
367      STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
368      STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
369      STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
370      STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
371
372      a += saved_a;
373    b += saved_b;
374    c += saved_c;
375    d += saved_d;
376
377    ptr += 64;
378  } while(size -= 64);
379
380  ctx->a = a;
381  ctx->b = b;
382  ctx->c = c;
383  ctx->d = d;
384
385  return ptr;
386}
387
388static void MD5_Init(MD5_CTX *ctx)
389{
390  ctx->a = 0x67452301;
391  ctx->b = 0xefcdab89;
392  ctx->c = 0x98badcfe;
393  ctx->d = 0x10325476;
394
395  ctx->lo = 0;
396  ctx->hi = 0;
397}
398
399static void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
400{
401  MD5_u32plus saved_lo;
402  unsigned long used, available;
403
404  saved_lo = ctx->lo;
405  ctx->lo = (saved_lo + size) & 0x1fffffff;
406  if(ctx->lo < saved_lo)
407    ctx->hi++;
408  ctx->hi += (MD5_u32plus)size >> 29;
409
410  used = saved_lo & 0x3f;
411
412  if(used) {
413    available = 64 - used;
414
415    if(size < available) {
416      memcpy(&ctx->buffer[used], data, size);
417      return;
418    }
419
420    memcpy(&ctx->buffer[used], data, available);
421    data = (const unsigned char *)data + available;
422    size -= available;
423    body(ctx, ctx->buffer, 64);
424  }
425
426  if(size >= 64) {
427    data = body(ctx, data, size & ~(unsigned long)0x3f);
428    size &= 0x3f;
429  }
430
431  memcpy(ctx->buffer, data, size);
432}
433
434static void MD5_Final(unsigned char *result, MD5_CTX *ctx)
435{
436  unsigned long used, available;
437
438  used = ctx->lo & 0x3f;
439
440  ctx->buffer[used++] = 0x80;
441
442  available = 64 - used;
443
444  if(available < 8) {
445    memset(&ctx->buffer[used], 0, available);
446    body(ctx, ctx->buffer, 64);
447    used = 0;
448    available = 64;
449  }
450
451  memset(&ctx->buffer[used], 0, available - 8);
452
453  ctx->lo <<= 3;
454  ctx->buffer[56] = curlx_ultouc((ctx->lo)&0xff);
455  ctx->buffer[57] = curlx_ultouc((ctx->lo >> 8)&0xff);
456  ctx->buffer[58] = curlx_ultouc((ctx->lo >> 16)&0xff);
457  ctx->buffer[59] = curlx_ultouc(ctx->lo >> 24);
458  ctx->buffer[60] = curlx_ultouc((ctx->hi)&0xff);
459  ctx->buffer[61] = curlx_ultouc((ctx->hi >> 8)&0xff);
460  ctx->buffer[62] = curlx_ultouc((ctx->hi >> 16)&0xff);
461  ctx->buffer[63] = curlx_ultouc(ctx->hi >> 24);
462
463  body(ctx, ctx->buffer, 64);
464
465  result[0] = curlx_ultouc((ctx->a)&0xff);
466  result[1] = curlx_ultouc((ctx->a >> 8)&0xff);
467  result[2] = curlx_ultouc((ctx->a >> 16)&0xff);
468  result[3] = curlx_ultouc(ctx->a >> 24);
469  result[4] = curlx_ultouc((ctx->b)&0xff);
470  result[5] = curlx_ultouc((ctx->b >> 8)&0xff);
471  result[6] = curlx_ultouc((ctx->b >> 16)&0xff);
472  result[7] = curlx_ultouc(ctx->b >> 24);
473  result[8] = curlx_ultouc((ctx->c)&0xff);
474  result[9] = curlx_ultouc((ctx->c >> 8)&0xff);
475  result[10] = curlx_ultouc((ctx->c >> 16)&0xff);
476  result[11] = curlx_ultouc(ctx->c >> 24);
477  result[12] = curlx_ultouc((ctx->d)&0xff);
478  result[13] = curlx_ultouc((ctx->d >> 8)&0xff);
479  result[14] = curlx_ultouc((ctx->d >> 16)&0xff);
480  result[15] = curlx_ultouc(ctx->d >> 24);
481
482  memset(ctx, 0, sizeof(*ctx));
483}
484
485#endif /* CRYPTO LIBS */
486
487const HMAC_params Curl_HMAC_MD5[] = {
488  {
489    (HMAC_hinit_func) MD5_Init,           /* Hash initialization function. */
490    (HMAC_hupdate_func) MD5_Update,       /* Hash update function. */
491    (HMAC_hfinal_func) MD5_Final,         /* Hash computation end function. */
492    sizeof(MD5_CTX),                      /* Size of hash context structure. */
493    64,                                   /* Maximum key length. */
494    16                                    /* Result size. */
495  }
496};
497
498const MD5_params Curl_DIGEST_MD5[] = {
499  {
500    (Curl_MD5_init_func) MD5_Init,      /* Digest initialization function */
501    (Curl_MD5_update_func) MD5_Update,  /* Digest update function */
502    (Curl_MD5_final_func) MD5_Final,    /* Digest computation end function */
503    sizeof(MD5_CTX),                    /* Size of digest context struct */
504    16                                  /* Result size */
505  }
506};
507
508/*
509 * @unittest: 1601
510 */
511void Curl_md5it(unsigned char *outbuffer, /* 16 bytes */
512                const unsigned char *input)
513{
514  MD5_CTX ctx;
515  MD5_Init(&ctx);
516  MD5_Update(&ctx, input, curlx_uztoui(strlen((char *)input)));
517  MD5_Final(outbuffer, &ctx);
518}
519
520MD5_context *Curl_MD5_init(const MD5_params *md5params)
521{
522  MD5_context *ctxt;
523
524  /* Create MD5 context */
525  ctxt = malloc(sizeof *ctxt);
526
527  if(!ctxt)
528    return ctxt;
529
530  ctxt->md5_hashctx = malloc(md5params->md5_ctxtsize);
531
532  if(!ctxt->md5_hashctx) {
533    free(ctxt);
534    return NULL;
535  }
536
537  ctxt->md5_hash = md5params;
538
539  (*md5params->md5_init_func)(ctxt->md5_hashctx);
540
541  return ctxt;
542}
543
544int Curl_MD5_update(MD5_context *context,
545                    const unsigned char *data,
546                    unsigned int len)
547{
548  (*context->md5_hash->md5_update_func)(context->md5_hashctx, data, len);
549
550  return 0;
551}
552
553int Curl_MD5_final(MD5_context *context, unsigned char *result)
554{
555  (*context->md5_hash->md5_final_func)(result, context->md5_hashctx);
556
557  free(context->md5_hashctx);
558  free(context);
559
560  return 0;
561}
562
563#endif /* CURL_DISABLE_CRYPTO_AUTH */
564