MD5.c 16.4 KB
Newer Older
1 2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
3 4 5 6 7 8
#include "kwsysPrivate.h"
#include KWSYS_HEADER(MD5.h)

/* Work-around CMake dependency scanning limitation.  This must
   duplicate the above list of headers.  */
#if 0
9
#include "MD5.h.in"
10 11
#endif

12 13 14
#include <stddef.h> /* size_t */
#include <stdlib.h> /* malloc, free */
#include <string.h> /* memcpy, strlen */
15 16 17 18 19 20 21 22

/*--------------------------------------------------------------------------*/

/* This MD5 implementation has been taken from a third party.  Slight
   modifications to the arrangement of the code have been made to put
   it in a single source file instead of a separate header and
   implementation file.  */

23
#if defined(__clang__) && !defined(__INTEL_COMPILER)
24 25
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wcast-align"
26 27
#endif

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
/*
  Copyright (C) 1999, 2000, 2002 Aladdin Enterprises.  All rights reserved.

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

  L. Peter Deutsch
  ghost@aladdin.com

 */
/*
  Independent implementation of MD5 (RFC 1321).

  This code implements the MD5 Algorithm defined in RFC 1321, whose
  text is available at
        http://www.ietf.org/rfc/rfc1321.txt
  The code is derived from the text of the RFC, including the test suite
  (section A.5) but excluding the rest of Appendix A.  It does not include
  any code or documentation that is identified in the RFC as being
  copyrighted.

  The original and principal author of md5.c is L. Peter Deutsch
  <ghost@aladdin.com>.  Other authors are noted in the change history
  that follows (in reverse chronological order):

  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
        either statically or dynamically; added missing #include <string.h>
        in library.
  2002-03-11 lpd Corrected argument list for main(), and added int return
        type, in test program and T value program.
  2002-02-21 lpd Added missing #include <stdio.h> in test program.
  2000-07-03 lpd Patched to eliminate warnings about "constant is
        unsigned in ANSI C, signed in traditional"; made test program
        self-checking.
  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
  1999-05-03 lpd Original version.
 */

/*
 * This package supports both compile-time and run-time determination of CPU
 * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
 * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
 * defined as non-zero, the code will be compiled to run only on big-endian
 * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
 * run on either big- or little-endian CPUs, but will run slightly less
 * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
 */

typedef unsigned char md5_byte_t; /* 8-bit byte */
91
typedef unsigned int md5_word_t;  /* 32-bit word */
92 93

/* Define the state of the MD5 Algorithm. */
94 95 96 97 98
typedef struct md5_state_s
{
  md5_word_t count[2]; /* message length in bits, lsw first */
  md5_word_t abcd[4];  /* digest buffer */
  md5_byte_t buf[64];  /* accumulate block */
99 100
} md5_state_t;

101
#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
102
#ifdef ARCH_IS_BIG_ENDIAN
103
#define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
104
#else
105
#define BYTE_ORDER 0
106 107 108 109 110
#endif

#define T_MASK ((md5_word_t)~0)
#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
111
#define T3 0x242070db
112 113
#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
114
#define T6 0x4787c62a
115 116
#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
117
#define T9 0x698098d8
118 119 120
#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
121
#define T13 0x6b901122
122 123
#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
124
#define T16 0x49b40821
125 126
#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
127
#define T19 0x265e5a51
128 129
#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
130
#define T22 0x02441453
131 132
#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
133
#define T25 0x21e1cde6
134 135
#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
136
#define T28 0x455a14ed
137 138
#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
139
#define T31 0x676f02d9
140 141 142
#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
143
#define T35 0x6d9d6122
144 145
#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
146
#define T38 0x4bdecfa9
147 148
#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
149
#define T41 0x289b7ec6
150 151
#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
152
#define T44 0x04881d05
153 154
#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
155
#define T47 0x1fa27cf8
156 157
#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
158
#define T50 0x432aff97
159 160
#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
161
#define T53 0x655b59c3
162 163 164
#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
165
#define T57 0x6fa87e4f
166 167
#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
168
#define T60 0x4e0811a1
169 170
#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
171
#define T63 0x2ad7d2bb
172 173
#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)

