testing/md5.c

   1 /*\r
   2  **********************************************************************\r
   3  ** md5.c                                                            **\r
   4  ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **\r
   5  ** Created: 2/17/90 RLR                                             **\r
   6  ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version                  **\r
   7  **********************************************************************\r
   8  */\r
   9 \r
  10 /*\r
  11  **********************************************************************\r
  12  ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **\r
  13  **                                                                  **\r
  14  ** License to copy and use this software is granted provided that   **\r
  15  ** it is identified as the "RSA Data Security, Inc. MD5 Message     **\r
  16  ** Digest Algorithm" in all material mentioning or referencing this **\r
  17  ** software or this function.                                       **\r
  18  **                                                                  **\r
  19  ** License is also granted to make and use derivative works         **\r
  20  ** provided that such works are identified as "derived from the RSA **\r
  21  ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **\r
  22  ** material mentioning or referencing the derived work.             **\r
  23  **                                                                  **\r
  24  ** RSA Data Security, Inc. makes no representations concerning      **\r
  25  ** either the merchantability of this software or the suitability   **\r
  26  ** of this software for any particular purpose.  It is provided "as **\r
  27  ** is" without express or implied warranty of any kind.             **\r
  28  **                                                                  **\r
  29  ** These notices must be retained in any copies of any part of this **\r
  30  ** documentation and/or software.                                   **\r
  31  **********************************************************************\r
  32  */\r
  33 \r
  34 /* -- include the following line if the md5.h header file is separate -- */\r
  35 #include "md5.h" \r
  36 \r
  37 /* forward declaration */\r
  38 static void Transform ();\r
  39 \r
  40 static unsigned char PADDING[64] = {\r
  41   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  42   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  43   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  44   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  45   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  46   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  47   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  48   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00\r
  49 };\r
  50 \r
  51 /* F, G and H are basic MD5 functions: selection, majority, parity */\r
  52 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))\r
  53 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))\r
  54 #define H(x, y, z) ((x) ^ (y) ^ (z))\r
  55 #define I(x, y, z) ((y) ^ ((x) | (~z))) \r
  56 \r
  57 /* ROTATE_LEFT rotates x left n bits */\r
  58 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))\r
  59 \r
  60 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */\r
  61 /* Rotation is separate from addition to prevent recomputation */\r
  62 #define FF(a, b, c, d, x, s, ac) \\r
  63   {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \\r
  64    (a) = ROTATE_LEFT ((a), (s)); \\r
  65    (a) += (b); \\r
  66   }\r
  67 #define GG(a, b, c, d, x, s, ac) \\r
  68   {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \\r
  69    (a) = ROTATE_LEFT ((a), (s)); \\r
  70    (a) += (b); \\r
  71   }\r
  72 #define HH(a, b, c, d, x, s, ac) \\r
  73   {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \\r
  74    (a) = ROTATE_LEFT ((a), (s)); \\r
  75    (a) += (b); \\r
  76   }\r
  77 #define II(a, b, c, d, x, s, ac) \\r
  78   {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \\r
  79    (a) = ROTATE_LEFT ((a), (s)); \\r
  80    (a) += (b); \\r
  81   }\r
  82 \r
  83 void MD5Init (mdContext)\r
  84 MD5_CTX *mdContext;\r
  85 {\r
  86   mdContext->i[0] = mdContext->i[1] = (UINT4)0;\r
  87 \r
  88   /* Load magic initialization constants.\r
  89    */\r
  90   mdContext->buf[0] = (UINT4)0x67452301;\r
  91   mdContext->buf[1] = (UINT4)0xefcdab89;\r
  92   mdContext->buf[2] = (UINT4)0x98badcfe;\r
  93   mdContext->buf[3] = (UINT4)0x10325476;\r
  94 }\r
  95 \r
  96 void MD5Update (mdContext, inBuf, inLen)\r
  97 MD5_CTX *mdContext;\r
  98 unsigned char *inBuf;\r
  99 unsigned int inLen;\r
 100 {\r
 101   UINT4 in[16];\r
 102   int mdi;\r
 103   unsigned int i, ii;\r
 104 \r
 105   /* compute number of bytes mod 64 */\r
 106   mdi = (int)((mdContext->i[0] >> 3) & 0x3F);\r
 107 \r
 108   /* update number of bits */\r
 109   if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])\r
 110     mdContext->i[1]++;\r
 111   mdContext->i[0] += ((UINT4)inLen << 3);\r
 112   mdContext->i[1] += ((UINT4)inLen >> 29);\r
 113 \r
 114   while (inLen--) {\r
 115     /* add new character to buffer, increment mdi */\r
 116     mdContext->in[mdi++] = *inBuf++;\r
 117 \r
 118     /* transform if necessary */\r
 119     if (mdi == 0x40) {\r
 120       for (i = 0, ii = 0; i < 16; i++, ii += 4)\r
 121         in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |\r
 122                 (((UINT4)mdContext->in[ii+2]) << 16) |\r
 123                 (((UINT4)mdContext->in[ii+1]) << 8) |\r
 124                 ((UINT4)mdContext->in[ii]);\r
 125       Transform (mdContext->buf, in);\r
 126       mdi = 0;\r
 127     }\r
 128   }\r
 129 }\r
 130 \r
 131 void MD5Final (mdContext)\r
 132 MD5_CTX *mdContext;\r
 133 {\r
 134   UINT4 in[16];\r
 135   int mdi;\r
 136   unsigned int i, ii;\r
 137   unsigned int padLen;\r
 138 \r
 139   /* save number of bits */\r
 140   in[14] = mdContext->i[0];\r
 141   in[15] = mdContext->i[1];\r
 142 \r
 143   /* compute number of bytes mod 64 */\r
 144   mdi = (int)((mdContext->i[0] >> 3) & 0x3F);\r
 145 \r
 146   /* pad out to 56 mod 64 */\r
 147   padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);\r
 148   MD5Update (mdContext, PADDING, padLen);\r
 149 \r
 150   /* append length in bits and transform */\r
 151   for (i = 0, ii = 0; i < 14; i++, ii += 4)\r
 152     in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |\r
 153             (((UINT4)mdContext->in[ii+2]) << 16) |\r
 154             (((UINT4)mdContext->in[ii+1]) << 8) |\r
 155             ((UINT4)mdContext->in[ii]);\r
 156   Transform (mdContext->buf, in);\r
 157 \r
 158   /* store buffer in digest */\r
 159   for (i = 0, ii = 0; i < 4; i++, ii += 4) {\r
 160     mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);\r
 161     mdContext->digest[ii+1] =\r
 162       (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);\r
 163     mdContext->digest[ii+2] =\r
 164       (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);\r
 165     mdContext->digest[ii+3] =\r
 166       (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);\r
 167   }\r
 168 }\r
 169 \r
 170 /* Basic MD5 step. Transform buf based on in.\r
 171  */\r
 172 static void Transform (buf, in)\r
 173 UINT4 *buf;\r
 174 UINT4 *in;\r
 175 {\r
 176   UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];\r
 177 \r
 178   /* Round 1 */\r
 179 #define S11 7\r
 180 #define S12 12\r
 181 #define S13 17\r
 182 #define S14 22\r
 183   FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */\r
 184   FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */\r
 185   FF ( c, d, a, b, in[ 2], S13,  606105819); /* 3 */\r
 186   FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */\r
 187   FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */\r
 188   FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */\r
 189   FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */\r
 190   FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */\r
 191   FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */\r
 192   FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */\r
 193   FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */\r
 194   FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */\r
 195   FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */\r
 196   FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */\r
 197   FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */\r
 198   FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */\r
 199 \r
 200   /* Round 2 */\r
 201 #define S21 5\r
 202 #define S22 9\r
 203 #define S23 14\r
 204 #define S24 20\r
 205   GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */\r
 206   GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */\r
 207   GG ( c, d, a, b, in[11], S23,  643717713); /* 19 */\r
 208   GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */\r
 209   GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */\r
 210   GG ( d, a, b, c, in[10], S22,   38016083); /* 22 */\r
 211   GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */\r
 212   GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */\r
 213   GG ( a, b, c, d, in[ 9], S21,  568446438); /* 25 */\r
 214   GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */\r
 215   GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */\r
 216   GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */\r
 217   GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */\r
 218   GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */\r
 219   GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */\r
 220   GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */\r
 221 \r
 222   /* Round 3 */\r
 223 #define S31 4\r
 224 #define S32 11\r
 225 #define S33 16\r
 226 #define S34 23\r
 227   HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */\r
 228   HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */\r
 229   HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */\r
 230   HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */\r
 231   HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */\r
 232   HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */\r
 233   HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */\r
 234   HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */\r
 235   HH ( a, b, c, d, in[13], S31,  681279174); /* 41 */\r
 236   HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */\r
 237   HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */\r
 238   HH ( b, c, d, a, in[ 6], S34,   76029189); /* 44 */\r
 239   HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */\r
 240   HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */\r
 241   HH ( c, d, a, b, in[15], S33,  530742520); /* 47 */\r
 242   HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */\r
 243 \r
 244   /* Round 4 */\r
 245 #define S41 6\r
 246 #define S42 10\r
 247 #define S43 15\r
 248 #define S44 21\r
 249   II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */\r
 250   II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */\r
 251   II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */\r
 252   II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */\r
 253   II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */\r
 254   II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */\r
 255   II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */\r
 256   II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */\r
 257   II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */\r
 258   II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */\r
 259   II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */\r
 260   II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */\r
 261   II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */\r
 262   II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */\r
 263   II ( c, d, a, b, in[ 2], S43,  718787259); /* 63 */\r
 264   II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */\r
 265 \r
 266   buf[0] += a;\r
 267   buf[1] += b;\r
 268   buf[2] += c;\r
 269   buf[3] += d;\r
 270 }\r
 271 \r
 272 /*\r
 273  **********************************************************************\r
 274  ** End of md5.c                                                     **\r
 275  ******************************* (cut) ********************************\r
 276  */\r