diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/uip/RCS/md5.c,v

   1 head    1.4;
   2 access;
   3 symbols;
   4 locks; strict;
   5 comment @ * @;
   6
   7
   8 1.4
   9 date    92.10.26.16.48.02;      author jromine; state Exp;
  10 branches;
  11 next    1.3;
  12
  13 1.3
  14 date    92.10.20.22.45.05;      author jromine; state Exp;
  15 branches;
  16 next    1.2;
  17
  18 1.2
  19 date    92.03.03.17.09.57;      author jromine; state Exp;
  20 branches;
  21 next    1.1;
  22
  23 1.1
  24 date    92.02.11.05.16.13;      author jromine; state Exp;
  25 branches;
  26 next    ;
  27
  28
  29 desc
  30 @@
  31
  32
  33 1.4
  34 log
  35 @MD5 API changes (from MTR)
  36 @
  37 text
  38 @#ifndef        lint
  39 static char md5ident[]="@@(#)$Id: md5.c,v 1.3 1992/10/20 22:45:05 jromine Exp jromine $";
  40 #endif
  41 /* taken from RFC-1321/Appendix A.3 */
  42
  43 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
  44  */
  45
  46 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  47 rights reserved.
  48
  49 License to copy and use this software is granted provided that it
  50 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
  51 Algorithm" in all material mentioning or referencing this software
  52 or this function.
  53
  54 License is also granted to make and use derivative works provided
  55 that such works are identified as "derived from the RSA Data
  56 Security, Inc. MD5 Message-Digest Algorithm" in all material
  57 mentioning or referencing the derived work.
  58
  59 RSA Data Security, Inc. makes no representations concerning either
  60 the merchantability of this software or the suitability of this
  61 software for any particular purpose. It is provided "as is"
  62 without express or implied warranty of any kind.
  63
  64 These notices must be retained in any copies of any part of this
  65 documentation and/or software.
  66  */
  67
  68 /* #include "global.h" */
  69 #include "../h/md5.h"
  70
  71 /* Constants for MD5Transform routine.
  72  */
  73 #define S11 7
  74 #define S12 12
  75 #define S13 17
  76 #define S14 22
  77 #define S21 5
  78 #define S22 9
  79 #define S23 14
  80 #define S24 20
  81 #define S31 4
  82 #define S32 11
  83 #define S33 16
  84 #define S34 23
  85 #define S41 6
  86 #define S42 10
  87 #define S43 15
  88 #define S44 21
  89
  90 static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
  91 static void Encode PROTO_LIST
  92   ((unsigned char *, UINT4 *, unsigned int));
  93 static void Decode PROTO_LIST
  94   ((UINT4 *, unsigned char *, unsigned int));
  95 static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
  96 static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
  97
  98 static unsigned char PADDING[64] = {
  99   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 100   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 101   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 102 };
 103
 104 /* F, G, H and I are basic MD5 functions.
 105  */
 106 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
 107 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
 108 #define H(x, y, z) ((x) ^ (y) ^ (z))
 109 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 110
 111 /* ROTATE_LEFT rotates x left n bits.
 112  */
 113 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 114
 115 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
 116 Rotation is separate from addition to prevent recomputation.
 117  */
 118 #define FF(a, b, c, d, x, s, ac) { \
 119  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 120  (a) = ROTATE_LEFT ((a), (s)); \
 121  (a) += (b); \
 122   }
 123 #define GG(a, b, c, d, x, s, ac) { \
 124  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 125  (a) = ROTATE_LEFT ((a), (s)); \
 126  (a) += (b); \
 127   }
 128 #define HH(a, b, c, d, x, s, ac) { \
 129  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 130  (a) = ROTATE_LEFT ((a), (s)); \
 131  (a) += (b); \
 132   }
 133 #define II(a, b, c, d, x, s, ac) { \
 134  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 135  (a) = ROTATE_LEFT ((a), (s)); \
 136  (a) += (b); \
 137   }
 138
 139 /* MD5 initialization. Begins an MD5 operation, writing a new context.
 140  */
 141 void MD5Init (context)
 142 MD5_CTX *context;                                        /* context */
 143 {
 144   context->count[0] = context->count[1] = 0;
 145   /* Load magic initialization constants.
 146 */
 147   context->state[0] = 0x67452301;
 148   context->state[1] = 0xefcdab89;
 149   context->state[2] = 0x98badcfe;
 150   context->state[3] = 0x10325476;
 151 }
 152
 153 /* MD5 block update operation. Continues an MD5 message-digest
 154   operation, processing another message block, and updating the
 155   context.
 156  */
 157 void MD5Update (context, input, inputLen)
 158 MD5_CTX *context;                                        /* context */
 159 unsigned char *input;                                /* input block */
 160 unsigned int inputLen;                     /* length of input block */
 161 {
 162   unsigned int i, index, partLen;
 163
 164   /* Compute number of bytes mod 64 */
 165   index = (unsigned int)((context->count[0] >> 3) & 0x3F);
 166
 167   /* Update number of bits */
 168   if ((context->count[0] += ((UINT4)inputLen << 3))
 169    < ((UINT4)inputLen << 3))
 170  context->count[1]++;
 171   context->count[1] += ((UINT4)inputLen >> 29);
 172
 173   partLen = 64 - index;
 174
 175   /* Transform as many times as possible.
 176 */
 177   if (inputLen >= partLen) {
 178  MD5_memcpy
 179    ((POINTER)&context->buffer[index], (POINTER)input, partLen);
 180  MD5Transform (context->state, context->buffer);
 181
 182  for (i = partLen; i + 63 < inputLen; i += 64)
 183    MD5Transform (context->state, &input[i]);
 184
 185  index = 0;
 186   }
 187   else
 188  i = 0;
 189
 190   /* Buffer remaining input */
 191   MD5_memcpy
 192  ((POINTER)&context->buffer[index], (POINTER)&input[i],
 193   inputLen-i);
 194 }
 195
 196 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 197   the message digest and zeroizing the context.
 198  */
 199 void MD5Final (digest, context)
 200 unsigned char digest[16];                         /* message digest */
 201 MD5_CTX *context;                                       /* context */
 202 {
 203   unsigned char bits[8];
 204   unsigned int index, padLen;
 205
 206   /* Save number of bits */
 207   Encode (bits, context->count, 8);
 208
 209   /* Pad out to 56 mod 64.
 210 */
 211   index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 212   padLen = (index < 56) ? (56 - index) : (120 - index);
 213   MD5Update (context, PADDING, padLen);
 214
 215   /* Append length (before padding) */
 216   MD5Update (context, bits, 8);
 217   /* Store state in digest */
 218   Encode (digest, context->state, 16);
 219
 220   /* Zeroize sensitive information.
 221 */
 222   MD5_memset ((POINTER)context, 0, sizeof (*context));
 223 }
 224
 225 /* MD5 basic transformation. Transforms state based on block.
 226  */
 227 static void MD5Transform (state, block)
 228 UINT4 state[4];
 229 unsigned char block[64];
 230 {
 231   UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 232
 233   Decode (x, block, 64);
 234
 235   /* Round 1 */
 236   FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 237   FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 238   FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 239   FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 240   FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 241   FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 242   FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 243   FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 244   FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 245   FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 246   FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 247   FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 248   FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 249   FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 250   FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 251   FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 252
 253  /* Round 2 */
 254   GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 255   GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 256   GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 257   GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 258   GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 259   GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 260   GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 261   GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 262   GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 263   GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 264   GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 265   GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 266   GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 267   GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 268   GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 269   GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 270
 271   /* Round 3 */
 272   HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 273   HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 274   HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 275   HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 276   HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 277   HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 278   HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 279   HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 280   HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 281   HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 282   HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 283   HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 284   HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 285   HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 286   HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 287   HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 288
 289   /* Round 4 */
 290   II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 291   II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 292   II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 293   II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 294   II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 295   II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 296   II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 297   II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 298   II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 299   II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 300   II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 301   II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 302   II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 303   II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 304   II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 305   II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 306
 307   state[0] += a;
 308   state[1] += b;
 309   state[2] += c;
 310   state[3] += d;
 311
 312   /* Zeroize sensitive information.
 313 */
 314   MD5_memset ((POINTER)x, 0, sizeof (x));
 315 }
 316
 317 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
 318   a multiple of 4.
 319  */
 320 static void Encode (output, input, len)
 321 unsigned char *output;
 322 UINT4 *input;
 323 unsigned int len;
 324 {
 325   unsigned int i, j;
 326
 327   for (i = 0, j = 0; j < len; i++, j += 4) {
 328  output[j] = (unsigned char)(input[i] & 0xff);
 329  output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 330  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 331  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 332   }
 333 }
 334
 335 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
 336   a multiple of 4.
 337  */
 338 static void Decode (output, input, len)
 339 UINT4 *output;
 340 unsigned char *input;
 341 unsigned int len;
 342 {
 343   unsigned int i, j;
 344
 345   for (i = 0, j = 0; j < len; i++, j += 4)
 346  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 347    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 348 }
 349
 350 /* Note: Replace "for loop" with standard memcpy if possible.
 351  */
 352
 353 static void MD5_memcpy (output, input, len)
 354 POINTER output;
 355 POINTER input;
 356 unsigned int len;
 357 {
 358   unsigned int i;
 359
 360   for (i = 0; i < len; i++)
 361  output[i] = input[i];
 362 }
 363
 364 /* Note: Replace "for loop" with standard memset if possible.
 365  */
 366 static void MD5_memset (output, value, len)
 367 POINTER output;
 368 int value;
 369 unsigned int len;
 370 {
 371   unsigned int i;
 372
 373   for (i = 0; i < len; i++)
 374  ((char *)output)[i] = (char)value;
 375 }
 376 @
 377
 378
 379 1.3
 380 log
 381 @move location of md5.h
 382 @
 383 text
 384 @d2 1
 385 a2 1
 386 static char md5ident[]="@@(#)$Id: md5.c,v 1.2 1992/03/03 17:09:57 jromine Exp jromine $";
 387 d4 3
 388 a6 7
 389 /*
 390  ***********************************************************************
 391  ** md5.c -- the source code for MD5 routines                         **
 392  ** RSA Data Security, Inc. MD5 Message-Digest Algorithm              **
 393  ** Created: 2/17/90 RLR                                              **
 394  ** Revised: 1/91 SRD,AJ,BSK,JT Reference C ver., 7/10 constant corr. **
 395  ***********************************************************************
 396 d9 20
 397 a28 22
 398 /*
 399  ***********************************************************************
 400  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved.  **
 401  **                                                                   **
 402  ** License to copy and use this software is granted provided that    **
 403  ** it is identified as the "RSA Data Security, Inc. MD5 Message-     **
 404  ** Digest Algorithm" in all material mentioning or referencing this  **
 405  ** software or this function.                                        **
 406  **                                                                   **
 407  ** License is also granted to make and use derivative works          **
 408  ** provided that such works are identified as "derived from the RSA  **
 409  ** Data Security, Inc. MD5 Message-Digest Algorithm" in all          **
 410  ** material mentioning or referencing the derived work.              **
 411  **                                                                   **
 412  ** RSA Data Security, Inc. makes no representations concerning       **
 413  ** either the merchantability of this software or the suitability    **
 414  ** of this software for any particular purpose.  It is provided "as  **
 415  ** is" without express or implied warranty of any kind.              **
 416  **                                                                   **
 417  ** These notices must be retained in any copies of any part of this  **
 418  ** documentation and/or software.                                    **
 419  ***********************************************************************
 420 d31 1
 421 d34 1
 422 a34 9
 423 /*
 424  ***********************************************************************
 425  **  Message-digest routines:                                         **
 426  **  To form the message digest for a message M                       **
 427  **    (1) Initialize a context buffer mdContext using MD5Init        **
 428  **    (2) Call MD5Update on mdContext and M                          **
 429  **    (3) Call MD5Final on mdContext                                 **
 430  **  The message digest is now in mdContext->digest[0...15]           **
 431  ***********************************************************************
 432 d36 16
 433 d53 7
 434 a59 2
 435 /* forward declaration */
 436 static void Transform ();
 437 d62 3
 438 a64 8
 439   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 440   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 441   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 442   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 443   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 444   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 445   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 446   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 447 d67 2
 448 a68 1
 449 /* F, G, H and I are basic MD5 functions */
 450 d74 2
 451 a75 1
 452 /* ROTATE_LEFT rotates x left n bits */
 453 d78 7
 454 a84 6
 455 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
 456 /* Rotation is separate from addition to prevent recomputation */
 457 #define FF(a, b, c, d, x, s, ac) \
 458   {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 459    (a) = ROTATE_LEFT ((a), (s)); \
 460    (a) += (b); \
 461 d86 4
 462 a89 4
 463 #define GG(a, b, c, d, x, s, ac) \
 464   {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 465    (a) = ROTATE_LEFT ((a), (s)); \
 466    (a) += (b); \
 467 d91 4
 468 a94 4
 469 #define HH(a, b, c, d, x, s, ac) \
 470   {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 471    (a) = ROTATE_LEFT ((a), (s)); \
 472    (a) += (b); \
 473 d96 4
 474 a99 4
 475 #define II(a, b, c, d, x, s, ac) \
 476   {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 477    (a) = ROTATE_LEFT ((a), (s)); \
 478    (a) += (b); \
 479 d102 1
 480 a102 2
 481 /* The routine MD5Init initializes the message-digest context
 482    mdContext. All fields are set to zero.
 483 d104 2
 484 a105 2
 485 void MD5Init (mdContext)
 486 MD5_CTX *mdContext;
 487 d107 1
 488 a107 2
 489   mdContext->i[0] = mdContext->i[1] = (UINT4)0;
 490
 491 d109 5
 492 a113 5
 493    */
 494   mdContext->buf[0] = (UINT4)0x67452301;
 495   mdContext->buf[1] = (UINT4)0xefcdab89;
 496   mdContext->buf[2] = (UINT4)0x98badcfe;
 497   mdContext->buf[3] = (UINT4)0x10325476;
 498 d116 3
 499 a118 3
 500 /* The routine MD5Update updates the message-digest context to
 501    account for the presence of each of the characters inBuf[0..inLen-1]
 502    in the message whose digest is being computed.
 503 d120 4
 504 a123 4
 505 void MD5Update (mdContext, inBuf, inLen)
 506 MD5_CTX *mdContext;
 507 unsigned char *inBuf;
 508 unsigned int inLen;
 509 d125 1
 510 a125 3
 511   UINT4 in[16];
 512   int mdi;
 513   unsigned int i, ii;
 514 d127 2
 515 a128 2
 516   /* compute number of bytes mod 64 */
 517   mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
 518 d130 5
 519 a134 5
 520   /* update number of bits */
 521   if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
 522     mdContext->i[1]++;
 523   mdContext->i[0] += ((UINT4)inLen << 3);
 524   mdContext->i[1] += ((UINT4)inLen >> 29);
 525 d136 1
 526 a136 3
 527   while (inLen--) {
 528     /* add new character to buffer, increment mdi */
 529     mdContext->in[mdi++] = *inBuf++;
 530 d138 11
 531 a148 10
 532     /* transform if necessary */
 533     if (mdi == 0x40) {
 534       for (i = 0, ii = 0; i < 16; i++, ii += 4)
 535         in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
 536                 (((UINT4)mdContext->in[ii+2]) << 16) |
 537                 (((UINT4)mdContext->in[ii+1]) << 8) |
 538                 ((UINT4)mdContext->in[ii]);
 539       Transform (mdContext->buf, in);
 540       mdi = 0;
 541     }
 542 d150 7
 543 d159 2
 544 a160 2
 545 /* The routine MD5Final terminates the message-digest computation and
 546    ends with the desired message digest in mdContext->digest[0...15].
 547 d162 3
 548 a164 2
 549 void MD5Final (mdContext)
 550 MD5_CTX *mdContext;
 551 d166 2
 552 a167 4
 553   UINT4 in[16];
 554   int mdi;
 555   unsigned int i, ii;
 556   unsigned int padLen;
 557 d169 2
 558 a170 3
 559   /* save number of bits */
 560   in[14] = mdContext->i[0];
 561   in[15] = mdContext->i[1];
 562 d172 5
 563 a176 2
 564   /* compute number of bytes mod 64 */
 565   mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
 566 d178 4
 567 a181 3
 568   /* pad out to 56 mod 64 */
 569   padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
 570   MD5Update (mdContext, PADDING, padLen);
 571 d183 3
 572 a185 18
 573   /* append length in bits and transform */
 574   for (i = 0, ii = 0; i < 14; i++, ii += 4)
 575     in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
 576             (((UINT4)mdContext->in[ii+2]) << 16) |
 577             (((UINT4)mdContext->in[ii+1]) << 8) |
 578             ((UINT4)mdContext->in[ii]);
 579   Transform (mdContext->buf, in);
 580
 581   /* store buffer in digest */
 582   for (i = 0, ii = 0; i < 4; i++, ii += 4) {
 583     mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
 584     mdContext->digest[ii+1] =
 585       (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
 586     mdContext->digest[ii+2] =
 587       (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
 588     mdContext->digest[ii+3] =
 589       (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
 590   }
 591 d188 1
 592 a188 1
 593 /* Basic MD5 step. Transforms buf based on in.
 594 d190 3
 595 a192 3
 596 static void Transform (buf, in)
 597 UINT4 *buf;
 598 UINT4 *in;
 599 d194 1
 600 a194 1
 601   UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
 602 d196 2
 603 d199 16
 604 a214 20
 605 #define S11 7
 606 #define S12 12
 607 #define S13 17
 608 #define S14 22
 609   FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */
 610   FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */
 611   FF ( c, d, a, b, in[ 2], S13,  606105819); /* 3 */
 612   FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */
 613   FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */
 614   FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */
 615   FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */
 616   FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */
 617   FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */
 618   FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */
 619   FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */
 620   FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */
 621   FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */
 622   FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */
 623   FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */
 624   FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */
 625 d216 17
 626 a232 21
 627   /* Round 2 */
 628 #define S21 5
 629 #define S22 9
 630 #define S23 14
 631 #define S24 20
 632   GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */
 633   GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */
 634   GG ( c, d, a, b, in[11], S23,  643717713); /* 19 */
 635   GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */
 636   GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */
 637   GG ( d, a, b, c, in[10], S22,   38016083); /* 22 */
 638   GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */
 639   GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */
 640   GG ( a, b, c, d, in[ 9], S21,  568446438); /* 25 */
 641   GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */
 642   GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */
 643   GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */
 644   GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */
 645   GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */
 646   GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */
 647   GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */
 648 d235 16
 649 a250 20
 650 #define S31 4
 651 #define S32 11
 652 #define S33 16
 653 #define S34 23
 654   HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */
 655   HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */
 656   HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */
 657   HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */
 658   HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */
 659   HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */
 660   HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */
 661   HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */
 662   HH ( a, b, c, d, in[13], S31,  681279174); /* 41 */
 663   HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */
 664   HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */
 665   HH ( b, c, d, a, in[ 6], S34,   76029189); /* 44 */
 666   HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */
 667   HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */
 668   HH ( c, d, a, b, in[15], S33,  530742520); /* 47 */
 669   HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */
 670 d253 16
 671 a268 20
 672 #define S41 6
 673 #define S42 10
 674 #define S43 15
 675 #define S44 21
 676   II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */
 677   II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */
 678   II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */
 679   II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */
 680   II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */
 681   II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */
 682   II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */
 683   II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */
 684   II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */
 685   II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */
 686   II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */
 687   II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */
 688   II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */
 689   II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */
 690   II ( c, d, a, b, in[ 2], S43,  718787259); /* 63 */
 691   II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */
 692 d270 8
 693 a277 4
 694   buf[0] += a;
 695   buf[1] += b;
 696   buf[2] += c;
 697   buf[3] += d;
 698 d280 2
 699 a281 4
 700 /*
 701  ***********************************************************************
 702  ** End of md5.c                                                      **
 703  ******************************** (cut) ********************************
 704 d283 56
 705 @
 706
 707
 708 1.2
 709 log
 710 @fixes from mtr
 711 @
 712 text
 713 @d2 1
 714 a2 1
 715 static char md5ident[]="@@(#)$Id: md5.c,v 1.1 1992/02/11 05:16:13 jromine Exp jromine $";
 716 d37 1
 717 a37 1
 718 #include "md5.h"
 719 @
 720
 721
 722 1.1
 723 log
 724 @Initial revision
 725 @
 726 text
 727 @d2 1
 728 a2 1
 729 static char ident[]="@@(#)$Id: popser.c,v 1.22 1992/02/10 22:35:58 jromine Exp $";
 730 @