usr/src/lib/libsum/common/sum-md5.c

   1 /***********************************************************************
   2 *                                                                      *
   3 *               This software is part of the ast package               *
   4 *          Copyright (c) 1996-2010 AT&T Intellectual Property          *
   5 *                      and is licensed under the                       *
   6 *                  Common Public License, Version 1.0                  *
   7 *                    by AT&T Intellectual Property                     *
   8 *                                                                      *
   9 *                A copy of the License is available at                 *
  10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
  11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
  12 *                                                                      *
  13 *              Information and Software Systems Research               *
  14 *                            AT&T Research                             *
  15 *                           Florham Park NJ                            *
  16 *                                                                      *
  17 *                 Glenn Fowler <gsf@research.att.com>                  *
  18 *                                                                      *
  19 ***********************************************************************/
  20 #pragma prototyped
  21
  22 /*
  23  * md5
  24  */
  25
  26 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  27    rights reserved.
  28
  29    License to copy and use this software is granted provided that it
  30    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
  31    Method" in all material mentioning or referencing this software
  32    or this function.
  33
  34    License is also granted to make and use derivative works provided
  35    that such works are identified as "derived from the RSA Data
  36    Security, Inc. MD5 Message-Digest Method" in all material
  37    mentioning or referencing the derived work.
  38
  39    RSA Data Security, Inc. makes no representations concerning either
  40    the merchantability of this software or the suitability of this
  41    software for any particular purpose. It is provided "as is"
  42    without express or implied warranty of any kind.
  43
  44    These notices must be retained in any copies of any part of this
  45    documentation and/or software.
  46  */
  47
  48 #define md5_description \
  49         "The RSA Data Security, Inc. MD5 Message-Digest Method, 1991-2, \
  50         used with permission. The block count is not printed."
  51 #define md5_options     "[+(version)?md5 (RSA Data Security, Inc. MD5 Message-Digest, 1991-2) 1996-02-29]"
  52 #define md5_match       "md5|MD5"
  53 #define md5_scale       0
  54
  55 typedef uint32_t UINT4;
  56
  57 typedef struct Md5_s
  58 {
  59         _SUM_PUBLIC_
  60         _SUM_PRIVATE_
  61         UINT4           state[4];       /* state (ABCD)                 */
  62         UINT4           count[2];       /* # bits handled mod 2^64 (lsb)*/
  63         unsigned char   buffer[64];     /* input buffer                 */
  64         unsigned char   digest[16];     /* final digest                 */
  65         unsigned char   digest_sum[16]; /* sum of all digests           */
  66 } Md5_t;
  67
  68 static const unsigned char      md5_pad[] =
  69 {
  70         0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  71         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  72         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  73         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  74         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  75         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  76         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  77         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  78 };
  79
  80 /*
  81  * encode input into output
  82  * len must be a multiple of 4
  83  */
  84
  85 static void
  86 md5_encode(register unsigned char* output, register UINT4* input, unsigned int len)
  87 {
  88         register unsigned int   i;
  89         register unsigned int   j;
  90
  91         for (i = j = 0; j < len; i++, j += 4)
  92         {
  93                 output[j] = (unsigned char)(input[i] & 0xff);
  94                 output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
  95                 output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
  96                 output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
  97         }
  98 }
  99
 100 /*
 101  * decode input into output
 102  * len must be a multiple of 4
 103  */
 104
 105 static void
 106 md5_decode(register UINT4* output, register unsigned char* input, unsigned int len)
 107 {
 108         unsigned int    i;
 109         unsigned int    j;
 110
 111         for (i = j = 0; j < len; i++, j += 4)
 112                 output[i] = ((UINT4)input[j]) |
 113                             (((UINT4)input[j+1]) << 8) |
 114                             (((UINT4)input[j+2]) << 16) |
 115                             (((UINT4)input[j+3]) << 24);
 116 }
 117
 118 static int
 119 md5_init(Sum_t* p)
 120 {
 121         register Md5_t* context = (Md5_t*)p;
 122
 123         context->count[0] = context->count[1] = 0;
 124         context->state[0] = 0x67452301;
 125         context->state[1] = 0xefcdab89;
 126         context->state[2] = 0x98badcfe;
 127         context->state[3] = 0x10325476;
 128         return 0;
 129 }
 130
 131 static Sum_t*
 132 md5_open(const Method_t* method, const char* name)
 133 {
 134         Md5_t*  p;
 135
 136         if (p = newof(0, Md5_t, 1, 0))
 137         {
 138                 p->method = (Method_t*)method;
 139                 p->name = name;
 140                 md5_init((Sum_t*)p);
 141         }
 142         return (Sum_t*)p;
 143 }
 144
 145 /*
 146  * basic MD5 step -- transforms buf based on in
 147  */
 148
 149 #define S11 7
 150 #define S12 12
 151 #define S13 17
 152 #define S14 22
 153 #define S21 5
 154 #define S22 9
 155 #define S23 14
 156 #define S24 20
 157 #define S31 4
 158 #define S32 11
 159 #define S33 16
 160 #define S34 23
 161 #define S41 6
 162 #define S42 10
 163 #define S43 15
 164 #define S44 21
 165
 166 /* F, G, H and I are basic MD5 functions */
 167 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
 168 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
 169 #define H(x, y, z) ((x) ^ (y) ^ (z))
 170 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 171
 172 /* ROTATE_LEFT rotates x left n bits */
 173 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 174
 175 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
 176 /* Rotation is separate from addition to prevent recomputation */
 177 #define FF(a, b, c, d, x, s, ac) { \
 178     (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
 179     (a) = ROTATE_LEFT ((a), (s)); \
 180     (a) += (b); \
 181   }
 182 #define GG(a, b, c, d, x, s, ac) { \
 183     (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
 184     (a) = ROTATE_LEFT ((a), (s)); \
 185     (a) += (b); \
 186   }
 187 #define HH(a, b, c, d, x, s, ac) { \
 188     (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
 189     (a) = ROTATE_LEFT ((a), (s)); \
 190     (a) += (b); \
 191   }
 192 #define II(a, b, c, d, x, s, ac) { \
 193     (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 194     (a) = ROTATE_LEFT ((a), (s)); \
 195     (a) += (b); \
 196   }
 197
 198 static void
 199 md5_transform(UINT4 state[4], unsigned char block[64])
 200 {
 201         UINT4   a = state[0];
 202         UINT4   b = state[1];
 203         UINT4   c = state[2];
 204         UINT4   d = state[3];
 205         UINT4   x[16];
 206
 207         md5_decode(x, block, 64);
 208
 209         /* round 1 */
 210         FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 211         FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 212         FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 213         FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 214         FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 215         FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 216         FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 217         FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 218         FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 219         FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 220         FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 221         FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 222         FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 223         FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 224         FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 225         FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 226
 227         /* round 2 */
 228         GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 229         GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 230         GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 231         GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 232         GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 233         GG (d, a, b, c, x[10], S22, 0x02441453); /* 22 */
 234         GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 235         GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 236         GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 237         GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 238         GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 239         GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 240         GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 241         GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 242         GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 243         GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 244
 245         /* round 3 */
 246         HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 247         HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 248         HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 249         HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 250         HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 251         HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 252         HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 253         HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 254         HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 255         HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 256         HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 257         HH (b, c, d, a, x[ 6], S34, 0x04881d05); /* 44 */
 258         HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 259         HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 260         HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 261         HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 262
 263         /* round 4 */
 264         II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 265         II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 266         II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 267         II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 268         II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 269         II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 270         II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 271         II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 272         II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 273         II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 274         II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 275         II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 276         II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 277         II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 278         II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 279         II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 280
 281         state[0] += a;
 282         state[1] += b;
 283         state[2] += c;
 284         state[3] += d;
 285 }
 286
 287 static int
 288 md5_block(Sum_t* p, const void* s, size_t inputLen)
 289 {
 290         register Md5_t* context = (Md5_t*)p;
 291         unsigned char*  input = (unsigned char*)s;
 292         unsigned int    i;
 293         unsigned int    index;
 294         unsigned int    partLen;
 295
 296         /* compute number of bytes mod 64 */
 297         index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 298
 299         /* update number of bits */
 300         if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3))
 301                 context->count[1]++;
 302         context->count[1] += ((UINT4)inputLen >> 29);
 303         partLen = 64 - index;
 304
 305         /* transform as many times as possible */
 306         if (inputLen >= partLen)
 307         {
 308                 memcpy(&context->buffer[index], input, partLen);
 309                 md5_transform(context->state, context->buffer);
 310                 for (i = partLen; i + 63 < inputLen; i += 64)
 311                         md5_transform(context->state, &input[i]);
 312                 index = 0;
 313         }
 314         else
 315                 i = 0;
 316
 317         /* buffer remaining input */
 318         memcpy(&context->buffer[index], &input[i], inputLen - i);
 319
 320         return 0;
 321 }
 322
 323 static int
 324 md5_done(Sum_t* p)
 325 {
 326         register Md5_t* context = (Md5_t*)p;
 327         unsigned char   bits[8];
 328         unsigned int    index;
 329         unsigned int    padLen;
 330
 331         /* save number of bits */
 332         md5_encode(bits, context->count, sizeof(bits));
 333
 334         /* pad out to 56 mod 64 */
 335         index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 336         padLen = (index < 56) ? (56 - index) : (120 - index);
 337         md5_block(p, md5_pad, padLen);
 338
 339         /* append length (before padding) */
 340         md5_block(p, bits, sizeof(bits));
 341
 342         /* store state in digest */
 343         md5_encode(context->digest, context->state, sizeof(context->digest));
 344
 345         /* accumulate the digests */
 346         for (index = 0; index < elementsof(context->digest); index++)
 347                 context->digest_sum[index] ^= context->digest[index];
 348
 349         return 0;
 350 }
 351
 352 static int
 353 md5_print(Sum_t* p, Sfio_t* sp, register int flags, size_t scale)
 354 {
 355         register Md5_t*         x = (Md5_t*)p;
 356         register unsigned char* d;
 357         register int            n;
 358
 359         d = (flags & SUM_TOTAL) ? x->digest_sum : x->digest;
 360         for (n = 0; n < elementsof(x->digest); n++)
 361                 sfprintf(sp, "%02x", d[n]);
 362         return 0;
 363 }
 364
 365 static int
 366 md5_data(Sum_t* p, Sumdata_t* data)
 367 {
 368         register Md5_t*         x = (Md5_t*)p;
 369
 370         data->size = elementsof(x->digest);
 371         data->num = 0;
 372         data->buf = x->digest;
 373         return 0;
 374 }