dist/ntp/libntp/md5c.c

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