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