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