开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > TCP/IP协议栈 > 查看源码
md5c.c
资源名称：export.zip　[点击查看]
上传用户：hepax88
上传日期：2007-01-03
资源大小：1101k
文件大小：18k
源码类别：

TCP/IP协议栈

开发平台：

Visual C++

md5c.c：源码内容
  1. /* MD5.C - RSA Data Security, Inc., MD5 message-digest algorithm */
  3. #include <mem.h>
  5. #ifdef CPU386
  6. #pragma inline
  7. #endif
  9. #ifndef NULL
  10. #define NULL (void *)0
  11. #endif
  13. /* This version taken from RSAREF 2.0 and modified for use
  14.  * under Borland C++ with DOS by Phil Karn, KA9Q, September 1994.
  15.  * The changes include the replacement of MD5_memset() and MD5_memcpy()
  16.  * with calls to memset() and memcpy(), and the inclusion of an optional
  17.  * 386/486 inline assembler version of MD5Transform().
  18.  *
  19.  * The 386/486 assembler version of MD5Transform() included here was previously
  20.  * released on 22 Feb 1992 with an earlier version of md5.c from RSA;
  21.  * it has been modified here to suit the different
  22.  * internal calling conventions subsequently adopted by RSA.
  23.  */
  25. /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  26.    rights reserved.
  28.    License to copy and use this software is granted provided that it
  29.    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
  30.    Algorithm" in all material mentioning or referencing this software
  31.    or this function.
  33.    License is also granted to make and use derivative works provided
  34.    that such works are identified as "derived from the RSA Data
  35.    Security, Inc. MD5 Message-Digest Algorithm" in all material
  36.    mentioning or referencing the derived work.  
  37.                                                                     
  38.    RSA Data Security, Inc. makes no representations concerning either
  39.    the merchantability of this software or the suitability of this
  40.    software for any particular purpose. It is provided "as is"
  41.    without express or implied warranty of any kind.  
  42.                                                                     
  43.    These notices must be retained in any copies of any part of this
  44.    documentation and/or software.  
  45.  */
  47. /*#include "global.h" */
  48. #include "md5.h"
  50. /* Constants for MD5Transform routine.
  51.  */
  52. #define S11 7
  53. #define S12 12
  54. #define S13 17
  55. #define S14 22
  56. #define S21 5
  57. #define S22 9
  58. #define S23 14
  59. #define S24 20
  60. #define S31 4
  61. #define S32 11
  62. #define S33 16
  63. #define S34 23
  64. #define S41 6
  65. #define S42 10
  66. #define S43 15
  67. #define S44 21
  69. static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
  70. static void Encode PROTO_LIST
  71.   ((unsigned char *, UINT4 *, unsigned int));
  72. #ifndef CPU386
  73. static void Decode PROTO_LIST
  74.   ((UINT4 *, unsigned char *, unsigned int));
  75. #endif
  77. static unsigned char PADDING[64] = {
  78.   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  79.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  80.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  81. };
  83. #ifndef CPU386
  85. /* F, G, H and I are basic MD5 functions.
  86.  */
  87. #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  88. #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  89. #define H(x, y, z) ((x) ^ (y) ^ (z))
  90. #define I(x, y, z) ((y) ^ ((x) | (~z)))
  92. /* ROTATE_LEFT rotates x left n bits.
  93.  */
  94. #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  96. /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
  97.    Rotation is separate from addition to prevent recomputation.
  98.  */
  99. #define FF(a, b, c, d, x, s, ac) { 
  100.     (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); 
  101.     (a) = ROTATE_LEFT ((a), (s)); 
  102.     (a) += (b); 
  103.   }
  104. #define GG(a, b, c, d, x, s, ac) { 
  105.     (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); 
  106.     (a) = ROTATE_LEFT ((a), (s)); 
  107.     (a) += (b); 
  108.   }
  109. #define HH(a, b, c, d, x, s, ac) { 
  110.     (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); 
  111.     (a) = ROTATE_LEFT ((a), (s)); 
  112.     (a) += (b); 
  113.   }
  114. #define II(a, b, c, d, x, s, ac) { 
  115.     (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); 
  116.     (a) = ROTATE_LEFT ((a), (s)); 
  117.     (a) += (b); 
  118.   }
  119. #endif
  121. /* MD5 initialization. Begins an MD5 operation, writing a new context.
  122.  */
  123. void MD5Init (context)
  124. MD5_CTX *context;                                        /* context */
  125. {
  126.   context->count[0] = context->count[1] = 0;
  128.   /* Load magic initialization constants.
  129.    */
  130.   context->state[0] = 0x67452301;
  131.   context->state[1] = 0xefcdab89;
  132.   context->state[2] = 0x98badcfe;
  133.   context->state[3] = 0x10325476;
  134. }
  136. /* MD5 block update operation. Continues an MD5 message-digest
  137.      operation, processing another message block, and updating the
  138.      context.
  139.  * Rewritten to better optimize the common case when MD5Update()
  140.  * is only called with multiples of 64 bytes (e.g., when hashing
  141.  * a stdio buffer) - PRK
  142.  */
  143. void MD5Update (context, input, inputLen)
  144. MD5_CTX *context;                                        /* context */
  145. unsigned char *input;                                /* input block */
  146. unsigned int inputLen;                     /* length of input block */
  147. {
  148.   unsigned int i, index, partLen;
  150.   /* Compute number of bytes mod 64 */
  151.   index = (unsigned int)((context->count[0] >> 3) & 0x3F);
  153.   /* Update number of bits */
  154.   if ((context->count[0] += ((UINT4)inputLen << 3))
  155.       < ((UINT4)inputLen << 3))
  156.     context->count[1]++;
  157.   context->count[1] += ((UINT4)inputLen >> 29);
  158.   
  159.   if(index != 0){
  160. /* Complete the partial buffer first */
  161. partLen = 64 - index; /* room left in buffer */
  162. i = inputLen > partLen ? partLen : inputLen; /* min(room,data) */
  163. memcpy(&context->buffer[index],input,i);
  164. input += i;
  165. inputLen -= i;
  166. if(i == partLen){
  167. /* Buffer now full, hash it */
  168. MD5Transform(context->state,context->buffer);
  169. } else
  170. return; /* Not yet full */
  171.   }
  172.   /* Now do as many 64 byte chunks direct from the input as possible */
  173.   while(inputLen >= 64){
  174. MD5Transform(context->state,input);
  175. input += 64;
  176. inputLen -= 64;
  177.   }
  178.   /* Now buffer any remaining input */
  179.   if(inputLen > 0)
  180. memcpy(context->buffer,input,inputLen);
  181. }
  183. /* MD5 finalization. Ends an MD5 message-digest operation, writing the
  184.      the message digest and zeroizing the context.
  185.  */
  186. void MD5Final (digest, context)
  187. unsigned char digest[16];                         /* message digest */
  188. MD5_CTX *context;                                       /* context */
  189. {
  190.   unsigned char bits[8];
  191.   unsigned int index, padLen;
  193.   /* Save number of bits */
  194.   Encode (bits, context->count, 8);
  196.   /* Pad out to 56 mod 64.
  197.    */
  198.   index = (unsigned int)((context->count[0] >> 3) & 0x3f);
  199.   padLen = (index < 56) ? (56 - index) : (120 - index);
  200.   MD5Update (context, PADDING, padLen);
  201.   
  202.   /* Append length (before padding) */
  203.   MD5Update (context, bits, 8);
  205.   if(digest != NULL){ /* Bill Simpson's change to simplify AH */
  206.   /* Store state in digest */
  207.   Encode (digest, context->state, 16);
  208.   
  209.   /* Zeroize sensitive information. */
  210.   memset ((POINTER)context, 0, sizeof (*context));
  211.   }
  212. }
  214. #ifndef CPU386 /* Not used; an asm version is available for the 386/486 */
  216. /* MD5 basic transformation. Transforms state based on block.
  217.  */
  218. static void MD5Transform (state, block)
  219. UINT4 state[4];
  220. unsigned char block[64];
  221. {
  222.   UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
  223.   
  224.   Decode (x, block, 64);
  226.   /* Round 1 */
  227.   FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
  228.   FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
  229.   FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
  230.   FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
  231.   FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
  232.   FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
  233.   FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
  234.   FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
  235.   FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
  236.   FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
  237.   FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
  238.   FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
  239.   FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
  240.   FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
  241.   FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
  242.   FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
  244.   /* Round 2 */
  245.   GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
  246.   GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
  247.   GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
  248.   GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
  249.   GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
  250.   GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
  251.   GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
  252.   GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
  253.   GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
  254.   GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
  255.   GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
  256.   GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
  257.   GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
  258.   GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
  259.   GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
  260.   GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
  262.   /* Round 3 */
  263.   HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
  264.   HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
  265.   HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
  266.   HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
  267.   HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
  268.   HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
  269.   HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
  270.   HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
  271.   HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
  272.   HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
  273.   HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
  274.   HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
  275.   HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
  276.   HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
  277.   HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
  278.   HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
  280.   /* Round 4 */
  281.   II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
  282.   II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
  283.   II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
  284.   II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
  285.   II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
  286.   II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
  287.   II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
  288.   II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
  289.   II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
  290.   II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
  291.   II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
  292.   II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
  293.   II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
  294.   II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
  295.   II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
  296.   II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
  298.   state[0] += a;
  299.   state[1] += b;
  300.   state[2] += c;
  301.   state[3] += d;
  302.   
  303.   /* Zeroize sensitive information.
  304.    */
  305.   memset ((POINTER)x, 0, sizeof (x));
  306. }
  308. #endif
  310. /* Encodes input (UINT4) into output (unsigned char). Assumes len is
  311.      a multiple of 4.
  312.  */
  313. static void Encode (output, input, len)
  314. unsigned char *output;
  315. UINT4 *input;
  316. unsigned int len;
  317. {
  318.   unsigned int i, j;
  320.   for (i = 0, j = 0; j < len; i++, j += 4) {
  321.     output[j] = (unsigned char)(input[i] & 0xff);
  322.     output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
  323.     output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
  324.     output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
  325.   }
  326. }
  328. #ifndef CPU386 /* Not needed in assembler version */
  329. /* Decodes input (unsigned char) into output (UINT4). Assumes len is
  330.      a multiple of 4.
  331.  */
  332. static void Decode (output, input, len)
  333. UINT4 *output;
  334. unsigned char *input;
  335. unsigned int len;
  336. {
  337.   unsigned int i, j;
  339.   for (i = 0, j = 0; j < len; i++, j += 4)
  340.     output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
  341.       (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
  342. }
  343. #else /* CPU386 */
  344. /* Fast 386 Borland C inline assembler version of the transform() function
  345.  * from the RSA Data Security, Inc, MD5 Message Digest Algorithm.
  346.  *
  347.  * This version uses native 32 bit registers, so it needs a 386 or 486 CPU.
  348.  * It also assumes large model (-ml)
  349.  *
  350.  * Because this function does *lots* of 32-bit operations, this version is
  351.  * MUCH faster than the reference C version compiled with a garden-
  352.  * variety 16-bit MS-DOS C compiler.
  353.  *
  354.  * Originally written and placed into the public domain on
  355.  * 22 February 1992 by Phil Karn, KA9Q
  356.  *
  357.  * Updated 1 Sept 1994 by Phil Karn to match newer version of MD5.C released
  358.  * in the RSAREF package. Also changed some register assignments to get rid
  359.  * of the segment override prefixes on memory references
  360.  */
  363. /* Code sequence common to all four rounds.
  364.  * evaluates a = b + (a + edi + x + t) <<< s
  365.  * where it is assumed a and b are registers, x is a memory location,
  366.  * edi is the edi register, and s and t are integer constants
  367.  */
  368. #define COM(a,b,x,s,t)
  369. lea a,t[a+edi];
  370. add a,x;
  371. rol a,s;
  372. add a,b;
  374. /* Round 1 functions */
  375. /* edi = F(x,y,z) = (x & y) | (~x & z) */
  376. #define F(x,y,z)
  377. mov edi,x;
  378. and edi,y;
  379. mov ebp,x;
  380. not ebp;
  381. and ebp,z;
  382. or edi,ebp
  384. /* a = b + ((a + F(b,c,d) + x + t) <<< s); */
  385. #define FF(a,b,c,d,x,s,t)
  386. F(b,c,d);
  387. COM(a,b,x,s,t)
  389. /* Round 2 functions */
  390. /* edi = G(x,y,z) = F(z,x,y) = (x & z) | (y & ~z) */
  391. #define G(x,y,z) F(z,x,y)
  393. /* a = b + ((a + G(b,c,d) + x + t) <<< s) */
  394. #define GG(a,b,c,d,x,s,t)
  395. G(b,c,d);
  396. COM(a,b,x,s,t)
  398. /* Round 3 functions */
  399. /* edi = H(x,y,z) = x ^ y ^ z */
  400. #define H(x,y,z)
  401. mov edi,x;
  402. xor edi,y;
  403. xor edi,z
  405. /* a = b + ((a + H(b,c,d) + x + t) <<< s) */
  406. #define HH(a,b,c,d,x,s,t)
  407. H(b,c,d);
  408. COM(a,b,x,s,t)
  410. /* Round 4 functions */
  411. /* edi = I(x,y,z) = y ^ (x | ~z) */
  412. #define I(x,y,z)
  413. mov edi,z;
  414. not edi;
  415. or edi,x;
  416. xor edi,y
  418. /* a = b + ((a + I(b,c,d) + x + t) <<< s) */
  419. #define II(a,b,c,d,x,s,t)
  420. I(b,c,d);
  421. COM(a,b,x,s,t)
  423. /* Register assignments */
  424. #define A eax
  425. #define B ebx
  426. #define C ecx
  427. #define D edx
  429. static void
  430. MD5Transform (state, block)
  431. UINT4 state[4];
  432. unsigned char block[64];
  433. {
  434. asm {
  436. /* Save caller's registers */
  437. push si;
  438. push edi;
  439. push ds;
  441. lds si,state; /* Read input state */
  443. mov A,dword ptr si[0*4]; /* A = state[0] */
  444. mov B,dword ptr si[1*4]; /* B = state[1] */
  445. mov C,dword ptr si[2*4]; /* C = state[2] */
  446. mov D,dword ptr si[3*4]; /* D = state[3] */
  448. lds si,block; /* Set up for data block read */
  450. /* The FF macro uses ebp as scratch. This makes our args
  451.  * inaccessible until it is restored!
  452.  */
  453. push ebp;
  455. /* Round 1. The *4 factors in the subscripts to si account for the
  456.  * byte offsets of each long element in the input array. The input
  457.  * is actually a byte array, but we can treat it directly as a long
  458.  * array because MD5 is little-endian, like the 386/486.
  459.  *
  460.  * The only hazard is if the input buffer isn't 32-bit aligned,
  461.  * things will run a little more slowly.
  462.  */
  463. FF(A,B,C,D,si[ 0*4],S11,3614090360); /* 1 */
  464. FF(D,A,B,C,si[ 1*4],S12,3905402710); /* 2 */
  465. FF(C,D,A,B,si[ 2*4],S13, 606105819); /* 3 */
  466. FF(B,C,D,A,si[ 3*4],S14,3250441966); /* 4 */
  467. FF(A,B,C,D,si[ 4*4],S11,4118548399); /* 5 */
  468. FF(D,A,B,C,si[ 5*4],S12,1200080426); /* 6 */
  469. FF(C,D,A,B,si[ 6*4],S13,2821735955); /* 7 */
  470. FF(B,C,D,A,si[ 7*4],S14,4249261313); /* 8 */
  471. FF(A,B,C,D,si[ 8*4],S11,1770035416); /* 9 */
  472. FF(D,A,B,C,si[ 9*4],S12,2336552879); /* 10 */
  473. FF(C,D,A,B,si[10*4],S13,4294925233); /* 11 */
  474. FF(B,C,D,A,si[11*4],S14,2304563134); /* 12 */
  475. FF(A,B,C,D,si[12*4],S11,1804603682); /* 13 */
  476. FF(D,A,B,C,si[13*4],S12,4254626195); /* 14 */
  477. FF(C,D,A,B,si[14*4],S13,2792965006); /* 15 */
  478. FF(B,C,D,A,si[15*4],S14,1236535329); /* 16 */
  480. /* Round 2 */
  481. GG(A,B,C,D,si[ 1*4],S21,4129170786); /* 17 */
  482. GG(D,A,B,C,si[ 6*4],S22,3225465664); /* 18 */
  483. GG(C,D,A,B,si[11*4],S23, 643717713); /* 19 */
  484. GG(B,C,D,A,si[ 0*4],S24,3921069994); /* 20 */
  485. GG(A,B,C,D,si[ 5*4],S21,3593408605); /* 21 */
  486. GG(D,A,B,C,si[10*4],S22,  38016083); /* 22 */
  487. GG(C,D,A,B,si[15*4],S23,3634488961); /* 23 */
  488. GG(B,C,D,A,si[ 4*4],S24,3889429448); /* 24 */
  489. GG(A,B,C,D,si[ 9*4],S21, 568446438); /* 25 */
  490. GG(D,A,B,C,si[14*4],S22,3275163606); /* 26 */
  491. GG(C,D,A,B,si[ 3*4],S23,4107603335); /* 27 */
  492. GG(B,C,D,A,si[ 8*4],S24,1163531501); /* 28 */
  493. GG(A,B,C,D,si[13*4],S21,2850285829); /* 29 */
  494. GG(D,A,B,C,si[ 2*4],S22,4243563512); /* 30 */
  495. GG(C,D,A,B,si[ 7*4],S23,1735328473); /* 31 */
  496. GG(B,C,D,A,si[12*4],S24,2368359562); /* 32 */
  498. /* Round 3 */
  499. HH(A,B,C,D,si[ 5*4],S31,4294588738); /* 33 */
  500. HH(D,A,B,C,si[ 8*4],S32,2272392833); /* 34 */
  501. HH(C,D,A,B,si[11*4],S33,1839030562); /* 35 */
  502. HH(B,C,D,A,si[14*4],S34,4259657740); /* 36 */
  503. HH(A,B,C,D,si[ 1*4],S31,2763975236); /* 37 */
  504. HH(D,A,B,C,si[ 4*4],S32,1272893353); /* 38 */
  505. HH(C,D,A,B,si[ 7*4],S33,4139469664); /* 39 */
  506. HH(B,C,D,A,si[10*4],S34,3200236656); /* 40 */
  507. HH(A,B,C,D,si[13*4],S31, 681279174); /* 41 */
  508. HH(D,A,B,C,si[ 0*4],S32,3936430074); /* 42 */
  509. HH(C,D,A,B,si[ 3*4],S33,3572445317); /* 43 */
  510. HH(B,C,D,A,si[ 6*4],S34,  76029189); /* 44 */
  511. HH(A,B,C,D,si[ 9*4],S31,3654602809); /* 45 */
  512. HH(D,A,B,C,si[12*4],S32,3873151461); /* 46 */
  513. HH(C,D,A,B,si[15*4],S33, 530742520); /* 47 */
  514. HH(B,C,D,A,si[ 2*4],S34,3299628645); /* 48 */
  516. /* Round 4 */
  517. II(A,B,C,D,si[ 0*4],S41,4096336452); /* 49 */
  518. II(D,A,B,C,si[ 7*4],S42,1126891415); /* 50 */
  519. II(C,D,A,B,si[14*4],S43,2878612391); /* 51 */
  520. II(B,C,D,A,si[ 5*4],S44,4237533241); /* 52 */
  521. II(A,B,C,D,si[12*4],S41,1700485571); /* 53 */
  522. II(D,A,B,C,si[ 3*4],S42,2399980690); /* 54 */
  523. II(C,D,A,B,si[10*4],S43,4293915773); /* 55 */
  524. II(B,C,D,A,si[ 1*4],S44,2240044497); /* 56 */
  525. II(A,B,C,D,si[ 8*4],S41,1873313359); /* 57 */
  526. II(D,A,B,C,si[15*4],S42,4264355552); /* 58 */
  527. II(C,D,A,B,si[ 6*4],S43,2734768916); /* 59 */
  528. II(B,C,D,A,si[13*4],S44,1309151649); /* 60 */
  529. II(A,B,C,D,si[ 4*4],S41,4149444226); /* 61 */
  530. II(D,A,B,C,si[11*4],S42,3174756917); /* 62 */
  531. II(C,D,A,B,si[ 2*4],S43, 718787259); /* 63 */
  532. II(B,C,D,A,si[ 9*4],S44,3951481745); /* 64 */
  534. pop ebp; /* We can address our args again */
  536. lds si,state; /* Update the caller's state */
  537. add dword ptr si[0*4],A; /* state[0] += A */
  538. add dword ptr si[1*4],B; /* state[1] += B */
  539. add dword ptr si[2*4],C; /* state[2] += C */
  540. add dword ptr si[3*4],D; /* state[3] += D */
  542. /* Restore caller's registers */
  543. pop ds;
  544. pop edi;
  545. pop si;
  546. }
  547. }
  548. #endif /* CPU386 */