174
static void md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/)
175
{
176 177 178
  md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2],
             d = pms->abcd[3];
  md5_word_t t;
179
#if BYTE_ORDER > 0
180 181
  /* Define storage only for big-endian CPUs. */
  md5_word_t X[16];
182
#else
183 184 185
  /* Define storage for little-endian or both types of CPUs. */
  md5_word_t xbuf[16];
  const md5_word_t* X;
186 187
#endif

188
  {
189
#if BYTE_ORDER == 0
190 191 192 193 194 195 196 197
    /*
     * Determine dynamically whether this is a big-endian or
     * little-endian machine, since we can use a more efficient
     * algorithm on the latter.
     */
    static const int w = 1;

    if (*((const md5_byte_t*)&w)) /* dynamic little-endian */
198
#endif
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
#if BYTE_ORDER <= 0 /* little-endian */
    {
      /*
       * On little-endian machines, we can process properly aligned
       * data without copying it.
       */
      if (!((data - (const md5_byte_t*)0) & 3)) {
        /* data are properly aligned */
        X = (const md5_word_t*)data;
      } else {
        /* not aligned */
        memcpy(xbuf, data, 64);
        X = xbuf;
      }
    }
214 215
#endif
#if BYTE_ORDER == 0
216
    else /* dynamic big-endian */
217
#endif
218 219 220 221 222 223 224 225 226 227 228 229 230
#if BYTE_ORDER >= 0 /* big-endian */
    {
      /*
       * On big-endian machines, we must arrange the bytes in the
       * right order.
       */
      const md5_byte_t* xp = data;
      int i;

#if BYTE_ORDER == 0
      X = xbuf; /* (dynamic only) */
#else
#define xbuf X /* (static only) */
231
#endif
232 233 234
      for (i = 0; i < 16; ++i, xp += 4)
        xbuf[i] =
          (md5_word_t)(xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24));
235
    }
236 237
#endif
  }
238 239 240

#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))

241 242 243
/* Round 1. */
/* Let [abcd k s i] denote the operation
   a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
244
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
245 246
#define SET(a, b, c, d, k, s, Ti)                                             \
  t = a + F(b, c, d) + X[k] + (Ti);                                           \
247
  a = ROTATE_LEFT(t, s) + b
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
  /* Do the following 16 operations. */
  SET(a, b, c, d, 0, 7, T1);
  SET(d, a, b, c, 1, 12, T2);
  SET(c, d, a, b, 2, 17, T3);
  SET(b, c, d, a, 3, 22, T4);
  SET(a, b, c, d, 4, 7, T5);
  SET(d, a, b, c, 5, 12, T6);
  SET(c, d, a, b, 6, 17, T7);
  SET(b, c, d, a, 7, 22, T8);
  SET(a, b, c, d, 8, 7, T9);
  SET(d, a, b, c, 9, 12, T10);
  SET(c, d, a, b, 10, 17, T11);
  SET(b, c, d, a, 11, 22, T12);
  SET(a, b, c, d, 12, 7, T13);
  SET(d, a, b, c, 13, 12, T14);
  SET(c, d, a, b, 14, 17, T15);
  SET(b, c, d, a, 15, 22, T16);
265 266
#undef SET

267 268 269
/* Round 2. */
/* Let [abcd k s i] denote the operation
     a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
270
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
271 272
#define SET(a, b, c, d, k, s, Ti)                                             \
  t = a + G(b, c, d) + X[k] + (Ti);                                           \
273
  a = ROTATE_LEFT(t, s) + b
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
  /* Do the following 16 operations. */
  SET(a, b, c, d, 1, 5, T17);
  SET(d, a, b, c, 6, 9, T18);
  SET(c, d, a, b, 11, 14, T19);
  SET(b, c, d, a, 0, 20, T20);
  SET(a, b, c, d, 5, 5, T21);
  SET(d, a, b, c, 10, 9, T22);
  SET(c, d, a, b, 15, 14, T23);
  SET(b, c, d, a, 4, 20, T24);
  SET(a, b, c, d, 9, 5, T25);
  SET(d, a, b, c, 14, 9, T26);
  SET(c, d, a, b, 3, 14, T27);
  SET(b, c, d, a, 8, 20, T28);
  SET(a, b, c, d, 13, 5, T29);
  SET(d, a, b, c, 2, 9, T30);
  SET(c, d, a, b, 7, 14, T31);
  SET(b, c, d, a, 12, 20, T32);
