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