md5.c

   1 /*
   2  * This is an OpenSSL-compatible implementation of the RSA Data Security,
   3  * Inc. MD5 Message-Digest Algorithm.
   4  *
   5  * Written by Solar Designer <solar at openwall.com> in 2001, and placed
   6  * in the public domain.  There's absolutely no warranty.
   7  *
   8  * This differs from Colin Plumb's older public domain implementation in
   9  * that no 32-bit integer data type is required, there's no compile-time
  10  * endianness configuration, and the function prototypes match OpenSSL's.
  11  * The primary goals are portability and ease of use.
  12  *
  13  * This implementation is meant to be fast, but not as fast as possible.
  14  * Some known optimizations are not included to reduce source code size
  15  * and avoid compile-time configuration.
  16  */
  17
  18 #ifndef HAVE_OPENSSL
  19
  20 #include <string.h>
  21
  22 #include "md5.h"
  23
  24 /*
  25  * The basic MD5 functions.
  26  *
  27  * F is optimized compared to its RFC 1321 definition just like in Colin
  28  * Plumb's implementation.
  29  */
  30 #define F(x, y, z)                      ((z) ^ ((x) & ((y) ^ (z))))
  31 #define G(x, y, z)                      ((y) ^ ((z) & ((x) ^ (y))))
  32 #define H(x, y, z)                      ((x) ^ (y) ^ (z))
  33 #define I(x, y, z)                      ((y) ^ ((x) | ~(z)))
  34
  35 /*
  36  * The MD5 transformation for all four rounds.
  37  */
  38 #define STEP(f, a, b, c, d, x, t, s) \
  39         (a) += f((b), (c), (d)) + (x) + (t); \
  40         (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
  41         (a) += (b);
  42
  43 /*
  44  * SET reads 4 input bytes in little-endian byte order and stores them
  45  * in a properly aligned word in host byte order.
  46  *
  47  * The check for little-endian architectures which tolerate unaligned
  48  * memory accesses is just an optimization.  Nothing will break if it
  49  * doesn't work.
  50  */
  51 #if defined(__i386__) || defined(__vax__)
  52 #define SET(n) \
  53         (*(MD5_u32plus *)&ptr[(n) * 4])
  54 #define GET(n) \
  55         SET(n)
  56 #else
  57 #define SET(n) \
  58         (ctx->block[(n)] = \
  59         (MD5_u32plus)ptr[(n) * 4] | \
  60         ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
  61         ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
  62         ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
  63 #define GET(n) \
  64         (ctx->block[(n)])
  65 #endif
  66
  67 /*
  68  * This processes one or more 64-byte data blocks, but does NOT update
  69  * the bit counters.  There're no alignment requirements.
  70  */
  71 static void *body(MD5_CTX *ctx, void *data, unsigned long size)
  72 {
  73         unsigned char *ptr;
  74         MD5_u32plus a, b, c, d;
  75         MD5_u32plus saved_a, saved_b, saved_c, saved_d;
  76
  77         ptr = data;
  78
  79         a = ctx->a;
  80         b = ctx->b;
  81         c = ctx->c;
  82         d = ctx->d;
  83
  84         do {
  85                 saved_a = a;
  86                 saved_b = b;
  87                 saved_c = c;
  88                 saved_d = d;
  89
  90 /* Round 1 */
  91                 STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
  92                 STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
  93                 STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
  94                 STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
  95                 STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
  96                 STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
  97                 STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
  98                 STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
  99                 STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
 100                 STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
 101                 STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
 102                 STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
 103                 STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
 104                 STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
 105                 STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
 106                 STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
 107
 108 /* Round 2 */
 109                 STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
 110                 STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
 111                 STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
 112                 STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
 113                 STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
 114                 STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
 115                 STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
 116                 STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
 117                 STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
 118                 STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
 119                 STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
 120                 STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
 121                 STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
 122                 STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
 123                 STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
 124                 STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
 125
 126 /* Round 3 */
 127                 STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
 128                 STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
 129                 STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
 130                 STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
 131                 STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
 132                 STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
 133                 STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
 134                 STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
 135                 STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
 136                 STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
 137                 STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
 138                 STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
 139                 STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
 140                 STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
 141                 STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
 142                 STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
 143
 144 /* Round 4 */
 145                 STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
 146                 STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
 147                 STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
 148                 STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
 149                 STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
 150                 STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
 151                 STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
 152                 STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
 153                 STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
 154                 STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
 155                 STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
 156                 STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
 157                 STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
 158                 STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
 159                 STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
 160                 STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
 161
 162                 a += saved_a;
 163                 b += saved_b;
 164                 c += saved_c;
 165                 d += saved_d;
 166
 167                 ptr += 64;
 168         } while (size -= 64);
 169
 170         ctx->a = a;
 171         ctx->b = b;
 172         ctx->c = c;
 173         ctx->d = d;
 174
 175         return ptr;
 176 }
 177
 178 void MD5_Init(MD5_CTX *ctx)
 179 {
 180         ctx->a = 0x67452301;
 181         ctx->b = 0xefcdab89;
 182         ctx->c = 0x98badcfe;
 183         ctx->d = 0x10325476;
 184
 185         ctx->lo = 0;
 186         ctx->hi = 0;
 187 }
 188
 189 void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)
 190 {
 191         MD5_u32plus saved_lo;
 192         unsigned long used, free;
 193
 194         saved_lo = ctx->lo;
 195         if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
 196                 ctx->hi++;
 197         ctx->hi += size >> 29;
 198
 199         used = saved_lo & 0x3f;
 200
 201         if (used) {
 202                 free = 64 - used;
 203
 204                 if (size < free) {
 205                         memcpy(&ctx->buffer[used], data, size);
 206                         return;
 207                 }
 208
 209                 memcpy(&ctx->buffer[used], data, free);
 210                 data = (unsigned char *)data + free;
 211                 size -= free;
 212                 body(ctx, ctx->buffer, 64);
 213         }
 214
 215         if (size >= 64) {
 216                 data = body(ctx, data, size & ~(unsigned long)0x3f);
 217                 size &= 0x3f;
 218         }
 219
 220         memcpy(ctx->buffer, data, size);
 221 }
 222
 223 void MD5_Final(unsigned char *result, MD5_CTX *ctx)
 224 {
 225         unsigned long used, free;
 226
 227         used = ctx->lo & 0x3f;
 228
 229         ctx->buffer[used++] = 0x80;
 230
 231         free = 64 - used;
 232
 233         if (free < 8) {
 234                 memset(&ctx->buffer[used], 0, free);
 235                 body(ctx, ctx->buffer, 64);
 236                 used = 0;
 237                 free = 64;
 238         }
 239
 240         memset(&ctx->buffer[used], 0, free - 8);
 241
 242         ctx->lo <<= 3;
 243         ctx->buffer[56] = ctx->lo;
 244         ctx->buffer[57] = ctx->lo >> 8;
 245         ctx->buffer[58] = ctx->lo >> 16;
 246         ctx->buffer[59] = ctx->lo >> 24;
 247         ctx->buffer[60] = ctx->hi;
 248         ctx->buffer[61] = ctx->hi >> 8;
 249         ctx->buffer[62] = ctx->hi >> 16;
 250         ctx->buffer[63] = ctx->hi >> 24;
 251
 252         body(ctx, ctx->buffer, 64);
 253
 254         result[0] = ctx->a;
 255         result[1] = ctx->a >> 8;
 256         result[2] = ctx->a >> 16;
 257         result[3] = ctx->a >> 24;
 258         result[4] = ctx->b;
 259         result[5] = ctx->b >> 8;
 260         result[6] = ctx->b >> 16;
 261         result[7] = ctx->b >> 24;
 262         result[8] = ctx->c;
 263         result[9] = ctx->c >> 8;
 264         result[10] = ctx->c >> 16;
 265         result[11] = ctx->c >> 24;
 266         result[12] = ctx->d;
 267         result[13] = ctx->d >> 8;
 268         result[14] = ctx->d >> 16;
 269         result[15] = ctx->d >> 24;
 270
 271         memset(ctx, 0, sizeof(*ctx));
 272 }
 273
 274 #endif