jackd/md5.c

   1 /*
   2  * Functions to compute MD5 message digest of files or memory blocks
   3  * according to the definition of MD5 in RFC 1321 from April 1992.
   4  * Copyright (C) 1995, 1996 Free Software Foundation, Inc.  NOTE: The
   5  * canonical source of this file is maintained with the GNU C Library.
   6  * Bugs can be reported to bug-glibc@prep.ai.mit.edu.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published
  10  * by the Free Software Foundation; either version 2, or (at your
  11  * option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  21  * 02111-1307, USA.
  22  *
  23  * Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
  24  * Modified by Gray Watson <http://256.com/gray/>, 1997.
  25  *
  26  */
  27
  28 /*
  29  * NOTE: during quick performance tests on a Sun Sparc Ultra 1 and an
  30  * Alpha 255 300, these functions performed upwards of 3mb/sec
  31  * including disk I/O time.
  32  */
  33
  34 /*
  35  * MD5 Test Suite from RFC1321: http://ds.internic.net:/rfc/rfc1321.txt
  36  *
  37  * MD5 ("") = d41d8cd98f00b204e9800998ecf8427e
  38  * MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661
  39  * MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
  40  * MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
  41  * MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
  42  * MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") =
  43  * d174ab98d277d9f5a5611c2c9f419d9f
  44  * MD5 ("123456789012345678901234567890123456789012345678901234567890123456
  45  * 78901234567890") = 57edf4a22be3c955ac49da2e2107b67a
  46  */
  47
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <sys/types.h>
  51
  52 #include "md5.h"
  53 #include "md5_loc.h"
  54
  55 /* static       char    *rcs_id =
  56
  57 /* version id for the library */
  58 /* static char *version_id = "$MD5Version: 1.0.0 November-19-1997 $"; */
  59
  60 /****************************** local routines *******************************/
  61
  62 /*
  63  * process_block
  64  *
  65  * DESCRIPTION:
  66  *
  67  * Process a block of bytes into a MD5 state structure.
  68  *
  69  * RETURNS:
  70  *
  71  * None.
  72  *
  73  * ARGUMENTS:
  74  *
  75  * md5_p - Pointer to MD5 structure from which we are getting the result.
  76  *
  77  * buffer - A buffer of bytes whose MD5 signature we are calculating.
  78  *
  79  * buf_len - The length of the buffer.
  80  */
  81 static  void    process_block(md5_t *md5_p, const void *buffer,
  82                               const unsigned int buf_len)
  83 {
  84   md5_uint32    correct[16];
  85   const void    *buf_p = buffer, *end_p;
  86   unsigned int  words_n;
  87   md5_uint32    A, B, C, D;
  88
  89   words_n = buf_len / sizeof(md5_uint32);
  90   end_p = (char *)buf_p + words_n * sizeof(md5_uint32);
  91
  92   A = md5_p->md_A;
  93   B = md5_p->md_B;
  94   C = md5_p->md_C;
  95   D = md5_p->md_D;
  96
  97   /*
  98    * First increment the byte count.  RFC 1321 specifies the possible
  99    * length of the file up to 2^64 bits.  Here we only compute the
 100    * number of bytes with a double word increment.  Modified to do
 101    * this to better avoid overflows in the lower word -- Gray 10/97.
 102    */
 103   if (md5_p->md_total[0] > MAX_MD5_UINT32 - buf_len) {
 104     md5_p->md_total[1]++;
 105     md5_p->md_total[0] -= (MAX_MD5_UINT32 - buf_len);
 106   }
 107   else {
 108     md5_p->md_total[0] += buf_len;
 109   }
 110
 111   /*
 112    * Process all bytes in the buffer with MD5_BLOCK bytes in each
 113    * round of the loop.
 114    */
 115   while (buf_p < end_p) {
 116     md5_uint32  A_save, B_save, C_save, D_save;
 117     md5_uint32  *corr_p = correct;
 118
 119     A_save = A;
 120     B_save = B;
 121     C_save = C;
 122     D_save = D;
 123
 124     /*
 125      * Before we start, one word to the strange constants.  They are
 126      * defined in RFC 1321 as
 127      *
 128      * T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..MD5_BLOCK
 129      */
 130
 131     /* Round 1. */
 132     OP1 (A, B, C, D, buf_p, corr_p,  7, 0xd76aa478);
 133     OP1 (D, A, B, C, buf_p, corr_p, 12, 0xe8c7b756);
 134     OP1 (C, D, A, B, buf_p, corr_p, 17, 0x242070db);
 135     OP1 (B, C, D, A, buf_p, corr_p, 22, 0xc1bdceee);
 136     OP1 (A, B, C, D, buf_p, corr_p,  7, 0xf57c0faf);
 137     OP1 (D, A, B, C, buf_p, corr_p, 12, 0x4787c62a);
 138     OP1 (C, D, A, B, buf_p, corr_p, 17, 0xa8304613);
 139     OP1 (B, C, D, A, buf_p, corr_p, 22, 0xfd469501);
 140     OP1 (A, B, C, D, buf_p, corr_p,  7, 0x698098d8);
 141     OP1 (D, A, B, C, buf_p, corr_p, 12, 0x8b44f7af);
 142     OP1 (C, D, A, B, buf_p, corr_p, 17, 0xffff5bb1);
 143     OP1 (B, C, D, A, buf_p, corr_p, 22, 0x895cd7be);
 144     OP1 (A, B, C, D, buf_p, corr_p,  7, 0x6b901122);
 145     OP1 (D, A, B, C, buf_p, corr_p, 12, 0xfd987193);
 146     OP1 (C, D, A, B, buf_p, corr_p, 17, 0xa679438e);
 147     OP1 (B, C, D, A, buf_p, corr_p, 22, 0x49b40821);
 148
 149     /* Round 2. */
 150     OP234 (FG, A, B, C, D, correct[  1],  5, 0xf61e2562);
 151     OP234 (FG, D, A, B, C, correct[  6],  9, 0xc040b340);
 152     OP234 (FG, C, D, A, B, correct[ 11], 14, 0x265e5a51);
 153     OP234 (FG, B, C, D, A, correct[  0], 20, 0xe9b6c7aa);
 154     OP234 (FG, A, B, C, D, correct[  5],  5, 0xd62f105d);
 155     OP234 (FG, D, A, B, C, correct[ 10],  9, 0x02441453);
 156     OP234 (FG, C, D, A, B, correct[ 15], 14, 0xd8a1e681);
 157     OP234 (FG, B, C, D, A, correct[  4], 20, 0xe7d3fbc8);
 158     OP234 (FG, A, B, C, D, correct[  9],  5, 0x21e1cde6);
 159     OP234 (FG, D, A, B, C, correct[ 14],  9, 0xc33707d6);
 160     OP234 (FG, C, D, A, B, correct[  3], 14, 0xf4d50d87);
 161     OP234 (FG, B, C, D, A, correct[  8], 20, 0x455a14ed);
 162     OP234 (FG, A, B, C, D, correct[ 13],  5, 0xa9e3e905);
 163     OP234 (FG, D, A, B, C, correct[  2],  9, 0xfcefa3f8);
 164     OP234 (FG, C, D, A, B, correct[  7], 14, 0x676f02d9);
 165     OP234 (FG, B, C, D, A, correct[ 12], 20, 0x8d2a4c8a);
 166
 167     /* Round 3. */
 168     OP234 (FH, A, B, C, D, correct[  5],  4, 0xfffa3942);
 169     OP234 (FH, D, A, B, C, correct[  8], 11, 0x8771f681);
 170     OP234 (FH, C, D, A, B, correct[ 11], 16, 0x6d9d6122);
 171     OP234 (FH, B, C, D, A, correct[ 14], 23, 0xfde5380c);
 172     OP234 (FH, A, B, C, D, correct[  1],  4, 0xa4beea44);
 173     OP234 (FH, D, A, B, C, correct[  4], 11, 0x4bdecfa9);
 174     OP234 (FH, C, D, A, B, correct[  7], 16, 0xf6bb4b60);
 175     OP234 (FH, B, C, D, A, correct[ 10], 23, 0xbebfbc70);
 176     OP234 (FH, A, B, C, D, correct[ 13],  4, 0x289b7ec6);
 177     OP234 (FH, D, A, B, C, correct[  0], 11, 0xeaa127fa);
 178     OP234 (FH, C, D, A, B, correct[  3], 16, 0xd4ef3085);
 179     OP234 (FH, B, C, D, A, correct[  6], 23, 0x04881d05);
 180     OP234 (FH, A, B, C, D, correct[  9],  4, 0xd9d4d039);
 181     OP234 (FH, D, A, B, C, correct[ 12], 11, 0xe6db99e5);
 182     OP234 (FH, C, D, A, B, correct[ 15], 16, 0x1fa27cf8);
 183     OP234 (FH, B, C, D, A, correct[  2], 23, 0xc4ac5665);
 184
 185     /* Round 4. */
 186     OP234 (FI, A, B, C, D, correct[  0],  6, 0xf4292244);
 187     OP234 (FI, D, A, B, C, correct[  7], 10, 0x432aff97);
 188     OP234 (FI, C, D, A, B, correct[ 14], 15, 0xab9423a7);
 189     OP234 (FI, B, C, D, A, correct[  5], 21, 0xfc93a039);
 190     OP234 (FI, A, B, C, D, correct[ 12],  6, 0x655b59c3);
 191     OP234 (FI, D, A, B, C, correct[  3], 10, 0x8f0ccc92);
 192     OP234 (FI, C, D, A, B, correct[ 10], 15, 0xffeff47d);
 193     OP234 (FI, B, C, D, A, correct[  1], 21, 0x85845dd1);
 194     OP234 (FI, A, B, C, D, correct[  8],  6, 0x6fa87e4f);
 195     OP234 (FI, D, A, B, C, correct[ 15], 10, 0xfe2ce6e0);
 196     OP234 (FI, C, D, A, B, correct[  6], 15, 0xa3014314);
 197     OP234 (FI, B, C, D, A, correct[ 13], 21, 0x4e0811a1);
 198     OP234 (FI, A, B, C, D, correct[  4],  6, 0xf7537e82);
 199     OP234 (FI, D, A, B, C, correct[ 11], 10, 0xbd3af235);
 200     OP234 (FI, C, D, A, B, correct[  2], 15, 0x2ad7d2bb);
 201     OP234 (FI, B, C, D, A, correct[  9], 21, 0xeb86d391);
 202
 203     /* Add the starting values of the context. */
 204     A += A_save;
 205     B += B_save;
 206     C += C_save;
 207     D += D_save;
 208   }
 209
 210   /* Put checksum in context given as argument. */
 211   md5_p->md_A = A;
 212   md5_p->md_B = B;
 213   md5_p->md_C = C;
 214   md5_p->md_D = D;
 215 }
 216
 217 /*
 218  * md5_get_result
 219  *
 220  * DESCRIPTION:
 221  *
 222  * Copy the resulting MD5 signature from MD5_P into the first 16 bytes
 223  * (MD5_SIZE) of the result buffer.
 224  *
 225  * RETURNS:
 226  *
 227  * None.
 228  *
 229  * ARGUMENTS:
 230  *
 231  * md5_p - Pointer to MD5 structure from which we are getting the result.
 232  *
 233  * result - A 16 byte buffer that will contain the MD5 signature.
 234  */
 235 static  void    md5_get_result(const md5_t *md5_p, void *result)
 236 {
 237   md5_uint32    hold;
 238   void          *res_p = result;
 239
 240   hold = SWAP(md5_p->md_A);
 241   memcpy(res_p, &hold, sizeof(md5_uint32));
 242   res_p = (char *)res_p + sizeof(md5_uint32);
 243
 244   hold = SWAP(md5_p->md_B);
 245   memcpy(res_p, &hold, sizeof(md5_uint32));
 246   res_p = (char *)res_p + sizeof(md5_uint32);
 247
 248   hold = SWAP(md5_p->md_C);
 249   memcpy(res_p, &hold, sizeof(md5_uint32));
 250   res_p = (char *)res_p + sizeof(md5_uint32);
 251
 252   hold = SWAP(md5_p->md_D);
 253   memcpy(res_p, &hold, sizeof(md5_uint32));
 254 }
 255
 256 /***************************** exported routines *****************************/
 257
 258 /*
 259  * md5_init
 260  *
 261  * DESCRIPTION:
 262  *
 263  * Initialize structure containing state of MD5 computation. (RFC 1321,
 264  * 3.3: Step 3).  This is for progressive MD5 calculations only.  If
 265  * you have the complete string available, md5_buffer should be used.
 266  * md5_process should be called for each bunch of bytes and after the
 267  * last process call, md5_finish should be called to get the
 268  * signature.
 269  *
 270  * RETURNS:
 271  *
 272  * None.
 273  *
 274  * ARGUMENTS:
 275  *
 276  * md5_p - Pointer to md5 structure that we are initializing.
 277  */
 278 void    md5_init(md5_t *md5_p)
 279 {
 280   md5_p->md_A = 0x67452301;
 281   md5_p->md_B = 0xefcdab89;
 282   md5_p->md_C = 0x98badcfe;
 283   md5_p->md_D = 0x10325476;
 284
 285   md5_p->md_total[0] = 0;
 286   md5_p->md_total[1] = 0;
 287   md5_p->md_buf_len = 0;
 288 }
 289
 290 /*
 291  * md5_process
 292  *
 293  * DESCRIPTION:
 294  *
 295  * This function is used to progressively calculate a MD5 signature some
 296  * number of bytes at a time.  If you have the complete string
 297  * available, md5_buffer should be used.  The MD5 structure should
 298  * have been initialized with md5_init and after the last process
 299  * call, md5_finish should be called to get the results.
 300  *
 301  * RETURNS:
 302  *
 303  * None.
 304  *
 305  * ARGUMENTS:
 306  *
 307  * md5_p - Pointer to MD5 structure which we are progressively updating.
 308  *
 309  * buffer - A buffer of bytes whose MD5 signature we are calculating.
 310  *
 311  * buf_len - The length of the buffer.
 312  */
 313 void    md5_process(md5_t *md5_p, const void *buffer,
 314                     const unsigned int buf_len)
 315 {
 316   unsigned int  len = buf_len;
 317   unsigned int  in_block, add;
 318
 319   /*
 320    * When we already have some bytes in our internal buffer, copy some
 321    * from the user to fill the block.
 322    */
 323   if (md5_p->md_buf_len > 0) {
 324
 325     in_block = md5_p->md_buf_len;
 326     if (in_block + len > sizeof(md5_p->md_buffer)) {
 327       add = sizeof(md5_p->md_buffer) - in_block;
 328     }
 329     else {
 330       add = len;
 331     }
 332
 333     memcpy (md5_p->md_buffer + in_block, buffer, add);
 334     md5_p->md_buf_len += add;
 335     in_block += add;
 336
 337     if (in_block > MD5_BLOCK_SIZE) {
 338       process_block (md5_p, md5_p->md_buffer, in_block & ~BLOCK_SIZE_MASK);
 339       /* the regions in the following copy operation will not overlap. */
 340       memcpy (md5_p->md_buffer,
 341               md5_p->md_buffer + (in_block & ~BLOCK_SIZE_MASK),
 342               in_block & BLOCK_SIZE_MASK);
 343       md5_p->md_buf_len = in_block & BLOCK_SIZE_MASK;
 344     }
 345
 346     buffer = (const char *)buffer + add;
 347     len -= add;
 348   }
 349
 350   /* process available complete blocks right from the user buffer */
 351   if (len > MD5_BLOCK_SIZE) {
 352     process_block (md5_p, buffer, len & ~BLOCK_SIZE_MASK);
 353     buffer = (const char *) buffer + (len & ~BLOCK_SIZE_MASK);
 354     len &= BLOCK_SIZE_MASK;
 355   }
 356
 357   /* copy remaining bytes into the internal buffer */
 358   if (len > 0) {
 359     memcpy (md5_p->md_buffer, buffer, len);
 360     md5_p->md_buf_len = len;
 361   }
 362 }
 363
 364 /*
 365  * md5_finish
 366  *
 367  * DESCRIPTION:
 368  *
 369  * Finish a progressing MD5 calculation and copy the resulting MD5
 370  * signature into the result buffer which should be 16 bytes
 371  * (MD5_SIZE).  After this call, the MD5 structure is invalid.
 372  *
 373  * RETURNS:
 374  *
 375  * None.
 376  *
 377  * ARGUMENTS:
 378  *
 379  * md5_p - Pointer to MD5 structure which we are finishing.
 380  *
 381  * signature - A 16 byte buffer that will contain the MD5 signature.
 382  */
 383 void    md5_finish(md5_t *md5_p, void *signature)
 384 {
 385   md5_uint32    bytes, hold;
 386   int           pad;
 387
 388   /* take yet unprocessed bytes into account */
 389   bytes = md5_p->md_buf_len;
 390
 391   /*
 392    * Count remaining bytes.  Modified to do this to better avoid
 393    * overflows in the lower word -- Gray 10/97.
 394    */
 395   if (md5_p->md_total[0] > MAX_MD5_UINT32 - bytes) {
 396     md5_p->md_total[1]++;
 397     md5_p->md_total[0] -= (MAX_MD5_UINT32 - bytes);
 398   }
 399   else {
 400     md5_p->md_total[0] += bytes;
 401   }
 402
 403   /*
 404    * Pad the buffer to the next MD5_BLOCK-byte boundary.  (RFC 1321,
 405    * 3.1: Step 1).  We need enough room for two size words and the
 406    * bytes left in the buffer.  For some reason even if we are equal
 407    * to the block-size, we add an addition block of pad bytes.
 408    */
 409   pad = MD5_BLOCK_SIZE - (sizeof(md5_uint32) * 2) - bytes;
 410   if (pad <= 0) {
 411     pad += MD5_BLOCK_SIZE;
 412   }
 413
 414   /*
 415    * Modified from a fixed array to this assignment and memset to be
 416    * more flexible with block-sizes -- Gray 10/97.
 417    */
 418   if (pad > 0) {
 419     /* some sort of padding start byte */
 420     md5_p->md_buffer[bytes] = (unsigned char)0x80;
 421     if (pad > 1) {
 422       memset (md5_p->md_buffer + bytes + 1, 0, pad - 1);
 423     }
 424     bytes += pad;
 425   }
 426
 427   /* put the 64-bit file length in _bits_ (i.e. *8) at the end of the buffer */
 428   hold = SWAP(md5_p->md_total[0] << 3);
 429   memcpy(md5_p->md_buffer + bytes, &hold, sizeof(md5_uint32));
 430   bytes += sizeof(md5_uint32);
 431
 432   /* shift the high word over by 3 and add in the top 3 bits from the low */
 433   hold = SWAP((md5_p->md_total[1] << 3) | (md5_p->md_total[0] >> 29));
 434   memcpy(md5_p->md_buffer + bytes, &hold, sizeof(md5_uint32));
 435   bytes += sizeof(md5_uint32);
 436
 437   /* process last bytes, the padding chars, and size words */
 438   process_block(md5_p, md5_p->md_buffer, bytes);
 439   md5_get_result(md5_p, signature);
 440 }
 441
 442 /*
 443  * md5_buffer
 444  *
 445  * DESCRIPTION:
 446  *
 447  * This function is used to calculate a MD5 signature for a buffer of
 448  * bytes.  If you only have part of a buffer that you want to process
 449  * then md5_init, md5_process, and md5_finish should be used.
 450  *
 451  * RETURNS:
 452  *
 453  * None.
 454  *
 455  * ARGUMENTS:
 456  *
 457  * buffer - A buffer of bytes whose MD5 signature we are calculating.
 458  *
 459  * buf_len - The length of the buffer.
 460  *
 461  * signature - A 16 byte buffer that will contain the MD5 signature.
 462  */
 463 void    md5_buffer(const char *buffer, const unsigned int buf_len,
 464                    void *signature)
 465 {
 466   md5_t         md5;
 467
 468   /* initialize the computation context */
 469   md5_init(&md5);
 470
 471   /* process whole buffer but last buf_len % MD5_BLOCK bytes */
 472   md5_process(&md5, buffer, buf_len);
 473
 474   /* put result in desired memory area */
 475   md5_finish(&md5, signature);
 476 }
 477
 478 /*
 479  * md5_sig_to_string
 480  *
 481  * DESCRIPTION:
 482  *
 483  * Convert a MD5 signature in a 16 byte buffer into a hexadecimal string
 484  * representation.
 485  *
 486  * RETURNS:
 487  *
 488  * None.
 489  *
 490  * ARGUMENTS:
 491  *
 492  * signature - a 16 byte buffer that contains the MD5 signature.
 493  *
 494  * str - a string of charactes which should be at least 33 bytes long (2
 495  * characters per MD5 byte and 1 for the \0).
 496  *
 497  * str_len - the length of the string.
 498  */
 499 void    md5_sig_to_string(void *signature, char *str, const int str_len)
 500 {
 501   unsigned char *sig_p;
 502   char          *str_p, *max_p;
 503   unsigned int  high, low;
 504
 505   str_p = str;
 506   max_p = str + str_len;
 507
 508   for (sig_p = (unsigned char *)signature;
 509        sig_p < (unsigned char *)signature + MD5_SIZE;
 510        sig_p++) {
 511     high = *sig_p / 16;
 512     low = *sig_p % 16;
 513     /* account for 2 chars */
 514     if (str_p + 1 >= max_p) {
 515       break;
 516     }
 517     *str_p++ = HEX_STRING[high];
 518     *str_p++ = HEX_STRING[low];
 519   }
 520   /* account for 2 chars */
 521   if (str_p < max_p) {
 522     *str_p++ = '\0';
 523   }
 524 }
 525
 526 /*
 527  * md5_sig_from_string
 528  *
 529  * DESCRIPTION:
 530  *
 531  * Convert a MD5 signature from a hexadecimal string representation into
 532  * a 16 byte buffer.
 533  *
 534  * RETURNS:
 535  *
 536  * None.
 537  *
 538  * ARGUMENTS:
 539  *
 540  * signature - A 16 byte buffer that will contain the MD5 signature.
 541  *
 542  * str - A string of charactes which _must_ be at least 32 bytes long (2
 543  * characters per MD5 byte).
 544  */
 545 void    md5_sig_from_string(void *signature, const char *str)
 546 {
 547   unsigned char *sig_p;
 548   const char    *str_p;
 549   char          *hex;
 550   unsigned int  high, low, val;
 551
 552   hex = HEX_STRING;
 553   sig_p = signature;
 554
 555   for (str_p = str; str_p < str + MD5_SIZE * 2; str_p += 2) {
 556     high = strchr(hex, *str_p) - hex;
 557     low = strchr(hex, *(str_p + 1)) - hex;
 558     val = high * 16 + low;
 559     *sig_p++ = val;
 560   }
 561 }