lib/md5.c

   1 /* Functions to compute MD5 message digest of files or memory blocks.
   2    according to the definition of MD5 in RFC 1321 from April 1992.
   3    Copyright (C) 1995-1997, 1999-2001, 2005-2006, 2008-2020 Free Software
   4    Foundation, Inc.
   5    This file is part of the GNU C Library.
   6
   7    This program is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by the
   9    Free Software Foundation; either version 2, or (at your option) any
  10    later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, see <https://www.gnu.org/licenses/>.  */
  19
  20 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
  21
  22 #include <config.h>
  23
  24 #if HAVE_OPENSSL_MD5
  25 # define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
  26 #endif
  27 #include "md5.h"
  28
  29 #include <stdalign.h>
  30 #include <stdint.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <sys/types.h>
  34
  35 #if USE_UNLOCKED_IO
  36 # include "unlocked-io.h"
  37 #endif
  38
  39 #ifdef _LIBC
  40 # include <endian.h>
  41 # if __BYTE_ORDER == __BIG_ENDIAN
  42 #  define WORDS_BIGENDIAN 1
  43 # endif
  44 /* We need to keep the namespace clean so define the MD5 function
  45    protected using leading __ .  */
  46 # define md5_init_ctx __md5_init_ctx
  47 # define md5_process_block __md5_process_block
  48 # define md5_process_bytes __md5_process_bytes
  49 # define md5_finish_ctx __md5_finish_ctx
  50 # define md5_read_ctx __md5_read_ctx
  51 # define md5_stream __md5_stream
  52 # define md5_buffer __md5_buffer
  53 #endif
  54
  55 #include <byteswap.h>
  56 #ifdef WORDS_BIGENDIAN
  57 # define SWAP(n) bswap_32 (n)
  58 #else
  59 # define SWAP(n) (n)
  60 #endif
  61
  62 #define BLOCKSIZE 32768
  63 #if BLOCKSIZE % 64 != 0
  64 # error "invalid BLOCKSIZE"
  65 #endif
  66
  67 #if ! HAVE_OPENSSL_MD5
  68 /* This array contains the bytes used to pad the buffer to the next
  69    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
  70 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
  71
  72
  73 /* Initialize structure containing state of computation.
  74    (RFC 1321, 3.3: Step 3)  */
  75 void
  76 md5_init_ctx (struct md5_ctx *ctx)
  77 {
  78   ctx->A = 0x67452301;
  79   ctx->B = 0xefcdab89;
  80   ctx->C = 0x98badcfe;
  81   ctx->D = 0x10325476;
  82
  83   ctx->total[0] = ctx->total[1] = 0;
  84   ctx->buflen = 0;
  85 }
  86
  87 /* Copy the 4 byte value from v into the memory location pointed to by *cp,
  88    If your architecture allows unaligned access this is equivalent to
  89    * (uint32_t *) cp = v  */
  90 static void
  91 set_uint32 (char *cp, uint32_t v)
  92 {
  93   memcpy (cp, &v, sizeof v);
  94 }
  95
  96 /* Put result from CTX in first 16 bytes following RESBUF.  The result
  97    must be in little endian byte order.  */
  98 void *
  99 md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 100 {
 101   char *r = resbuf;
 102   set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A));
 103   set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B));
 104   set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C));
 105   set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D));
 106
 107   return resbuf;
 108 }
 109
 110 /* Process the remaining bytes in the internal buffer and the usual
 111    prolog according to the standard and write the result to RESBUF.  */
 112 void *
 113 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 114 {
 115   /* Take yet unprocessed bytes into account.  */
 116   uint32_t bytes = ctx->buflen;
 117   size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
 118
 119   /* Now count remaining bytes.  */
 120   ctx->total[0] += bytes;
 121   if (ctx->total[0] < bytes)
 122     ++ctx->total[1];
 123
 124   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
 125   ctx->buffer[size - 2] = SWAP (ctx->total[0] << 3);
 126   ctx->buffer[size - 1] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
 127
 128   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
 129
 130   /* Process last bytes.  */
 131   md5_process_block (ctx->buffer, size * 4, ctx);
 132
 133   return md5_read_ctx (ctx, resbuf);
 134 }
 135 #endif
 136
 137 #if defined _LIBC || defined GL_COMPILE_CRYPTO_STREAM
 138
 139 #include "af_alg.h"
 140
 141 /* Compute MD5 message digest for bytes read from STREAM.  The
 142    resulting message digest number will be written into the 16 bytes
 143    beginning at RESBLOCK.  */
 144 int
 145 md5_stream (FILE *stream, void *resblock)
 146 {
 147   switch (afalg_stream (stream, "md5", resblock, MD5_DIGEST_SIZE))
 148     {
 149     case 0: return 0;
 150     case -EIO: return 1;
 151     }
 152
 153   char *buffer = malloc (BLOCKSIZE + 72);
 154   if (!buffer)
 155     return 1;
 156
 157   struct md5_ctx ctx;
 158   md5_init_ctx (&ctx);
 159   size_t sum;
 160
 161   /* Iterate over full file contents.  */
 162   while (1)
 163     {
 164       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
 165          computation function processes the whole buffer so that with the
 166          next round of the loop another block can be read.  */
 167       size_t n;
 168       sum = 0;
 169
 170       /* Read block.  Take care for partial reads.  */
 171       while (1)
 172         {
 173           /* Either process a partial fread() from this loop,
 174              or the fread() in afalg_stream may have gotten EOF.
 175              We need to avoid a subsequent fread() as EOF may
 176              not be sticky.  For details of such systems, see:
 177              https://sourceware.org/bugzilla/show_bug.cgi?id=1190  */
 178           if (feof (stream))
 179             goto process_partial_block;
 180
 181           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
 182
 183           sum += n;
 184
 185           if (sum == BLOCKSIZE)
 186             break;
 187
 188           if (n == 0)
 189             {
 190               /* Check for the error flag IFF N == 0, so that we don't
 191                  exit the loop after a partial read due to e.g., EAGAIN
 192                  or EWOULDBLOCK.  */
 193               if (ferror (stream))
 194                 {
 195                   free (buffer);
 196                   return 1;
 197                 }
 198               goto process_partial_block;
 199             }
 200         }
 201
 202       /* Process buffer with BLOCKSIZE bytes.  Note that
 203          BLOCKSIZE % 64 == 0
 204        */
 205       md5_process_block (buffer, BLOCKSIZE, &ctx);
 206     }
 207
 208 process_partial_block:
 209
 210   /* Process any remaining bytes.  */
 211   if (sum > 0)
 212     md5_process_bytes (buffer, sum, &ctx);
 213
 214   /* Construct result in desired memory.  */
 215   md5_finish_ctx (&ctx, resblock);
 216   free (buffer);
 217   return 0;
 218 }
 219 #endif
 220
 221 #if ! HAVE_OPENSSL_MD5
 222 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
 223    result is always in little endian byte order, so that a byte-wise
 224    output yields to the wanted ASCII representation of the message
 225    digest.  */
 226 void *
 227 md5_buffer (const char *buffer, size_t len, void *resblock)
 228 {
 229   struct md5_ctx ctx;
 230
 231   /* Initialize the computation context.  */
 232   md5_init_ctx (&ctx);
 233
 234   /* Process whole buffer but last len % 64 bytes.  */
 235   md5_process_bytes (buffer, len, &ctx);
 236
 237   /* Put result in desired memory area.  */
 238   return md5_finish_ctx (&ctx, resblock);
 239 }
 240
 241
 242 void
 243 md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 244 {
 245   /* When we already have some bits in our internal buffer concatenate
 246      both inputs first.  */
 247   if (ctx->buflen != 0)
 248     {
 249       size_t left_over = ctx->buflen;
 250       size_t add = 128 - left_over > len ? len : 128 - left_over;
 251
 252       memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
 253       ctx->buflen += add;
 254
 255       if (ctx->buflen > 64)
 256         {
 257           md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
 258
 259           ctx->buflen &= 63;
 260           /* The regions in the following copy operation cannot overlap,
 261              because ctx->buflen < 64 ≤ (left_over + add) & ~63.  */
 262           memcpy (ctx->buffer,
 263                   &((char *) ctx->buffer)[(left_over + add) & ~63],
 264                   ctx->buflen);
 265         }
 266
 267       buffer = (const char *) buffer + add;
 268       len -= add;
 269     }
 270
 271   /* Process available complete blocks.  */
 272   if (len >= 64)
 273     {
 274 #if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
 275 # define UNALIGNED_P(p) ((uintptr_t) (p) % alignof (uint32_t) != 0)
 276       if (UNALIGNED_P (buffer))
 277         while (len > 64)
 278           {
 279             md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
 280             buffer = (const char *) buffer + 64;
 281             len -= 64;
 282           }
 283       else
 284 #endif
 285         {
 286           md5_process_block (buffer, len & ~63, ctx);
 287           buffer = (const char *) buffer + (len & ~63);
 288           len &= 63;
 289         }
 290     }
 291
 292   /* Move remaining bytes in internal buffer.  */
 293   if (len > 0)
 294     {
 295       size_t left_over = ctx->buflen;
 296
 297       memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
 298       left_over += len;
 299       if (left_over >= 64)
 300         {
 301           md5_process_block (ctx->buffer, 64, ctx);
 302           left_over -= 64;
 303           /* The regions in the following copy operation cannot overlap,
 304              because left_over ≤ 64.  */
 305           memcpy (ctx->buffer, &ctx->buffer[16], left_over);
 306         }
 307       ctx->buflen = left_over;
 308     }
 309 }
 310
 311
 312 /* These are the four functions used in the four steps of the MD5 algorithm
 313    and defined in the RFC 1321.  The first function is a little bit optimized
 314    (as found in Colin Plumbs public domain implementation).  */
 315 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
 316 #define FF(b, c, d) (d ^ (b & (c ^ d)))
 317 #define FG(b, c, d) FF (d, b, c)
 318 #define FH(b, c, d) (b ^ c ^ d)
 319 #define FI(b, c, d) (c ^ (b | ~d))
 320
 321 /* Process LEN bytes of BUFFER, accumulating context into CTX.
 322    It is assumed that LEN % 64 == 0.  */
 323
 324 void
 325 md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
 326 {
 327   uint32_t correct_words[16];
 328   const uint32_t *words = buffer;
 329   size_t nwords = len / sizeof (uint32_t);
 330   const uint32_t *endp = words + nwords;
 331   uint32_t A = ctx->A;
 332   uint32_t B = ctx->B;
 333   uint32_t C = ctx->C;
 334   uint32_t D = ctx->D;
 335   uint32_t lolen = len;
 336
 337   /* First increment the byte count.  RFC 1321 specifies the possible
 338      length of the file up to 2^64 bits.  Here we only compute the
 339      number of bytes.  Do a double word increment.  */
 340   ctx->total[0] += lolen;
 341   ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
 342
 343   /* Process all bytes in the buffer with 64 bytes in each round of
 344      the loop.  */
 345   while (words < endp)
 346     {
 347       uint32_t *cwp = correct_words;
 348       uint32_t A_save = A;
 349       uint32_t B_save = B;
 350       uint32_t C_save = C;
 351       uint32_t D_save = D;
 352
 353       /* First round: using the given function, the context and a constant
 354          the next context is computed.  Because the algorithms processing
 355          unit is a 32-bit word and it is determined to work on words in
 356          little endian byte order we perhaps have to change the byte order
 357          before the computation.  To reduce the work for the next steps
 358          we store the swapped words in the array CORRECT_WORDS.  */
 359
 360 #define OP(a, b, c, d, s, T)                                            \
 361       do                                                                \
 362         {                                                               \
 363           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
 364           ++words;                                                      \
 365           CYCLIC (a, s);                                                \
 366           a += b;                                                       \
 367         }                                                               \
 368       while (0)
 369
 370       /* It is unfortunate that C does not provide an operator for
 371          cyclic rotation.  Hope the C compiler is smart enough.  */
 372 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 373
 374       /* Before we start, one word to the strange constants.
 375          They are defined in RFC 1321 as
 376
 377          T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
 378
 379          Here is an equivalent invocation using Perl:
 380
 381          perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
 382        */
 383
 384       /* Round 1.  */
 385       OP (A, B, C, D, 7, 0xd76aa478);
 386       OP (D, A, B, C, 12, 0xe8c7b756);
 387       OP (C, D, A, B, 17, 0x242070db);
 388       OP (B, C, D, A, 22, 0xc1bdceee);
 389       OP (A, B, C, D, 7, 0xf57c0faf);
 390       OP (D, A, B, C, 12, 0x4787c62a);
 391       OP (C, D, A, B, 17, 0xa8304613);
 392       OP (B, C, D, A, 22, 0xfd469501);
 393       OP (A, B, C, D, 7, 0x698098d8);
 394       OP (D, A, B, C, 12, 0x8b44f7af);
 395       OP (C, D, A, B, 17, 0xffff5bb1);
 396       OP (B, C, D, A, 22, 0x895cd7be);
 397       OP (A, B, C, D, 7, 0x6b901122);
 398       OP (D, A, B, C, 12, 0xfd987193);
 399       OP (C, D, A, B, 17, 0xa679438e);
 400       OP (B, C, D, A, 22, 0x49b40821);
 401
 402       /* For the second to fourth round we have the possibly swapped words
 403          in CORRECT_WORDS.  Redefine the macro to take an additional first
 404          argument specifying the function to use.  */
 405 #undef OP
 406 #define OP(f, a, b, c, d, k, s, T)                                      \
 407       do                                                                \
 408         {                                                               \
 409           a += f (b, c, d) + correct_words[k] + T;                      \
 410           CYCLIC (a, s);                                                \
 411           a += b;                                                       \
 412         }                                                               \
 413       while (0)
 414
 415       /* Round 2.  */
 416       OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
 417       OP (FG, D, A, B, C, 6, 9, 0xc040b340);
 418       OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
 419       OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
 420       OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
 421       OP (FG, D, A, B, C, 10, 9, 0x02441453);
 422       OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
 423       OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
 424       OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
 425       OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
 426       OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
 427       OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
 428       OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
 429       OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
 430       OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
 431       OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
 432
 433       /* Round 3.  */
 434       OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
 435       OP (FH, D, A, B, C, 8, 11, 0x8771f681);
 436       OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
 437       OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
 438       OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
 439       OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
 440       OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
 441       OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
 442       OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
 443       OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
 444       OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
 445       OP (FH, B, C, D, A, 6, 23, 0x04881d05);
 446       OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
 447       OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
 448       OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
 449       OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
 450
 451       /* Round 4.  */
 452       OP (FI, A, B, C, D, 0, 6, 0xf4292244);
 453       OP (FI, D, A, B, C, 7, 10, 0x432aff97);
 454       OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
 455       OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
 456       OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
 457       OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
 458       OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
 459       OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
 460       OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
 461       OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
 462       OP (FI, C, D, A, B, 6, 15, 0xa3014314);
 463       OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
 464       OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
 465       OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
 466       OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
 467       OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
 468
 469       /* Add the starting values of the context.  */
 470       A += A_save;
 471       B += B_save;
 472       C += C_save;
 473       D += D_save;
 474     }
 475
 476   /* Put checksum in context given as argument.  */
 477   ctx->A = A;
 478   ctx->B = B;
 479   ctx->C = C;
 480   ctx->D = D;
 481 }
 482 #endif
 483
 484 /*
 485  * Hey Emacs!
 486  * Local Variables:
 487  * coding: utf-8
 488  * End:
 489  */