contrib/ntp/libntp/md5c.c

   1 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
   2  */
   3
   4 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
   5    rights reserved.
   6
   7    License to copy and use this software is granted provided that it
   8    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
   9    Algorithm" in all material mentioning or referencing this software
  10    or this function.
  11
  12    License is also granted to make and use derivative works provided
  13    that such works are identified as "derived from the RSA Data
  14    Security, Inc. MD5 Message-Digest Algorithm" in all material
  15    mentioning or referencing the derived work.
  16
  17    RSA Data Security, Inc. makes no representations concerning either
  18    the merchantability of this software or the suitability of this
  19    software for any particular purpose. It is provided "as is"
  20    without express or implied warranty of any kind.
  21
  22    These notices must be retained in any copies of any part of this
  23    documentation and/or software.
  24  */
  25
  26 #include "global.h"
  27 #include "md5.h"
  28
  29 /* Constants for MD5Transform routine.
  30  */
  31 #define S11 7
  32 #define S12 12
  33 #define S13 17
  34 #define S14 22
  35 #define S21 5
  36 #define S22 9
  37 #define S23 14
  38 #define S24 20
  39 #define S31 4
  40 #define S32 11
  41 #define S33 16
  42 #define S34 23
  43 #define S41 6
  44 #define S42 10
  45 #define S43 15
  46 #define S44 21
  47
  48 static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
  49 static void Encode PROTO_LIST
  50   ((unsigned char *, UINT4 *, unsigned int));
  51 static void Decode PROTO_LIST
  52   ((UINT4 *, unsigned char *, unsigned int));
  53 static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
  54 static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
  55
  56 static unsigned char PADDING[64] = {
  57   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  58   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  59   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  60 };
  61
  62 /* F, G, H and I are basic MD5 functions.
  63  */
  64 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  65 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  66 #define H(x, y, z) ((x) ^ (y) ^ (z))
  67 #define I(x, y, z) ((y) ^ ((x) | (~z)))
  68
  69 /* ROTATE_LEFT rotates x left n bits.
  70  */
  71 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  72
  73 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
  74    Rotation is separate from addition to prevent recomputation.
  75  */
  76 #define FF(a, b, c, d, x, s, ac) { \
  77     (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
  78     (a) = ROTATE_LEFT ((a), (s)); \
  79     (a) += (b); \
  80   }
  81 #define GG(a, b, c, d, x, s, ac) { \
  82     (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
  83     (a) = ROTATE_LEFT ((a), (s)); \
  84     (a) += (b); \
  85   }
  86 #define HH(a, b, c, d, x, s, ac) { \
  87     (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
  88     (a) = ROTATE_LEFT ((a), (s)); \
  89     (a) += (b); \
  90   }
  91 #define II(a, b, c, d, x, s, ac) { \
  92     (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
  93     (a) = ROTATE_LEFT ((a), (s)); \
  94     (a) += (b); \
  95   }
  96
  97 /* MD5 initialization. Begins an MD5 operation, writing a new context.
  98  */
  99 void
 100 MD5Init(
 101         MD5_CTX *context                             /* context */
 102         )
 103 {
 104   context->count[0] = context->count[1] = 0;
 105
 106   /* Load magic initialization constants.
 107    */
 108   context->state[0] = 0x67452301;
 109   context->state[1] = 0xefcdab89;
 110   context->state[2] = 0x98badcfe;
 111   context->state[3] = 0x10325476;
 112 }
 113
 114 /* MD5 block update operation. Continues an MD5 message-digest
 115      operation, processing another message block, and updating the
 116      context.
 117  */
 118 void
 119 MD5Update (
 120         MD5_CTX *context,                               /* context */
 121         unsigned char *input,                       /* input block */
 122         unsigned int inputLen             /* length of input block */
 123         )
 124 {
 125   unsigned int i, index, partLen;
 126
 127   /* Compute number of bytes mod 64 */
 128   index = (unsigned int)((context->count[0] >> 3) & 0x3F);
 129
 130   /* Update number of bits */
 131   if ((context->count[0] += ((UINT4)inputLen << 3))
 132       < ((UINT4)inputLen << 3))
 133     context->count[1]++;
 134   context->count[1] += ((UINT4)inputLen >> 29);
 135
 136   partLen = 64 - index;
 137
 138   /* Transform as many times as possible.
 139    */
 140   if (inputLen >= partLen) {
 141     MD5_memcpy
 142       ((POINTER)&context->buffer[index], (POINTER)input, partLen);
 143     MD5Transform (context->state, context->buffer);
 144
 145     for (i = partLen; i + 63 < inputLen; i += 64)
 146       MD5Transform (context->state, &input[i]);
 147
 148     index = 0;
 149   }
 150   else
 151     i = 0;
 152
 153   /* Buffer remaining input */
 154   MD5_memcpy
 155     ((POINTER)&context->buffer[index], (POINTER)&input[i],
 156      inputLen-i);
 157 }
 158
 159 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 160      the message digest and zeroizing the context.
 161  */
 162 void
 163 MD5Final (
 164         unsigned char digest[16],                /* message digest */
 165         MD5_CTX *context                                /* context */
 166         )
 167 {
 168   unsigned char bits[8];
 169   unsigned int index, padLen;
 170
 171   /* Save number of bits */
 172   Encode (bits, context->count, 8);
 173
 174   /* Pad out to 56 mod 64.
 175    */
 176   index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 177   padLen = (index < 56) ? (56 - index) : (120 - index);
 178   MD5Update (context, PADDING, padLen);
 179
 180   /* Append length (before padding) */
 181   MD5Update (context, bits, 8);
 182
 183   /* Store state in digest */
 184   Encode (digest, context->state, 16);
 185
 186   /* Zeroize sensitive information.
 187    */
 188   MD5_memset ((POINTER)context, 0, sizeof (*context));
 189 }
 190
 191 /* MD5 basic transformation. Transforms state based on block.
 192  */
 193 static void
 194 MD5Transform (
 195         UINT4 state[4],
 196         unsigned char block[64]
 197         )
 198 {
 199   UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 200
 201   Decode (x, block, 64);
 202
 203   /* Round 1 */
 204   FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 205   FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 206   FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 207   FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 208   FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 209   FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 210   FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 211   FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 212   FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 213   FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 214   FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 215   FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 216   FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 217   FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 218   FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 219   FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 220
 221   /* Round 2 */
 222   GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 223   GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 224   GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 225   GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 226   GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 227   GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 228   GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 229   GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 230   GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 231   GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 232   GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 233   GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 234   GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 235   GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 236   GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 237   GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 238
 239   /* Round 3 */
 240   HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 241   HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 242   HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 243   HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 244   HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 245   HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 246   HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 247   HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 248   HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 249   HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 250   HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 251   HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 252   HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 253   HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 254   HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 255   HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 256
 257   /* Round 4 */
 258   II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 259   II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 260   II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 261   II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 262   II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 263   II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 264   II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 265   II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 266   II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 267   II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 268   II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 269   II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 270   II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 271   II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 272   II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 273   II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 274
 275   state[0] += a;
 276   state[1] += b;
 277   state[2] += c;
 278   state[3] += d;
 279
 280   /* Zeroize sensitive information.
 281    */
 282   MD5_memset ((POINTER)x, 0, sizeof (x));
 283 }
 284
 285 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
 286      a multiple of 4.
 287  */
 288 static void
 289 Encode (
 290         unsigned char *output,
 291         UINT4 *input,
 292         unsigned int len
 293         )
 294 {
 295   unsigned int i, j;
 296
 297   for (i = 0, j = 0; j < len; i++, j += 4) {
 298     output[j] = (unsigned char)(input[i] & 0xff);
 299     output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 300     output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 301     output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 302   }
 303 }
 304
 305 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
 306      a multiple of 4.
 307  */
 308 static void
 309 Decode (
 310         UINT4 *output,
 311         unsigned char *input,
 312         unsigned int len
 313         )
 314 {
 315   unsigned int i, j;
 316
 317   for (i = 0, j = 0; j < len; i++, j += 4)
 318     output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 319       (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 320 }
 321
 322 /* Note: Replace "for loop" with standard memcpy if possible.
 323  */
 324 static void
 325 MD5_memcpy (
 326         POINTER output,
 327         POINTER input,
 328         unsigned int len
 329         )
 330 {
 331   unsigned int i;
 332
 333   for (i = 0; i < len; i++)
 334     output[i] = input[i];
 335 }
 336
 337 /* Note: Replace "for loop" with standard memset if possible.
 338  */
 339 static void
 340 MD5_memset (
 341         POINTER output,
 342         int value,
 343         unsigned int len
 344         )
 345 {
 346   unsigned int i;
 347
 348   for (i = 0; i < len; i++)
 349     ((char *)output)[i] = (char)value;
 350 }