lib/silccrypt/md5.c

   1 /* File ripped from noiz-0.5 */
   2 /* Modified by Pekka Riikonen (priikone@poseidon.pspt.fi) */
   3
   4 /*
   5  * This code implements the MD5 message-digest algorithm.
   6  * The algorithm is due to Ron Rivest.  This code was
   7  * written by Colin Plumb in 1993, no copyright is claimed.
   8  * This code is in the public domain; do with it what you wish.
   9  *
  10  * Equivalent code is available from RSA Data Security, Inc.
  11  * This code has been tested against that, and is equivalent,
  12  * except that you don't need to include two pages of legalese
  13  * with every copy.
  14  *
  15  * To compute the message digest of a chunk of bytes, declare an
  16  * MD5Context structure, pass it to MD5Init, call MD5Update as
  17  * needed on buffers full of bytes, and then call MD5Final, which
  18  * will fill a supplied 16-byte array with the digest.
  19  */
  20
  21 #include "silc.h"
  22 #include "md5_internal.h"
  23 #include "md5.h"
  24
  25 /*
  26  * SILC Hash API for MD5
  27  */
  28
  29 SILC_HASH_API_INIT(md5)
  30 {
  31   MD5Init((struct MD5Context *)context);
  32 }
  33
  34 SILC_HASH_API_UPDATE(md5)
  35 {
  36   MD5Update((struct MD5Context *)context, data, len);
  37 }
  38
  39 SILC_HASH_API_FINAL(md5)
  40 {
  41   MD5Final(digest, (struct MD5Context *)context);
  42 }
  43
  44 SILC_HASH_API_TRANSFORM(md5)
  45 {
  46   MD5Transform(state, buffer);
  47 }
  48
  49 SILC_HASH_API_CONTEXT_LEN(md5)
  50 {
  51   return sizeof(struct MD5Context);
  52 }
  53
  54 /*
  55  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  56  * initialization constants.
  57  */
  58 void
  59 MD5Init(struct MD5Context *ctx)
  60 {
  61   ctx->buf[0] = 0x67452301;
  62   ctx->buf[1] = 0xefcdab89;
  63   ctx->buf[2] = 0x98badcfe;
  64   ctx->buf[3] = 0x10325476;
  65
  66   ctx->bits[0] = 0;
  67   ctx->bits[1] = 0;
  68 }
  69
  70 /*
  71  * Update context to reflect the concatenation of another buffer full
  72  * of bytes.
  73  */
  74 void
  75 MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
  76 {
  77   SilcUInt32 t;
  78
  79   /* Update bitcount */
  80
  81   t = ctx->bits[0];
  82   if ((ctx->bits[0] = (t + ((SilcUInt32)len << 3)) & 0xffffffffL) < t)
  83     ctx->bits[1]++;     /* Carry from low to high */
  84   ctx->bits[1] += (SilcUInt32)len >> 29;
  85
  86   t = (t >> 3) & 0x3f;  /* Bytes already in shsInfo->data */
  87
  88   /* Handle any leading odd-sized chunks */
  89   if ( t ) {
  90     unsigned char *p = (unsigned char *)ctx->in + t;
  91
  92     t = 64-t;
  93     if (len < t) {
  94       memcpy(p, buf, len);
  95       return;
  96     }
  97     memcpy(p, buf, t);
  98     MD5Transform(ctx->buf, ctx->in);
  99     buf += t;
 100     len -= t;
 101   }
 102
 103   /* Process data in 64-byte chunks */
 104   while (len >= 64) {
 105     memcpy(ctx->in, buf, 64);
 106     MD5Transform(ctx->buf, ctx->in);
 107     buf += 64;
 108     len -= 64;
 109   }
 110
 111   /* Handle any remaining bytes of data. */
 112   memcpy(ctx->in, buf, len);
 113 }
 114
 115 /*
 116  * Final wrapup - pad to 64-byte boundary with the bit pattern
 117  * 1 0* (64-bit count of bits processed, MSB-first)
 118  */
 119 void
 120 MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 121 {
 122   unsigned count;
 123   unsigned char *p;
 124
 125   /* Compute number of bytes mod 64 */
 126   count = (ctx->bits[0] >> 3) & 0x3F;
 127
 128   /* Set the first char of padding to 0x80.  This is safe since there is
 129      always at least one byte free */
 130   p = ctx->in + count;
 131   *p++ = 0x80;
 132
 133   /* Bytes of padding needed to make 64 bytes */
 134   count = 64 - 1 - count;
 135
 136   /* Pad out to 56 mod 64 */
 137   if (count < 8) {
 138     /* Two lots of padding:  Pad the first block to 64 bytes */
 139     memset(p, 0, count);
 140     MD5Transform(ctx->buf, ctx->in);
 141
 142     /* Now fill the next block with 56 bytes */
 143     memset(ctx->in, 0, 56);
 144   } else {
 145     /* Pad block to 56 bytes */
 146     memset(p, 0, count-8);
 147   }
 148
 149   /* Append length in bits and transform */
 150   SILC_PUT32_LSB(ctx->bits[0], ctx->in + 56);
 151   SILC_PUT32_LSB(ctx->bits[1], ctx->in + 60);
 152   MD5Transform(ctx->buf, ctx->in);
 153   SILC_PUT32_LSB(ctx->buf[0], digest);
 154   SILC_PUT32_LSB(ctx->buf[1], digest + 4);
 155   SILC_PUT32_LSB(ctx->buf[2], digest + 8);
 156   SILC_PUT32_LSB(ctx->buf[3], digest + 12);
 157   memset(ctx, 0, sizeof(ctx));  /* In case it's sensitive */
 158 }
 159
 160 #ifndef ASM_MD5
 161
 162 /* The four core functions - F1 is optimized somewhat */
 163
 164 /* #define F1(x, y, z) (x & y | ~x & z) */
 165 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 166 #define F2(x, y, z) F1(z, x, y)
 167 #define F3(x, y, z) (x ^ y ^ z)
 168 #define F4(x, y, z) (y ^ (x | ~z))
 169
 170 /* This is the central step in the MD5 algorithm. */
 171 #define MD5STEP(f, w, x, y, z, data, s) \
 172         ( w += f(x, y, z) + data,  w = (w<<s | w>>(32-s)) & 0xffffffff, \
 173          w += x )
 174
 175 /*
 176  * The core of the MD5 algorithm, this alters an existing MD5 hash to
 177  * reflect the addition of 16 longwords of new data.  MD5Update blocks
 178  * the data and converts bytes into longwords for this routine.
 179  */
 180 void
 181 MD5Transform(SilcUInt32 buf[4], const unsigned char kbuf[64])
 182 {
 183   register SilcUInt32 a, b, c, d, i;
 184   SilcUInt32 in[16];
 185
 186   for (i = 0; i < 16; i++)
 187     SILC_GET32_LSB(in[i], kbuf + 4 * i);
 188
 189   a = buf[0];
 190   b = buf[1];
 191   c = buf[2];
 192   d = buf[3];
 193
 194   MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
 195   MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
 196   MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
 197   MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
 198   MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
 199   MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
 200   MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
 201   MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
 202   MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
 203   MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
 204   MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
 205   MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
 206   MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
 207   MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
 208   MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
 209   MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
 210
 211   MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
 212   MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
 213   MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
 214   MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
 215   MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
 216   MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
 217   MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
 218   MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
 219   MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
 220   MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
 221   MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
 222   MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
 223   MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
 224   MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
 225   MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
 226   MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
 227
 228   MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
 229   MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
 230   MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
 231   MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
 232   MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
 233   MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
 234   MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
 235   MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
 236   MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
 237   MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
 238   MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
 239   MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
 240   MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
 241   MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
 242   MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
 243   MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
 244
 245   MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
 246   MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
 247   MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
 248   MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
 249   MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
 250   MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
 251   MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
 252   MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
 253   MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
 254   MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
 255   MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
 256   MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
 257   MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
 258   MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
 259   MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
 260   MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
 261
 262   buf[0] += a;
 263   buf[1] += b;
 264   buf[2] += c;
 265   buf[3] += d;
 266 }
 267 #endif