291 292
#undef SET

293 294 295
/* Round 3. */
/* Let [abcd k s t] denote the operation
     a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
296
#define H(x, y, z) ((x) ^ (y) ^ (z))
297 298
#define SET(a, b, c, d, k, s, Ti)                                             \
  t = a + H(b, c, d) + X[k] + (Ti);                                           \
299
  a = ROTATE_LEFT(t, s) + b
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
  /* Do the following 16 operations. */
  SET(a, b, c, d, 5, 4, T33);
  SET(d, a, b, c, 8, 11, T34);
  SET(c, d, a, b, 11, 16, T35);
  SET(b, c, d, a, 14, 23, T36);
  SET(a, b, c, d, 1, 4, T37);
  SET(d, a, b, c, 4, 11, T38);
  SET(c, d, a, b, 7, 16, T39);
  SET(b, c, d, a, 10, 23, T40);
  SET(a, b, c, d, 13, 4, T41);
  SET(d, a, b, c, 0, 11, T42);
  SET(c, d, a, b, 3, 16, T43);
  SET(b, c, d, a, 6, 23, T44);
  SET(a, b, c, d, 9, 4, T45);
  SET(d, a, b, c, 12, 11, T46);
  SET(c, d, a, b, 15, 16, T47);
  SET(b, c, d, a, 2, 23, T48);
317 318
#undef SET

319 320 321
/* Round 4. */
/* Let [abcd k s t] denote the operation
     a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
322
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
323 324
#define SET(a, b, c, d, k, s, Ti)                                             \
  t = a + I(b, c, d) + X[k] + (Ti);                                           \
325
  a = ROTATE_LEFT(t, s) + b
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
  /* Do the following 16 operations. */
  SET(a, b, c, d, 0, 6, T49);
  SET(d, a, b, c, 7, 10, T50);
  SET(c, d, a, b, 14, 15, T51);
  SET(b, c, d, a, 5, 21, T52);
  SET(a, b, c, d, 12, 6, T53);
  SET(d, a, b, c, 3, 10, T54);
  SET(c, d, a, b, 10, 15, T55);
  SET(b, c, d, a, 1, 21, T56);
  SET(a, b, c, d, 8, 6, T57);
  SET(d, a, b, c, 15, 10, T58);
  SET(c, d, a, b, 6, 15, T59);
  SET(b, c, d, a, 13, 21, T60);
  SET(a, b, c, d, 4, 6, T61);
  SET(d, a, b, c, 11, 10, T62);
  SET(c, d, a, b, 2, 15, T63);
  SET(b, c, d, a, 9, 21, T64);
343 344
#undef SET

345 346 347 348 349 350 351
  /* Then perform the following additions. (That is increment each
     of the four registers by the value it had before this block
     was started.) */
  pms->abcd[0] += a;
  pms->abcd[1] += b;
  pms->abcd[2] += c;
  pms->abcd[3] += d;
352 353 354
}

/* Initialize the algorithm. */
355
static void md5_init(md5_state_t* pms)
356
{
357 358 359 360 361
  pms->count[0] = pms->count[1] = 0;
  pms->abcd[0] = 0x67452301;
  pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
  pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
  pms->abcd[3] = 0x10325476;
362 363 364
}

