9 date 92.10.26.16.48.02; author jromine; state Exp;
14 date 92.10.20.22.45.05; author jromine; state Exp;
19 date 92.03.03.17.09.57; author jromine; state Exp;
24 date 92.02.11.05.16.13; author jromine; state Exp;
35 @MD5 API changes (from MTR)
39 static char md5ident[]="@@(#)$Id: md5.c,v 1.3 1992/10/20 22:45:05 jromine Exp jromine $";
41 /* taken from RFC-1321/Appendix A.3 */
43 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
46 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
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
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.
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.
64 These notices must be retained in any copies of any part of this
65 documentation and/or software.
68 /* #include "global.h" */
71 /* Constants for MD5Transform routine.
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));
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
104 /* F, G, H and I are basic MD5 functions.
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)))
111 /* ROTATE_LEFT rotates x left n bits.
113 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
115 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
116 Rotation is separate from addition to prevent recomputation.
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)); \
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)); \
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)); \
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)); \
139 /* MD5 initialization. Begins an MD5 operation, writing a new context.
141 void MD5Init (context)
142 MD5_CTX *context; /* context */
144 context->count[0] = context->count[1] = 0;
145 /* Load magic initialization constants.
147 context->state[0] = 0x67452301;
148 context->state[1] = 0xefcdab89;
149 context->state[2] = 0x98badcfe;
150 context->state[3] = 0x10325476;
153 /* MD5 block update operation. Continues an MD5 message-digest
154 operation, processing another message block, and updating the
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 */
162 unsigned int i, index, partLen;
164 /* Compute number of bytes mod 64 */
165 index = (unsigned int)((context->count[0] >> 3) & 0x3F);
167 /* Update number of bits */
168 if ((context->count[0] += ((UINT4)inputLen << 3))
169 < ((UINT4)inputLen << 3))
171 context->count[1] += ((UINT4)inputLen >> 29);
173 partLen = 64 - index;
175 /* Transform as many times as possible.
177 if (inputLen >= partLen) {
179 ((POINTER)&context->buffer[index], (POINTER)input, partLen);
180 MD5Transform (context->state, context->buffer);
182 for (i = partLen; i + 63 < inputLen; i += 64)
183 MD5Transform (context->state, &input[i]);
190 /* Buffer remaining input */
192 ((POINTER)&context->buffer[index], (POINTER)&input[i],
196 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
197 the message digest and zeroizing the context.
199 void MD5Final (digest, context)
200 unsigned char digest[16]; /* message digest */
201 MD5_CTX *context; /* context */
203 unsigned char bits[8];
204 unsigned int index, padLen;
206 /* Save number of bits */
207 Encode (bits, context->count, 8);
209 /* Pad out to 56 mod 64.
211 index = (unsigned int)((context->count[0] >> 3) & 0x3f);
212 padLen = (index < 56) ? (56 - index) : (120 - index);
213 MD5Update (context, PADDING, padLen);
215 /* Append length (before padding) */
216 MD5Update (context, bits, 8);
217 /* Store state in digest */
218 Encode (digest, context->state, 16);
220 /* Zeroize sensitive information.
222 MD5_memset ((POINTER)context, 0, sizeof (*context));
225 /* MD5 basic transformation. Transforms state based on block.
227 static void MD5Transform (state, block)
229 unsigned char block[64];
231 UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
233 Decode (x, block, 64);
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 */
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 */
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 */
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 */
312 /* Zeroize sensitive information.
314 MD5_memset ((POINTER)x, 0, sizeof (x));
317 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
320 static void Encode (output, input, len)
321 unsigned char *output;
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);
335 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
338 static void Decode (output, input, len)
340 unsigned char *input;
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);
350 /* Note: Replace "for loop" with standard memcpy if possible.
353 static void MD5_memcpy (output, input, len)
360 for (i = 0; i < len; i++)
361 output[i] = input[i];
364 /* Note: Replace "for loop" with standard memset if possible.
366 static void MD5_memset (output, value, len)
373 for (i = 0; i < len; i++)
374 ((char *)output)[i] = (char)value;
381 @move location of md5.h
386 static char md5ident[]="@@(#)$Id: md5.c,v 1.2 1992/03/03 17:09:57 jromine Exp jromine $";
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 ***********************************************************************
399 ***********************************************************************
400 ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
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. **
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. **
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. **
417 ** These notices must be retained in any copies of any part of this **
418 ** documentation and/or software. **
419 ***********************************************************************
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 ***********************************************************************
435 /* forward declaration */
436 static void Transform ();
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
449 /* F, G, H and I are basic MD5 functions */
452 /* ROTATE_LEFT rotates x left n bits */
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)); \
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)); \
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)); \
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)); \
481 /* The routine MD5Init initializes the message-digest context
482 mdContext. All fields are set to zero.
485 void MD5Init (mdContext)
489 mdContext->i[0] = mdContext->i[1] = (UINT4)0;
494 mdContext->buf[0] = (UINT4)0x67452301;
495 mdContext->buf[1] = (UINT4)0xefcdab89;
496 mdContext->buf[2] = (UINT4)0x98badcfe;
497 mdContext->buf[3] = (UINT4)0x10325476;
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.
505 void MD5Update (mdContext, inBuf, inLen)
507 unsigned char *inBuf;
516 /* compute number of bytes mod 64 */
517 mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
520 /* update number of bits */
521 if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
523 mdContext->i[0] += ((UINT4)inLen << 3);
524 mdContext->i[1] += ((UINT4)inLen >> 29);
528 /* add new character to buffer, increment mdi */
529 mdContext->in[mdi++] = *inBuf++;
532 /* transform if necessary */
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);
545 /* The routine MD5Final terminates the message-digest computation and
546 ends with the desired message digest in mdContext->digest[0...15].
549 void MD5Final (mdContext)
559 /* save number of bits */
560 in[14] = mdContext->i[0];
561 in[15] = mdContext->i[1];
564 /* compute number of bytes mod 64 */
565 mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
568 /* pad out to 56 mod 64 */
569 padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
570 MD5Update (mdContext, PADDING, padLen);
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);
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);
593 /* Basic MD5 step. Transforms buf based on in.
596 static void Transform (buf, in)
601 UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
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 */
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 */
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 */
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 */
701 ***********************************************************************
703 ******************************** (cut) ********************************
715 static char md5ident[]="@@(#)$Id: md5.c,v 1.1 1992/02/11 05:16:13 jromine Exp jromine $";
729 static char ident[]="@@(#)$Id: popser.c,v 1.22 1992/02/10 22:35:58 jromine Exp $";