md5.c

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