/* Append a string to the message. */
365
static void md5_append(md5_state_t* pms, const md5_byte_t* data, size_t nbytes)
366
{
367 368 369 370
  const md5_byte_t* p = data;
  size_t left = nbytes;
  size_t offset = (pms->count[0] >> 3) & 63;
  md5_word_t nbits = (md5_word_t)(nbytes << 3);
371

372 373
  if (nbytes <= 0)
    return;
374

375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
  /* Update the message length. */
  pms->count[1] += (md5_word_t)(nbytes >> 29);
  pms->count[0] += nbits;
  if (pms->count[0] < nbits)
    pms->count[1]++;

  /* Process an initial partial block. */
  if (offset) {
    size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes);

    memcpy(pms->buf + offset, p, copy);
    if (offset + copy < 64)
      return;
    p += copy;
    left -= copy;
    md5_process(pms, pms->buf);
  }

  /* Process full blocks. */
  for (; left >= 64; p += 64, left -= 64)
    md5_process(pms, p);

  /* Process a final partial block. */
  if (left)
    memcpy(pms->buf, p, left);
400 401 402
}

/* Finish the message and return the digest. */
403
static void md5_finish(md5_state_t* pms, md5_byte_t digest[16])
404
{
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
  static const md5_byte_t pad[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                      0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  md5_byte_t data[8];
  int i;

  /* Save the length before padding. */
  for (i = 0; i < 8; ++i)
    data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
  /* Pad to 56 bytes mod 64. */
  md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
  /* Append the length. */
  md5_append(pms, data, 8);
  for (i = 0; i < 16; ++i)
    digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
422 423
}

424
#if defined(__clang__) && !defined(__INTEL_COMPILER)
425
#pragma clang diagnostic pop
426 427
#endif

428 429 430 431 432 433 434 435 436 437 438 439
/*--------------------------------------------------------------------------*/
/* Wrap up the MD5 state in our opaque structure.  */
struct kwsysMD5_s
{
  md5_state_t md5_state;
};

/*--------------------------------------------------------------------------*/
kwsysMD5* kwsysMD5_New(void)
{
  /* Allocate a process control structure.  */
  kwsysMD5* md5 = (kwsysMD5*)malloc(sizeof(kwsysMD5));
440
  if (!md5) {
441
    return 0;
442
  }
443 444 445 446 447 448 449
  return md5;
}

/*--------------------------------------------------------------------------*/
void kwsysMD5_Delete(kwsysMD5* md5)
{
  /* Make sure we have an instance.  */
450
  if (!md5) {
451
    return;
452
  }
453 454 455 456 457 458 459 460 461 462 463 464 465 466

  /* Free memory.  */
  free(md5);
}

/*--------------------------------------------------------------------------*/
void kwsysMD5_Initialize(kwsysMD5* md5)
{
  md5_init(&md5->md5_state);
}

/*--------------------------------------------------------------------------*/
void kwsysMD5_Append(kwsysMD5* md5, unsigned char const* data, int length)
{
467
  size_t dlen;
468
  if (length < 0) {
469
    dlen = strlen((char const*)data);
470
  } else {
471
    dlen = (size_t)length;
472
  }
473
  md5_append(&md5->md5_state, (md5_byte_t const*)data, dlen);
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
}

/*--------------------------------------------------------------------------*/
void kwsysMD5_Finalize(kwsysMD5* md5, unsigned char digest[16])
{
  md5_finish(&md5->md5_state, (md5_byte_t*)digest);
}

/*--------------------------------------------------------------------------*/
void kwsysMD5_FinalizeHex(kwsysMD5* md5, char buffer[32])
{
  unsigned char digest[16];
  kwsysMD5_Finalize(md5, digest);
  kwsysMD5_DigestToHex(digest, buffer);
}

/*--------------------------------------------------------------------------*/
void kwsysMD5_DigestToHex(unsigned char const digest[16], char buffer[32])
{
  /* Map from 4-bit index to hexadecimal representation.  */
494 495
  static char const hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
                                '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
496 497 498 499

  /* Map each 4-bit block separately.  */
  char* out = buffer;
  int i;
500
  for (i = 0; i < 16; ++i) {
501 502
    *out++ = hex[digest[i] >> 4];
    *out++ = hex[digest[i] & 0xF];
503
  }
504
}