md5sum.c

   1 /* md5sum.c - Compute MD5 checksum of files or strings according to the
   2  *            definition of MD5 in RFC 1321 from April 1992.
   3  * Copyright (C) 1995-1999 Free Software Foundation, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu> */
  21 /* Hacked to work with BusyBox by Alfred M. Szmidt <ams@trillian.itslinux.org> */
  22
  23 /*
  24  * June 29, 2001        Manuel Novoa III
  25  *
  26  * Added MD5SUM_SIZE_VS_SPEED configuration option.
  27  *
  28  * Current valid values, with data from my system for comparison, are:
  29  *   (using uClibc and running on linux-2.4.4.tar.bz2)
  30  *                     user times (sec)  text size (386)
  31  *     0 (fastest)         1.1                6144
  32  *     1                   1.4                5392
  33  *     2                   3.0                5088
  34  *     3 (smallest)        5.1                4912
  35  */
  36
  37 #define MD5SUM_SIZE_VS_SPEED 2
  38
  39 /**********************************************************************/
  40
  41 #include <stdio.h>
  42 #include <errno.h>
  43 #include <ctype.h>
  44 #include <getopt.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <endian.h>
  48 #include <sys/types.h>
  49 #if defined HAVE_LIMITS_H
  50 # include <limits.h>
  51 #endif
  52 #include "busybox.h"
  53
  54 /* For some silly reason, this file uses backwards TRUE and FALSE conventions */
  55 #undef TRUE
  56 #undef FALSE
  57 #define FALSE   ((int) 1)
  58 #define TRUE    ((int) 0)
  59
  60 //----------------------------------------------------------------------------
  61 //--------md5.c
  62 //----------------------------------------------------------------------------
  63
  64 /* md5.c - Functions to compute MD5 message digest of files or memory blocks
  65  *         according to the definition of MD5 in RFC 1321 from April 1992.
  66  */
  67
  68 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
  69
  70 //----------------------------------------------------------------------------
  71 //--------md5.h
  72 //----------------------------------------------------------------------------
  73
  74 /* md5.h - Declaration of functions and data types used for MD5 sum
  75    computing library functions. */
  76
  77 typedef u_int32_t md5_uint32;
  78
  79 /* Structure to save state of computation between the single steps.  */
  80 struct md5_ctx
  81 {
  82   md5_uint32 A;
  83   md5_uint32 B;
  84   md5_uint32 C;
  85   md5_uint32 D;
  86
  87   md5_uint32 total[2];
  88   md5_uint32 buflen;
  89   char buffer[128];
  90 };
  91
  92 /*
  93  * The following three functions are build up the low level used in
  94  * the functions `md5_stream' and `md5_buffer'.
  95  */
  96
  97 /* Initialize structure containing state of computation.
  98    (RFC 1321, 3.3: Step 3)  */
  99 static void md5_init_ctx __P ((struct md5_ctx *ctx));
 100
 101 /* Starting with the result of former calls of this function (or the
 102    initialization function update the context for the next LEN bytes
 103    starting at BUFFER.
 104    It is necessary that LEN is a multiple of 64!!! */
 105 static void md5_process_block __P ((const void *buffer, size_t len,
 106                                     struct md5_ctx *ctx));
 107
 108 /* Starting with the result of former calls of this function (or the
 109    initialization function update the context for the next LEN bytes
 110    starting at BUFFER.
 111    It is NOT required that LEN is a multiple of 64.  */
 112 static void md5_process_bytes __P ((const void *buffer, size_t len,
 113                                     struct md5_ctx *ctx));
 114
 115 /* Process the remaining bytes in the buffer and put result from CTX
 116    in first 16 bytes following RESBUF.  The result is always in little
 117    endian byte order, so that a byte-wise output yields to the wanted
 118    ASCII representation of the message digest.
 119
 120    IMPORTANT: On some systems it is required that RESBUF is correctly
 121    aligned for a 32 bits value.  */
 122 static void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
 123
 124
 125
 126
 127 /* Compute MD5 message digest for bytes read from STREAM.  The
 128    resulting message digest number will be written into the 16 bytes
 129    beginning at RESBLOCK.  */
 130 static int md5_stream __P ((FILE *stream, void *resblock));
 131
 132 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
 133    result is always in little endian byte order, so that a byte-wise
 134    output yields to the wanted ASCII representation of the message
 135    digest.  */
 136 static void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
 137
 138 //----------------------------------------------------------------------------
 139 //--------end of md5.h
 140 //----------------------------------------------------------------------------
 141
 142 /* Handle endian-ness */
 143 #if __BYTE_ORDER == __LITTLE_ENDIAN
 144         #define SWAP(n) (n)
 145 #else
 146         #define SWAP(n) ((n << 24) | ((n&65280)<<8) | ((n&16711680)>>8) | (n>>24))
 147 #endif
 148
 149
 150
 151 #if MD5SUM_SIZE_VS_SPEED == 0
 152 /* This array contains the bytes used to pad the buffer to the next
 153    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
 154 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */  };
 155 #endif
 156
 157 /* Initialize structure containing state of computation.
 158    (RFC 1321, 3.3: Step 3)  */
 159 void md5_init_ctx(struct md5_ctx *ctx)
 160 {
 161   ctx->A = 0x67452301;
 162   ctx->B = 0xefcdab89;
 163   ctx->C = 0x98badcfe;
 164   ctx->D = 0x10325476;
 165
 166   ctx->total[0] = ctx->total[1] = 0;
 167   ctx->buflen = 0;
 168 }
 169
 170 /* Process the remaining bytes in the internal buffer and the usual
 171    prolog according to the standard and write the result to RESBUF.
 172
 173    IMPORTANT: On some systems it is required that RESBUF is correctly
 174    aligned for a 32 bits value.  */
 175 static void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
 176 {
 177   /* Take yet unprocessed bytes into account.  */
 178   md5_uint32 bytes = ctx->buflen;
 179   size_t pad;
 180
 181   /* Now count remaining bytes.  */
 182   ctx->total[0] += bytes;
 183   if (ctx->total[0] < bytes)
 184     ++ctx->total[1];
 185
 186   pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
 187 #if MD5SUM_SIZE_VS_SPEED > 0
 188   memset(&ctx->buffer[bytes], 0, pad);
 189   ctx->buffer[bytes] = 0x80;
 190 #else
 191   memcpy(&ctx->buffer[bytes], fillbuf, pad);
 192 #endif
 193
 194   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
 195   *(md5_uint32 *) & ctx->buffer[bytes + pad] = SWAP(ctx->total[0] << 3);
 196   *(md5_uint32 *) & ctx->buffer[bytes + pad + 4] =
 197     SWAP( ((ctx->total[1] << 3) | (ctx->total[0] >> 29)) );
 198
 199   /* Process last bytes.  */
 200   md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
 201
 202 /* Put result from CTX in first 16 bytes following RESBUF.  The result is
 203    always in little endian byte order, so that a byte-wise output yields
 204    to the wanted ASCII representation of the message digest.
 205
 206    IMPORTANT: On some systems it is required that RESBUF is correctly
 207    aligned for a 32 bits value.  */
 208   ((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
 209   ((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
 210   ((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
 211   ((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
 212
 213   return resbuf;
 214 }
 215
 216 /* Compute MD5 message digest for bytes read from STREAM.  The
 217    resulting message digest number will be written into the 16 bytes
 218    beginning at RESBLOCK.  */
 219 static int md5_stream(FILE *stream, void *resblock)
 220 {
 221   /* Important: BLOCKSIZE must be a multiple of 64.  */
 222 static const int BLOCKSIZE = 4096;
 223   struct md5_ctx ctx;
 224   char buffer[BLOCKSIZE + 72];
 225   size_t sum;
 226
 227   /* Initialize the computation context.  */
 228   md5_init_ctx(&ctx);
 229
 230   /* Iterate over full file contents.  */
 231   while (1) {
 232     /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
 233        computation function processes the whole buffer so that with the
 234        next round of the loop another block can be read.  */
 235     size_t n;
 236     sum = 0;
 237
 238     /* Read block.  Take care for partial reads.  */
 239     do {
 240       n = fread(buffer + sum, 1, BLOCKSIZE - sum, stream);
 241
 242       sum += n;
 243     }
 244     while (sum < BLOCKSIZE && n != 0);
 245     if (n == 0 && ferror(stream))
 246       return 1;
 247
 248     /* If end of file is reached, end the loop.  */
 249     if (n == 0)
 250       break;
 251
 252     /* Process buffer with BLOCKSIZE bytes.  Note that
 253        BLOCKSIZE % 64 == 0
 254     */
 255     md5_process_block(buffer, BLOCKSIZE, &ctx);
 256   }
 257
 258   /* Add the last bytes if necessary.  */
 259   if (sum > 0)
 260     md5_process_bytes(buffer, sum, &ctx);
 261
 262   /* Construct result in desired memory.  */
 263   md5_finish_ctx(&ctx, resblock);
 264   return 0;
 265 }
 266
 267 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
 268    result is always in little endian byte order, so that a byte-wise
 269    output yields to the wanted ASCII representation of the message
 270    digest.  */
 271 static void *md5_buffer(const char *buffer, size_t len, void *resblock)
 272 {
 273   struct md5_ctx ctx;
 274
 275   /* Initialize the computation context.  */
 276   md5_init_ctx(&ctx);
 277
 278   /* Process whole buffer but last len % 64 bytes.  */
 279   md5_process_bytes(buffer, len, &ctx);
 280
 281   /* Put result in desired memory area.  */
 282   return md5_finish_ctx(&ctx, resblock);
 283 }
 284
 285 static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
 286 {
 287   /* When we already have some bits in our internal buffer concatenate
 288      both inputs first.  */
 289   if (ctx->buflen != 0) {
 290     size_t left_over = ctx->buflen;
 291     size_t add = 128 - left_over > len ? len : 128 - left_over;
 292
 293     memcpy(&ctx->buffer[left_over], buffer, add);
 294     ctx->buflen += add;
 295
 296     if (left_over + add > 64) {
 297       md5_process_block(ctx->buffer, (left_over + add) & ~63, ctx);
 298       /* The regions in the following copy operation cannot overlap.  */
 299       memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
 300              (left_over + add) & 63);
 301       ctx->buflen = (left_over + add) & 63;
 302     }
 303
 304     buffer = (const char *) buffer + add;
 305     len -= add;
 306   }
 307
 308   /* Process available complete blocks.  */
 309   if (len > 64) {
 310     md5_process_block(buffer, len & ~63, ctx);
 311     buffer = (const char *) buffer + (len & ~63);
 312     len &= 63;
 313   }
 314
 315   /* Move remaining bytes in internal buffer.  */
 316   if (len > 0) {
 317     memcpy(ctx->buffer, buffer, len);
 318     ctx->buflen = len;
 319   }
 320 }
 321
 322 /* These are the four functions used in the four steps of the MD5 algorithm
 323    and defined in the RFC 1321.  The first function is a little bit optimized
 324    (as found in Colin Plumbs public domain implementation).  */
 325 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
 326 #define FF(b, c, d) (d ^ (b & (c ^ d)))
 327 #define FG(b, c, d) FF (d, b, c)
 328 #define FH(b, c, d) (b ^ c ^ d)
 329 #define FI(b, c, d) (c ^ (b | ~d))
 330
 331 /* Process LEN bytes of BUFFER, accumulating context into CTX.
 332    It is assumed that LEN % 64 == 0.  */
 333 static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
 334 {
 335   md5_uint32 correct_words[16];
 336   const md5_uint32 *words = buffer;
 337   size_t nwords = len / sizeof(md5_uint32);
 338   const md5_uint32 *endp = words + nwords;
 339 #if MD5SUM_SIZE_VS_SPEED > 0
 340   static const md5_uint32 C_array[] = {
 341       /* round 1 */
 342       0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
 343       0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
 344       0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
 345       0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
 346       /* round 2 */
 347       0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
 348       0xd62f105d, 0x2441453,  0xd8a1e681, 0xe7d3fbc8,
 349       0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
 350       0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
 351       /* round 3 */
 352       0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
 353       0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
 354       0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
 355       0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
 356       /* round 4 */
 357       0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
 358       0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
 359       0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
 360       0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
 361   };
 362
 363   static const char P_array[] = {
 364 #if MD5SUM_SIZE_VS_SPEED > 1
 365       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
 366 #endif
 367       1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
 368       5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
 369       0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9  /* 4 */
 370   };
 371
 372 #if MD5SUM_SIZE_VS_SPEED > 1
 373   static const char S_array[] = {
 374       7, 12, 17, 22,
 375       5, 9, 14, 20,
 376       4, 11, 16, 23,
 377       6, 10, 15, 21
 378   };
 379 #endif
 380 #endif
 381
 382   md5_uint32 A = ctx->A;
 383   md5_uint32 B = ctx->B;
 384   md5_uint32 C = ctx->C;
 385   md5_uint32 D = ctx->D;
 386
 387   /* First increment the byte count.  RFC 1321 specifies the possible
 388      length of the file up to 2^64 bits.  Here we only compute the
 389      number of bytes.  Do a double word increment.  */
 390   ctx->total[0] += len;
 391   if (ctx->total[0] < len)
 392     ++ctx->total[1];
 393
 394   /* Process all bytes in the buffer with 64 bytes in each round of
 395      the loop.  */
 396   while (words < endp) {
 397     md5_uint32 *cwp = correct_words;
 398     md5_uint32 A_save = A;
 399     md5_uint32 B_save = B;
 400     md5_uint32 C_save = C;
 401     md5_uint32 D_save = D;
 402
 403 #if MD5SUM_SIZE_VS_SPEED > 1
 404 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 405
 406     const md5_uint32 *pc;
 407     const char *pp;
 408     const char *ps;
 409     int i;
 410     md5_uint32 temp;
 411
 412     for ( i=0 ; i < 16 ; i++ ) {
 413         cwp[i] = SWAP(words[i]);
 414     }
 415     words += 16;
 416
 417 #if MD5SUM_SIZE_VS_SPEED > 2
 418     pc = C_array; pp = P_array; ps = S_array - 4;
 419
 420     for ( i = 0 ; i < 64 ; i++ ) {
 421         if ((i&0x0f) == 0) ps += 4;
 422         temp = A;
 423         switch (i>>4) {
 424             case 0:
 425                 temp += FF(B,C,D);
 426                 break;
 427             case 1:
 428                 temp += FG(B,C,D);
 429                 break;
 430             case 2:
 431                 temp += FH(B,C,D);
 432                 break;
 433             case 3:
 434                 temp += FI(B,C,D);
 435         }
 436         temp += cwp[(int)(*pp++)] + *pc++;
 437         temp = CYCLIC (temp, ps[i&3]);
 438         temp += B;
 439         A = D; D = C; C = B; B = temp;
 440     }
 441 #else
 442     pc = C_array; pp = P_array; ps = S_array;
 443
 444     for ( i = 0 ; i < 16 ; i++ ) {
 445         temp = A + FF(B,C,D) + cwp[(int)(*pp++)] + *pc++;
 446         temp = CYCLIC (temp, ps[i&3]);
 447         temp += B;
 448         A = D; D = C; C = B; B = temp;
 449     }
 450
 451     ps += 4;
 452     for ( i = 0 ; i < 16 ; i++ ) {
 453         temp = A + FG(B,C,D) + cwp[(int)(*pp++)] + *pc++;
 454         temp = CYCLIC (temp, ps[i&3]);
 455         temp += B;
 456         A = D; D = C; C = B; B = temp;
 457     }
 458     ps += 4;
 459     for ( i = 0 ; i < 16 ; i++ ) {
 460         temp = A + FH(B,C,D) + cwp[(int)(*pp++)] + *pc++;
 461         temp = CYCLIC (temp, ps[i&3]);
 462         temp += B;
 463         A = D; D = C; C = B; B = temp;
 464     }
 465     ps += 4;
 466     for ( i = 0 ; i < 16 ; i++ ) {
 467         temp = A + FI(B,C,D) + cwp[(int)(*pp++)] + *pc++;
 468         temp = CYCLIC (temp, ps[i&3]);
 469         temp += B;
 470         A = D; D = C; C = B; B = temp;
 471     }
 472
 473 #endif
 474 #else
 475     /* First round: using the given function, the context and a constant
 476        the next context is computed.  Because the algorithms processing
 477        unit is a 32-bit word and it is determined to work on words in
 478        little endian byte order we perhaps have to change the byte order
 479        before the computation.  To reduce the work for the next steps
 480        we store the swapped words in the array CORRECT_WORDS.  */
 481
 482 #define OP(a, b, c, d, s, T)                                            \
 483       do                                                                \
 484         {                                                               \
 485           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
 486           ++words;                                                      \
 487           CYCLIC (a, s);                                                \
 488           a += b;                                                       \
 489         }                                                               \
 490       while (0)
 491
 492     /* It is unfortunate that C does not provide an operator for
 493        cyclic rotation.  Hope the C compiler is smart enough.  */
 494     /* gcc 2.95.4 seems to be --aaronl */
 495 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 496
 497     /* Before we start, one word to the strange constants.
 498        They are defined in RFC 1321 as
 499
 500        T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
 501     */
 502
 503 #if MD5SUM_SIZE_VS_SPEED == 1
 504     const md5_uint32 *pc;
 505     const char *pp;
 506     int i;
 507 #endif
 508
 509     /* Round 1.  */
 510 #if MD5SUM_SIZE_VS_SPEED == 1
 511     pc = C_array;
 512     for ( i=0 ; i < 4 ; i++ ) {
 513         OP(A, B, C, D, 7, *pc++);
 514         OP(D, A, B, C, 12, *pc++);
 515         OP(C, D, A, B, 17, *pc++);
 516         OP(B, C, D, A, 22, *pc++);
 517     }
 518 #else
 519     OP(A, B, C, D, 7, 0xd76aa478);
 520     OP(D, A, B, C, 12, 0xe8c7b756);
 521     OP(C, D, A, B, 17, 0x242070db);
 522     OP(B, C, D, A, 22, 0xc1bdceee);
 523     OP(A, B, C, D, 7, 0xf57c0faf);
 524     OP(D, A, B, C, 12, 0x4787c62a);
 525     OP(C, D, A, B, 17, 0xa8304613);
 526     OP(B, C, D, A, 22, 0xfd469501);
 527     OP(A, B, C, D, 7, 0x698098d8);
 528     OP(D, A, B, C, 12, 0x8b44f7af);
 529     OP(C, D, A, B, 17, 0xffff5bb1);
 530     OP(B, C, D, A, 22, 0x895cd7be);
 531     OP(A, B, C, D, 7, 0x6b901122);
 532     OP(D, A, B, C, 12, 0xfd987193);
 533     OP(C, D, A, B, 17, 0xa679438e);
 534     OP(B, C, D, A, 22, 0x49b40821);
 535 #endif
 536
 537     /* For the second to fourth round we have the possibly swapped words
 538        in CORRECT_WORDS.  Redefine the macro to take an additional first
 539        argument specifying the function to use.  */
 540 #undef OP
 541 #define OP(f, a, b, c, d, k, s, T)                                      \
 542       do                                                                \
 543         {                                                               \
 544           a += f (b, c, d) + correct_words[k] + T;                      \
 545           CYCLIC (a, s);                                                \
 546           a += b;                                                       \
 547         }                                                               \
 548       while (0)
 549
 550     /* Round 2.  */
 551 #if MD5SUM_SIZE_VS_SPEED == 1
 552     pp = P_array;
 553     for ( i=0 ; i < 4 ; i++ ) {
 554         OP(FG, A, B, C, D, (int)(*pp++), 5, *pc++);
 555         OP(FG, D, A, B, C, (int)(*pp++), 9, *pc++);
 556         OP(FG, C, D, A, B, (int)(*pp++), 14, *pc++);
 557         OP(FG, B, C, D, A, (int)(*pp++), 20, *pc++);
 558     }
 559 #else
 560     OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
 561     OP(FG, D, A, B, C, 6, 9, 0xc040b340);
 562     OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
 563     OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
 564     OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
 565     OP(FG, D, A, B, C, 10, 9, 0x02441453);
 566     OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
 567     OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
 568     OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
 569     OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
 570     OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
 571     OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
 572     OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
 573     OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
 574     OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
 575     OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
 576 #endif
 577
 578     /* Round 3.  */
 579 #if MD5SUM_SIZE_VS_SPEED == 1
 580     for ( i=0 ; i < 4 ; i++ ) {
 581         OP(FH, A, B, C, D, (int)(*pp++), 4, *pc++);
 582         OP(FH, D, A, B, C, (int)(*pp++), 11, *pc++);
 583         OP(FH, C, D, A, B, (int)(*pp++), 16, *pc++);
 584         OP(FH, B, C, D, A, (int)(*pp++), 23, *pc++);
 585     }
 586 #else
 587     OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
 588     OP(FH, D, A, B, C, 8, 11, 0x8771f681);
 589     OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
 590     OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
 591     OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
 592     OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
 593     OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
 594     OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
 595     OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
 596     OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
 597     OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
 598     OP(FH, B, C, D, A, 6, 23, 0x04881d05);
 599     OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
 600     OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
 601     OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
 602     OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
 603 #endif
 604
 605     /* Round 4.  */
 606 #if MD5SUM_SIZE_VS_SPEED == 1
 607     for ( i=0 ; i < 4 ; i++ ) {
 608         OP(FI, A, B, C, D, (int)(*pp++), 6, *pc++);
 609         OP(FI, D, A, B, C, (int)(*pp++), 10, *pc++);
 610         OP(FI, C, D, A, B, (int)(*pp++), 15, *pc++);
 611         OP(FI, B, C, D, A, (int)(*pp++), 21, *pc++);
 612     }
 613 #else
 614     OP(FI, A, B, C, D, 0, 6, 0xf4292244);
 615     OP(FI, D, A, B, C, 7, 10, 0x432aff97);
 616     OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
 617     OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
 618     OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
 619     OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
 620     OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
 621     OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
 622     OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
 623     OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
 624     OP(FI, C, D, A, B, 6, 15, 0xa3014314);
 625     OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
 626     OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
 627     OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
 628     OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
 629     OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
 630 #endif
 631 #endif
 632
 633     /* Add the starting values of the context.  */
 634     A += A_save;
 635     B += B_save;
 636     C += C_save;
 637     D += D_save;
 638   }
 639
 640   /* Put checksum in context given as argument.  */
 641   ctx->A = A;
 642   ctx->B = B;
 643   ctx->C = C;
 644   ctx->D = D;
 645 }
 646
 647 //----------------------------------------------------------------------------
 648 //--------end of md5.c
 649 //----------------------------------------------------------------------------
 650
 651 #define ISWHITE(c) ((c) == ' ' || (c) == '\t')
 652 #define ISXDIGIT(c) (isxdigit (c))
 653
 654 /* The minimum length of a valid digest line in a file produced
 655    by `md5sum FILE' and read by `md5sum -c'.  This length does
 656    not include any newline character at the end of a line.  */
 657 static const int MIN_DIGEST_LINE_LENGTH = 35; /* 32 - message digest length
 658                                       2 - blank and binary indicator
 659                                       1 - minimum filename length */
 660
 661 static int have_read_stdin; /* Nonzero if any of the files read were
 662                                the standard input. */
 663
 664 static int status_only = 0; /* With -c, don't generate any output.
 665                                The exit code indicates success or failure */
 666 static int warn = 0; /* With -w, print a message to standard error warning
 667                         about each improperly formatted MD5 checksum line */
 668
 669 static int split_3(char *s,
 670                    size_t s_len,
 671                    unsigned char **u,
 672                    char **w)
 673 {
 674   size_t i = 0;
 675   int escaped_filename = 0;
 676
 677   while (ISWHITE(s[i]))
 678     ++i;
 679
 680   /* The line must have at least 35 (36 if the first is a backslash)
 681      more characters to contain correct message digest information.
 682      Ignore this line if it is too short.  */
 683   if (!(s_len - i >= MIN_DIGEST_LINE_LENGTH
 684         || (s[i] == '\\' && s_len - i >= 1 + MIN_DIGEST_LINE_LENGTH)))
 685     return FALSE;
 686
 687   if (s[i] == '\\') {
 688     ++i;
 689     escaped_filename = 1;
 690   }
 691   *u = (unsigned char *) &s[i];
 692
 693   /* The first field has to be the 32-character hexadecimal
 694      representation of the message digest.  If it is not followed
 695      immediately by a white space it's an error.  */
 696   i += 32;
 697   if (!ISWHITE(s[i]))
 698     return FALSE;
 699
 700   s[i++] = '\0';
 701
 702   if (s[i] != ' ' && s[i++] != '*')
 703     return FALSE;
 704
 705   /* All characters between the type indicator and end of line are
 706      significant -- that includes leading and trailing white space.  */
 707   *w = &s[i];
 708
 709   if (escaped_filename) {
 710     /* Translate each `\n' string in the file name to a NEWLINE,
 711        and each `\\' string to a backslash.  */
 712
 713     char *dst = &s[i];
 714
 715     while (i < s_len) {
 716       switch (s[i]) {
 717        case '\\':
 718         if (i == s_len - 1) {
 719           /* A valid line does not end with a backslash.  */
 720           return FALSE;
 721         }
 722         ++i;
 723         switch (s[i++]) {
 724          case 'n':
 725           *dst++ = '\n';
 726           break;
 727          case '\\':
 728           *dst++ = '\\';
 729           break;
 730          default:
 731           /* Only `\' or `n' may follow a backslash.  */
 732           return FALSE;
 733         }
 734         break;
 735
 736        case '\0':
 737         /* The file name may not contain a NUL.  */
 738         return FALSE;
 739         break;
 740
 741        default:
 742         *dst++ = s[i++];
 743         break;
 744       }
 745     }
 746     *dst = '\0';
 747   }
 748   return TRUE;
 749 }
 750
 751 static inline int hex_digits(unsigned char const *s)
 752 {
 753   while (*s) {
 754     if (!ISXDIGIT(*s))
 755       return TRUE;
 756     ++s;
 757   }
 758   return FALSE;
 759 }
 760
 761 /* An interface to md5_stream.  Operate on FILENAME (it may be "-") and
 762    put the result in *MD5_RESULT.  Return non-zero upon failure, zero
 763    to indicate success.  */
 764 static int md5_file(const char *filename,
 765                     unsigned char *md5_result)
 766 {
 767   FILE *fp;
 768
 769   if (filename[0] == '-' && filename[1] == '\0') {
 770     have_read_stdin = 1;
 771     fp = stdin;
 772   } else {
 773     fp = wfopen(filename, "r");
 774     if (fp == NULL)
 775       return FALSE;
 776     }
 777
 778   if (md5_stream(fp, md5_result)) {
 779     perror_msg("%s", filename);
 780
 781     if (fp != stdin)
 782       fclose(fp);
 783     return FALSE;
 784   }
 785
 786   if (fp != stdin && fclose(fp) == EOF) {
 787     perror_msg("%s", filename);
 788     return FALSE;
 789   }
 790
 791   return TRUE;
 792 }
 793
 794 static int md5_check(const char *checkfile_name)
 795 {
 796   FILE *checkfile_stream;
 797   int n_properly_formated_lines = 0;
 798   int n_mismatched_checksums = 0;
 799   int n_open_or_read_failures = 0;
 800   unsigned char md5buffer[16];
 801   size_t line_number;
 802   char line[BUFSIZ];
 803
 804   if (checkfile_name[0] == '-' && checkfile_name[1] == '\0') {
 805     have_read_stdin = 1;
 806     checkfile_stream = stdin;
 807   } else {
 808     checkfile_stream = wfopen(checkfile_name, "r");
 809     if (checkfile_stream == NULL)
 810       return FALSE;
 811     }
 812
 813   line_number = 0;
 814
 815   do {
 816     char *filename;
 817     unsigned char *md5num;
 818     int line_length;
 819
 820     ++line_number;
 821
 822     fgets(line, BUFSIZ-1, checkfile_stream);
 823     line_length = strlen(line);
 824
 825     if (line_length <= 0 || line==NULL)
 826       break;
 827
 828     /* Ignore comment lines, which begin with a '#' character.  */
 829     if (line[0] == '#')
 830       continue;
 831
 832     /* Remove any trailing newline.  */
 833     if (line[line_length - 1] == '\n')
 834       line[--line_length] = '\0';
 835
 836     if (split_3(line, line_length, &md5num, &filename)
 837         || !hex_digits(md5num)) {
 838       if (warn) {
 839         error_msg("%s: %lu: improperly formatted MD5 checksum line",
 840                  checkfile_name, (unsigned long) line_number);
 841       }
 842     } else {
 843       static const char bin2hex[] = {
 844         '0', '1', '2', '3',
 845         '4', '5', '6', '7',
 846         '8', '9', 'a', 'b',
 847         'c', 'd', 'e', 'f'
 848       };
 849
 850       ++n_properly_formated_lines;
 851
 852       if (md5_file(filename, md5buffer)) {
 853         ++n_open_or_read_failures;
 854         if (!status_only) {
 855           printf("%s: FAILED open or read\n", filename);
 856           fflush(stdout);
 857         }
 858       } else {
 859         size_t cnt;
 860         /* Compare generated binary number with text representation
 861            in check file.  Ignore case of hex digits.  */
 862         for (cnt = 0; cnt < 16; ++cnt) {
 863           if (tolower(md5num[2 * cnt])
 864               != bin2hex[md5buffer[cnt] >> 4]
 865               || (tolower(md5num[2 * cnt + 1])
 866                   != (bin2hex[md5buffer[cnt] & 0xf])))
 867             break;
 868         }
 869         if (cnt != 16)
 870           ++n_mismatched_checksums;
 871
 872         if (!status_only) {
 873           printf("%s: %s\n", filename,
 874                  (cnt != 16 ? "FAILED" : "OK"));
 875           fflush(stdout);
 876         }
 877       }
 878     }
 879   }
 880
 881   while (!feof(checkfile_stream) && !ferror(checkfile_stream));
 882
 883   if (ferror(checkfile_stream)) {
 884     error_msg("%s: read error", checkfile_name);
 885     return FALSE;
 886   }
 887
 888   if (checkfile_stream != stdin && fclose(checkfile_stream) == EOF) {
 889     perror_msg("md5sum: %s", checkfile_name);
 890     return FALSE;
 891   }
 892
 893   if (n_properly_formated_lines == 0) {
 894     /* Warn if no tests are found.  */
 895     error_msg("%s: no properly formatted MD5 checksum lines found",
 896              checkfile_name);
 897     return FALSE;
 898   } else {
 899     if (!status_only) {
 900       int n_computed_checkums = (n_properly_formated_lines
 901                                  - n_open_or_read_failures);
 902
 903       if (n_open_or_read_failures > 0) {
 904         error_msg("WARNING: %d of %d listed files could not be read",
 905                  n_open_or_read_failures, n_properly_formated_lines);
 906         return FALSE;
 907       }
 908
 909       if (n_mismatched_checksums > 0) {
 910         error_msg("WARNING: %d of %d computed checksums did NOT match",
 911                  n_mismatched_checksums, n_computed_checkums);
 912         return FALSE;
 913       }
 914     }
 915   }
 916
 917   return ((n_properly_formated_lines > 0 && n_mismatched_checksums == 0
 918            && n_open_or_read_failures == 0) ? 0 : 1);
 919 }
 920
 921 int md5sum_main(int argc,
 922                 char **argv)
 923 {
 924   unsigned char md5buffer[16];
 925   int do_check = 0;
 926   int opt;
 927   char **string = NULL;
 928   size_t n_strings = 0;
 929   size_t err = 0;
 930   char file_type_specified = 0;
 931   char binary = 0;
 932
 933   while ((opt = getopt(argc, argv, "g:bcstw")) != -1) {
 934     switch (opt) {
 935      case 'g': { /* read a string */
 936        if (string == NULL)
 937          string = (char **) xmalloc ((argc - 1) * sizeof (char *));
 938
 939        string[n_strings++] = optarg;
 940        break;
 941      }
 942
 943      case 'b': /* read files in binary mode */
 944       file_type_specified = 1;
 945       binary = 1;
 946       break;
 947
 948      case 'c': /* check MD5 sums against given list */
 949       do_check = 1;
 950       break;
 951
 952      case 's':  /* don't output anything, status code shows success */
 953       status_only = 1;
 954       warn = 0;
 955       break;
 956
 957      case 't': /* read files in text mode (default) */
 958       file_type_specified = 1;
 959       binary = 0;
 960       break;
 961
 962      case 'w': /* warn about improperly formated MD5 checksum lines */
 963       status_only = 0;
 964       warn = 1;
 965       break;
 966
 967      default:
 968       show_usage();
 969     }
 970   }
 971
 972   if (file_type_specified && do_check) {
 973     error_msg_and_die("the -b and -t options are meaningless when verifying checksums");
 974   }
 975
 976   if (n_strings > 0 && do_check) {
 977     error_msg_and_die("the -g and -c options are mutually exclusive");
 978   }
 979
 980   if (status_only && !do_check) {
 981     error_msg_and_die("the -s option is meaningful only when verifying checksums");
 982   }
 983
 984   if (warn && !do_check) {
 985     error_msg_and_die("the -w option is meaningful only when verifying checksums");
 986   }
 987
 988   if (n_strings > 0) {
 989     size_t i;
 990
 991     if (optind < argc) {
 992       error_msg_and_die("no files may be specified when using -g");
 993     }
 994     for (i = 0; i < n_strings; ++i) {
 995       size_t cnt;
 996       md5_buffer (string[i], strlen (string[i]), md5buffer);
 997
 998       for (cnt = 0; cnt < 16; ++cnt)
 999         printf ("%02x", md5buffer[cnt]);
1000
1001       printf ("  \"%s\"\n", string[i]);
1002     }
1003   } else if (do_check) {
1004     if (optind + 1 < argc) {
1005       error_msg("only one argument may be specified when using -c");
1006     }
1007
1008     err = md5_check ((optind == argc) ? "-" : argv[optind]);
1009   } else {
1010     if (optind == argc)
1011       argv[argc++] = "-";
1012
1013     for (; optind < argc; ++optind) {
1014       int fail;
1015       char *file = argv[optind];
1016
1017       fail = md5_file (file, md5buffer);
1018       err |= fail;
1019       if (!fail && file[0]=='-' && file[1] == '\0') {
1020           size_t i;
1021           for (i = 0; i < 16; ++i)
1022               printf ("%02x", md5buffer[i]);
1023           putchar ('\n');
1024       } else if (!fail) {
1025         size_t i;
1026         /* Output a leading backslash if the file name contains
1027            a newline or backslash.  */
1028         if (strchr (file, '\n') || strchr (file, '\\'))
1029           putchar ('\\');
1030
1031         for (i = 0; i < 16; ++i)
1032           printf ("%02x", md5buffer[i]);
1033
1034         putchar (' ');
1035         if (binary)
1036           putchar ('*');
1037         else
1038           putchar (' ');
1039
1040         /* Translate each NEWLINE byte to the string, "\\n",
1041            and each backslash to "\\\\".  */
1042         for (i = 0; i < strlen (file); ++i) {
1043           switch (file[i]) {
1044            case '\n':
1045             fputs ("\\n", stdout);
1046             break;
1047
1048            case '\\':
1049             fputs ("\\\\", stdout);
1050             break;
1051
1052            default:
1053             putchar (file[i]);
1054             break;
1055           }
1056         }
1057         putchar ('\n');
1058       }
1059     }
1060   }
1061
1062   if (fclose (stdout) == EOF) {
1063     error_msg_and_die("write error");
1064   }
1065
1066   if (have_read_stdin && fclose (stdin) == EOF) {
1067     error_msg_and_die("standard input");
1068   }
1069
1070   if (err == 0)
1071           return EXIT_SUCCESS;
1072   else
1073           return EXIT_FAILURE;
1074 }