libmultihash/md5.c

   1 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   2 //  WjCryptLib_Md5
   3 //
   4 //  Implementation of MD5 hash function. Originally written by Alexander Peslyak. Modified by WaterJuice retaining
   5 //  Public Domain license.
   6 //
   7 //  This is free and unencumbered software released into the public domain - June 2013 waterjuice.org
   8 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   9
  10 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  11 //  IMPORTS
  12 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  13
  14 #include "md5.h"
  15 #include <memory.h>
  16
  17 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  18 //  INTERNAL FUNCTIONS
  19 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  20
  21 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  22 //  F, G, H, I
  23 //
  24 //  The basic MD5 functions. F and G are optimised compared to their RFC 1321 definitions for architectures that lack
  25 //  an AND-NOT instruction, just like in Colin Plumb's implementation.
  26 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  27 #define F( x, y, z )            ( (z) ^ ((x) & ((y) ^ (z))) )
  28 #define G( x, y, z )            ( (y) ^ ((z) & ((x) ^ (y))) )
  29 #define H( x, y, z )            ( (x) ^ (y) ^ (z) )
  30 #define I( x, y, z )            ( (y) ^ ((x) | ~(z)) )
  31
  32 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  33 //  STEP
  34 //
  35 //  The MD5 transformation for all four rounds.
  36 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  37 #define STEP( f, a, b, c, d, x, t, s )                          \
  38     (a) += f((b), (c), (d)) + (x) + (t);                        \
  39     (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));  \
  40     (a) += (b);
  41
  42 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  43 //  TransformFunction
  44 //
  45 //  This processes one or more 64-byte data blocks, but does NOT update the bit counters. There are no alignment
  46 //  requirements.
  47 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  48 static
  49 void*
  50     TransformFunction
  51     (
  52         Md5Context*     ctx,
  53         void const*     data,
  54         uintmax_t       size
  55     )
  56 {
  57     uint8_t*     ptr;
  58     uint32_t     a;
  59     uint32_t     b;
  60     uint32_t     c;
  61     uint32_t     d;
  62     uint32_t     saved_a;
  63     uint32_t     saved_b;
  64     uint32_t     saved_c;
  65     uint32_t     saved_d;
  66
  67     #define GET(n) (ctx->block[(n)])
  68     #define SET(n) (ctx->block[(n)] =             \
  69             ((uint32_t)ptr[(n)*4 + 0] << 0 )      \
  70         |   ((uint32_t)ptr[(n)*4 + 1] << 8 )      \
  71         |   ((uint32_t)ptr[(n)*4 + 2] << 16)      \
  72         |   ((uint32_t)ptr[(n)*4 + 3] << 24) )
  73
  74     ptr = (uint8_t*)data;
  75
  76     a = ctx->a;
  77     b = ctx->b;
  78     c = ctx->c;
  79     d = ctx->d;
  80
  81     do
  82     {
  83         saved_a = a;
  84         saved_b = b;
  85         saved_c = c;
  86         saved_d = d;
  87
  88         // Round 1
  89         STEP( F, a, b, c, d, SET(0),  0xd76aa478, 7 )
  90         STEP( F, d, a, b, c, SET(1),  0xe8c7b756, 12 )
  91         STEP( F, c, d, a, b, SET(2),  0x242070db, 17 )
  92         STEP( F, b, c, d, a, SET(3),  0xc1bdceee, 22 )
  93         STEP( F, a, b, c, d, SET(4),  0xf57c0faf, 7 )
  94         STEP( F, d, a, b, c, SET(5),  0x4787c62a, 12 )
  95         STEP( F, c, d, a, b, SET(6),  0xa8304613, 17 )
  96         STEP( F, b, c, d, a, SET(7),  0xfd469501, 22 )
  97         STEP( F, a, b, c, d, SET(8 ),  0x698098d8, 7 )
  98         STEP( F, d, a, b, c, SET(9 ),  0x8b44f7af, 12 )
  99         STEP( F, c, d, a, b, SET(10 ), 0xffff5bb1, 17 )
 100         STEP( F, b, c, d, a, SET(11 ), 0x895cd7be, 22 )
 101         STEP( F, a, b, c, d, SET(12 ), 0x6b901122, 7 )
 102         STEP( F, d, a, b, c, SET(13 ), 0xfd987193, 12 )
 103         STEP( F, c, d, a, b, SET(14 ), 0xa679438e, 17 )
 104         STEP( F, b, c, d, a, SET(15 ), 0x49b40821, 22 )
 105
 106         // Round 2
 107         STEP( G, a, b, c, d, GET(1),  0xf61e2562, 5 )
 108         STEP( G, d, a, b, c, GET(6),  0xc040b340, 9 )
 109         STEP( G, c, d, a, b, GET(11), 0x265e5a51, 14 )
 110         STEP( G, b, c, d, a, GET(0),  0xe9b6c7aa, 20 )
 111         STEP( G, a, b, c, d, GET(5),  0xd62f105d, 5 )
 112         STEP( G, d, a, b, c, GET(10), 0x02441453, 9 )
 113         STEP( G, c, d, a, b, GET(15), 0xd8a1e681, 14 )
 114         STEP( G, b, c, d, a, GET(4),  0xe7d3fbc8, 20 )
 115         STEP( G, a, b, c, d, GET(9),  0x21e1cde6, 5 )
 116         STEP( G, d, a, b, c, GET(14), 0xc33707d6, 9 )
 117         STEP( G, c, d, a, b, GET(3),  0xf4d50d87, 14 )
 118         STEP( G, b, c, d, a, GET(8),  0x455a14ed, 20 )
 119         STEP( G, a, b, c, d, GET(13), 0xa9e3e905, 5 )
 120         STEP( G, d, a, b, c, GET(2),  0xfcefa3f8, 9 )
 121         STEP( G, c, d, a, b, GET(7),  0x676f02d9, 14 )
 122         STEP( G, b, c, d, a, GET(12), 0x8d2a4c8a, 20 )
 123
 124         // Round 3
 125         STEP( H, a, b, c, d, GET(5),  0xfffa3942, 4 )
 126         STEP( H, d, a, b, c, GET(8),  0x8771f681, 11 )
 127         STEP( H, c, d, a, b, GET(11), 0x6d9d6122, 16 )
 128         STEP( H, b, c, d, a, GET(14), 0xfde5380c, 23 )
 129         STEP( H, a, b, c, d, GET(1),  0xa4beea44, 4 )
 130         STEP( H, d, a, b, c, GET(4),  0x4bdecfa9, 11 )
 131         STEP( H, c, d, a, b, GET(7),  0xf6bb4b60, 16 )
 132         STEP( H, b, c, d, a, GET(10), 0xbebfbc70, 23 )
 133         STEP( H, a, b, c, d, GET(13), 0x289b7ec6, 4 )
 134         STEP( H, d, a, b, c, GET(0),  0xeaa127fa, 11 )
 135         STEP( H, c, d, a, b, GET(3),  0xd4ef3085, 16 )
 136         STEP( H, b, c, d, a, GET(6),  0x04881d05, 23 )
 137         STEP( H, a, b, c, d, GET(9),  0xd9d4d039, 4 )
 138         STEP( H, d, a, b, c, GET(12), 0xe6db99e5, 11 )
 139         STEP( H, c, d, a, b, GET(15), 0x1fa27cf8, 16 )
 140         STEP( H, b, c, d, a, GET(2),  0xc4ac5665, 23 )
 141
 142         // Round 4
 143         STEP( I, a, b, c, d, GET(0),  0xf4292244, 6 )
 144         STEP( I, d, a, b, c, GET(7),  0x432aff97, 10 )
 145         STEP( I, c, d, a, b, GET(14), 0xab9423a7, 15 )
 146         STEP( I, b, c, d, a, GET(5),  0xfc93a039, 21 )
 147         STEP( I, a, b, c, d, GET(12), 0x655b59c3, 6 )
 148         STEP( I, d, a, b, c, GET(3),  0x8f0ccc92, 10 )
 149         STEP( I, c, d, a, b, GET(10), 0xffeff47d, 15 )
 150         STEP( I, b, c, d, a, GET(1),  0x85845dd1, 21 )
 151         STEP( I, a, b, c, d, GET(8),  0x6fa87e4f, 6 )
 152         STEP( I, d, a, b, c, GET(15), 0xfe2ce6e0, 10 )
 153         STEP( I, c, d, a, b, GET(6),  0xa3014314, 15 )
 154         STEP( I, b, c, d, a, GET(13), 0x4e0811a1, 21 )
 155         STEP( I, a, b, c, d, GET(4),  0xf7537e82, 6 )
 156         STEP( I, d, a, b, c, GET(11), 0xbd3af235, 10 )
 157         STEP( I, c, d, a, b, GET(2),  0x2ad7d2bb, 15 )
 158         STEP( I, b, c, d, a, GET(9),  0xeb86d391, 21 )
 159
 160         a += saved_a;
 161         b += saved_b;
 162         c += saved_c;
 163         d += saved_d;
 164
 165         ptr += 64;
 166     } while( size -= 64 );
 167
 168     ctx->a = a;
 169     ctx->b = b;
 170     ctx->c = c;
 171     ctx->d = d;
 172
 173     #undef GET
 174     #undef SET
 175
 176     return ptr;
 177 }
 178
 179 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 180 //  EXPORTED FUNCTIONS
 181 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 182
 183 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 184 //  Md5Initialise
 185 //
 186 //  Initialises an MD5 Context. Use this to initialise/reset a context.
 187 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 188 void
 189     Md5Initialise
 190     (
 191         Md5Context*         Context         // [out]
 192     )
 193 {
 194     Context->a = 0x67452301;
 195     Context->b = 0xefcdab89;
 196     Context->c = 0x98badcfe;
 197     Context->d = 0x10325476;
 198
 199     Context->lo = 0;
 200     Context->hi = 0;
 201 }
 202
 203 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 204 //  Md5Update
 205 //
 206 //  Adds data to the MD5 context. This will process the data and update the internal state of the context. Keep on
 207 //  calling this function until all the data has been added. Then call Md5Finalise to calculate the hash.
 208 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 209 void
 210     Md5Update
 211     (
 212         Md5Context*         Context,        // [in out]
 213         void const*         Buffer,         // [in]
 214         uint32_t            BufferSize      // [in]
 215     )
 216 {
 217     uint32_t    saved_lo;
 218     uint32_t    used;
 219     uint32_t    free;
 220
 221     saved_lo = Context->lo;
 222     if( (Context->lo = (saved_lo + BufferSize) & 0x1fffffff) < saved_lo )
 223     {
 224         Context->hi++;
 225     }
 226     Context->hi += (uint32_t)( BufferSize >> 29 );
 227
 228     used = saved_lo & 0x3f;
 229
 230     if( used )
 231     {
 232         free = 64 - used;
 233
 234         if( BufferSize < free )
 235         {
 236             memcpy( &Context->buffer[used], Buffer, BufferSize );
 237             return;
 238         }
 239
 240         memcpy( &Context->buffer[used], Buffer, free );
 241         Buffer = (uint8_t*)Buffer + free;
 242         BufferSize -= free;
 243         TransformFunction(Context, Context->buffer, 64);
 244     }
 245
 246     if( BufferSize >= 64 )
 247     {
 248         Buffer = TransformFunction( Context, Buffer, BufferSize & ~(unsigned long)0x3f );
 249         BufferSize &= 0x3f;
 250     }
 251
 252     memcpy( Context->buffer, Buffer, BufferSize );
 253 }
 254
 255 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 256 //  Md5Finalise
 257 //
 258 //  Performs the final calculation of the hash and returns the digest (16 byte buffer containing 128bit hash). After
 259 //  calling this, Md5Initialised must be used to reuse the context.
 260 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 261 void
 262     Md5Finalise
 263     (
 264         Md5Context*         Context,        // [in out]
 265         MD5_HASH*           Digest          // [in]
 266     )
 267 {
 268     uint32_t    used;
 269     uint32_t    free;
 270
 271     used = Context->lo & 0x3f;
 272
 273     Context->buffer[used++] = 0x80;
 274
 275     free = 64 - used;
 276
 277     if(free < 8)
 278     {
 279         memset( &Context->buffer[used], 0, free );
 280         TransformFunction( Context, Context->buffer, 64 );
 281         used = 0;
 282         free = 64;
 283     }
 284
 285     memset( &Context->buffer[used], 0, free - 8 );
 286
 287     Context->lo <<= 3;
 288     Context->buffer[56] = (uint8_t)( Context->lo );
 289     Context->buffer[57] = (uint8_t)( Context->lo >> 8 );
 290     Context->buffer[58] = (uint8_t)( Context->lo >> 16 );
 291     Context->buffer[59] = (uint8_t)( Context->lo >> 24 );
 292     Context->buffer[60] = (uint8_t)( Context->hi );
 293     Context->buffer[61] = (uint8_t)( Context->hi >> 8 );
 294     Context->buffer[62] = (uint8_t)( Context->hi >> 16 );
 295     Context->buffer[63] = (uint8_t)( Context->hi >> 24 );
 296
 297     TransformFunction( Context, Context->buffer, 64 );
 298
 299     Digest->bytes[0]  = (uint8_t)( Context->a );
 300     Digest->bytes[1]  = (uint8_t)( Context->a >> 8 );
 301     Digest->bytes[2]  = (uint8_t)( Context->a >> 16 );
 302     Digest->bytes[3]  = (uint8_t)( Context->a >> 24 );
 303     Digest->bytes[4]  = (uint8_t)( Context->b );
 304     Digest->bytes[5]  = (uint8_t)( Context->b >> 8 );
 305     Digest->bytes[6]  = (uint8_t)( Context->b >> 16 );
 306     Digest->bytes[7]  = (uint8_t)( Context->b >> 24 );
 307     Digest->bytes[8]  = (uint8_t)( Context->c );
 308     Digest->bytes[9]  = (uint8_t)( Context->c >> 8 );
 309     Digest->bytes[10] = (uint8_t)( Context->c >> 16 );
 310     Digest->bytes[11] = (uint8_t)( Context->c >> 24 );
 311     Digest->bytes[12] = (uint8_t)( Context->d );
 312     Digest->bytes[13] = (uint8_t)( Context->d >> 8 );
 313     Digest->bytes[14] = (uint8_t)( Context->d >> 16 );
 314     Digest->bytes[15] = (uint8_t)( Context->d >> 24 );
 315 }
 316
 317 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 318 //  Md5Calculate
 319 //
 320 //  Combines Md5Initialise, Md5Update, and Md5Finalise into one function. Calculates the MD5 hash of the buffer.
 321 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 322 void
 323     Md5Calculate
 324     (
 325         void  const*        Buffer,         // [in]
 326         uint32_t            BufferSize,     // [in]
 327         MD5_HASH*           Digest          // [in]
 328     )
 329 {
 330     Md5Context context;
 331
 332     Md5Initialise( &context );
 333     Md5Update( &context, Buffer, BufferSize );
 334     Md5Finalise( &context, Digest );
 335 }