/** @file
 * @internal
 * This code implements the MD5 message-digest algorithm. The algorithm is due
 * to Ron Rivest and is described in RFC 1321.
 *
 * This code was written by Colin Plumb in 1993; no copyright is claimed.
 *
 * To compute the message digest of a chunk of bytes, declare an MD5_Context
 * structure, pass it to OI_MD5_Init, call OI_MD5_Update as needed on buffers full of
 * bytes, and then call OI_MD5_Final, which will fill a supplied 16-byte array with
 * the digest.
 */

#define __OI_MODULE__ OI_MODULE_SUPPORT

#include "md5_hash.h"
#include "oi_memmgr.h"


static void Transform(OI_UINT32 *buf,
                      OI_UINT32 *in);


/*
 * Shuffle the bytes into little-endian order within 32 bit unsigned integers
 * as per the MD5 spec. Note: this code works regardless of the CPU byte order.
 */

static void ByteSwap(OI_UINT32 *buf,
                     OI_UINT count)
{
    OI_BYTE *p = (OI_BYTE*) buf;

    do {
        *buf++ = (OI_UINT32) ((OI_UINT) p[3] << 8 | p[2]) << 16 | ((OI_UINT) p[1] << 8 | p[0]);
        p += sizeof(OI_UINT32);
    } while (--count);
}


/*
 * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
 * initialization constants.
 */

void OI_MD5_Init(MD5_CONTEXT *ctx)
{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;

    ctx->bytes[0] = 0;
    ctx->bytes[1] = 0;
}

/*
 * Update context to reflect the concatenation of another buffer full
 * of bytes.
 */
void OI_MD5_Update(MD5_CONTEXT *ctx,
                OI_BYTE *buf,
                OI_UINT16 len)
{
    OI_UINT t;

    /* Update byte count */
    t = ctx->bytes[0];
    if ((ctx->bytes[0] = t + len) < t) {
        ctx->bytes[1]++; /* Carry from low to high */
    }
    t = 64 - (t & 0x3f); /* Space avail in ctx->in (at least 1) */
    if ((OI_UINT)t > len) {
        OI_MemCopy((OI_BYTE*)ctx->in + 64 - (OI_UINT)t, buf,  len);
        return;
    }
    /* First chunk is an odd size */
    OI_MemCopy((OI_BYTE*)ctx->in + 64 - (OI_UINT)t, buf, (OI_UINT)t);
    ByteSwap(ctx->in, 16);
    Transform(ctx->buf, ctx->in);
    buf += (OI_UINT)t;
    len -= (OI_UINT)t;
    /* Process data in 64-byte chunks */
    while (len >= 64) {
        OI_MemCopy(ctx->in, buf, 64);
        ByteSwap(ctx->in, 16);
        Transform(ctx->buf, ctx->in);
        buf += 64;
        len -= 64;
    }
    /* Handle any remaining bytes of data. */
    OI_MemCopy(ctx->in, buf, len);
}


/*
 * Final wrapup - pad to 64-byte boundary with the bit pattern 1 0* (64-bit
 * count of bits processed, MSB-first)
 */

void OI_MD5_Final(OI_BYTE *digest,
               MD5_CONTEXT *ctx)
{
    OI_INT count;
    OI_BYTE *p;

    /* Bytes in ctx->in */
    count = (OI_INT)(ctx->bytes[0] & 0x3f);
    /* First unused byte */
    p = (OI_BYTE*)ctx->in + count;

    /* Set the first char of padding to 0x80. There is always room.*/
    *p++ = 0x80;

    /* Bytes of padding needed to make 56 bytes (-8..55) */
    count = 56 - 1 - count;
    if (count < 0) { /* Padding forces an extra block */
        OI_MemZero(p, count+8);
        ByteSwap(ctx->in, 16);
        Transform(ctx->buf, ctx->in);
        p = (OI_BYTE*)ctx->in;
        count = 56;
    }
    OI_MemZero(p, count+8);
    ByteSwap(ctx->in, 14);
    /* Append length in bits and transform */
    ctx->in[14] = ctx->bytes[0] << 3;
    ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
    Transform(ctx->buf, ctx->in);
    ByteSwap(ctx->buf, 4);
    OI_MemCopy(digest, ctx->buf, 16);
    OI_MemZero(ctx, sizeof(ctx));
}


/*
 * The four core functions - F1 is optimized somewhat
 */

#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))


/*
 * This is the central step in the MD5 algorithm.
 */

#define MD5STEP_F1(w,x,y,z,in,s) (w += F1(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
#define MD5STEP_F2(w,x,y,z,in,s) (w += F2(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
#define MD5STEP_F3(w,x,y,z,in,s) (w += F3(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
#define MD5STEP_F4(w,x,y,z,in,s) (w += F4(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)


/*
 * The core of the MD5 algorithm, this alters an existing MD5 hash to
 * reflect the addition of 16 longwords of new data. MD5Update blocks
 * the data and converts bytes into longwords for this routine.
 */

static void Transform(OI_UINT32 *buf,
                      OI_UINT32 *in)
{
    OI_UINT32 a, b, c, d;

    a = buf[0];
    b = buf[1];
    c = buf[2];
    d = buf[3];
    MD5STEP_F1(a, b, c, d, (in[0] + 0xd76aa478), 7);
    MD5STEP_F1(d, a, b, c, (in[1] + 0xe8c7b756), 12);
    MD5STEP_F1(c, d, a, b, (in[2] + 0x242070db), 17);
    MD5STEP_F1(b, c, d, a, (in[3] + 0xc1bdceee), 22);
    MD5STEP_F1(a, b, c, d, (in[4] + 0xf57c0faf), 7);
    MD5STEP_F1(d, a, b, c, (in[5] + 0x4787c62a), 12);
    MD5STEP_F1(c, d, a, b, (in[6] + 0xa8304613), 17);
    MD5STEP_F1(b, c, d, a, (in[7] + 0xfd469501), 22);
    MD5STEP_F1(a, b, c, d, (in[8] + 0x698098d8), 7);
    MD5STEP_F1(d, a, b, c, (in[9] + 0x8b44f7af), 12);
    MD5STEP_F1(c, d, a, b, (in[10] + 0xffff5bb1), 17);
    MD5STEP_F1(b, c, d, a, (in[11] + 0x895cd7be), 22);
    MD5STEP_F1(a, b, c, d, (in[12] + 0x6b901122), 7);
    MD5STEP_F1(d, a, b, c, (in[13] + 0xfd987193), 12);
    MD5STEP_F1(c, d, a, b, (in[14] + 0xa679438e), 17);
    MD5STEP_F1(b, c, d, a, (in[15] + 0x49b40821), 22);
    MD5STEP_F2(a, b, c, d, (in[1] + 0xf61e2562), 5);
    MD5STEP_F2(d, a, b, c, (in[6] + 0xc040b340), 9);
    MD5STEP_F2(c, d, a, b, (in[11] + 0x265e5a51), 14);
    MD5STEP_F2(b, c, d, a, (in[0] + 0xe9b6c7aa), 20);
    MD5STEP_F2(a, b, c, d, (in[5] + 0xd62f105d), 5);
    MD5STEP_F2(d, a, b, c, (in[10] + 0x02441453), 9);
    MD5STEP_F2(c, d, a, b, (in[15] + 0xd8a1e681), 14);
    MD5STEP_F2(b, c, d, a, (in[4] + 0xe7d3fbc8), 20);
    MD5STEP_F2(a, b, c, d, (in[9] + 0x21e1cde6), 5);
    MD5STEP_F2(d, a, b, c, (in[14] + 0xc33707d6), 9);
    MD5STEP_F2(c, d, a, b, (in[3] + 0xf4d50d87), 14);
    MD5STEP_F2(b, c, d, a, (in[8] + 0x455a14ed), 20);
    MD5STEP_F2(a, b, c, d, (in[13] + 0xa9e3e905), 5);
    MD5STEP_F2(d, a, b, c, (in[2] + 0xfcefa3f8), 9);
    MD5STEP_F2(c, d, a, b, (in[7] + 0x676f02d9), 14);
    MD5STEP_F2(b, c, d, a, (in[12] + 0x8d2a4c8a), 20);
    MD5STEP_F3(a, b, c, d, (in[5] + 0xfffa3942), 4);
    MD5STEP_F3(d, a, b, c, (in[8] + 0x8771f681), 11);
    MD5STEP_F3(c, d, a, b, (in[11] + 0x6d9d6122), 16);
    MD5STEP_F3(b, c, d, a, (in[14] + 0xfde5380c), 23);
    MD5STEP_F3(a, b, c, d, (in[1] + 0xa4beea44), 4);
    MD5STEP_F3(d, a, b, c, (in[4] + 0x4bdecfa9), 11);
    MD5STEP_F3(c, d, a, b, (in[7] + 0xf6bb4b60), 16);
    MD5STEP_F3(b, c, d, a, (in[10] + 0xbebfbc70), 23);
    MD5STEP_F3(a, b, c, d, (in[13] + 0x289b7ec6), 4);
    MD5STEP_F3(d, a, b, c, (in[0] + 0xeaa127fa), 11);
    MD5STEP_F3(c, d, a, b, (in[3] + 0xd4ef3085), 16);
    MD5STEP_F3(b, c, d, a, (in[6] + 0x04881d05), 23);
    MD5STEP_F3(a, b, c, d, (in[9] + 0xd9d4d039), 4);
    MD5STEP_F3(d, a, b, c, (in[12] + 0xe6db99e5), 11);
    MD5STEP_F3(c, d, a, b, (in[15] + 0x1fa27cf8), 16);
    MD5STEP_F3(b, c, d, a, (in[2] + 0xc4ac5665), 23);
    MD5STEP_F4(a, b, c, d, (in[0] + 0xf4292244), 6);
    MD5STEP_F4(d, a, b, c, (in[7] + 0x432aff97), 10);
    MD5STEP_F4(c, d, a, b, (in[14] + 0xab9423a7), 15);
    MD5STEP_F4(b, c, d, a, (in[5] + 0xfc93a039), 21);
    MD5STEP_F4(a, b, c, d, (in[12] + 0x655b59c3), 6);
    MD5STEP_F4(d, a, b, c, (in[3] + 0x8f0ccc92), 10);
    MD5STEP_F4(c, d, a, b, (in[10] + 0xffeff47d), 15);
    MD5STEP_F4(b, c, d, a, (in[1] + 0x85845dd1), 21);
    MD5STEP_F4(a, b, c, d, (in[8] + 0x6fa87e4f), 6);
    MD5STEP_F4(d, a, b, c, (in[15] + 0xfe2ce6e0), 10);
    MD5STEP_F4(c, d, a, b, (in[6] + 0xa3014314), 15);
    MD5STEP_F4(b, c, d, a, (in[13] + 0x4e0811a1), 21);
    MD5STEP_F4(a, b, c, d, (in[4] + 0xf7537e82), 6);
    MD5STEP_F4(d, a, b, c, (in[11] + 0xbd3af235), 10);
    MD5STEP_F4(c, d, a, b, (in[2] + 0x2ad7d2bb), 15);
    MD5STEP_F4(b, c, d, a, (in[9] + 0xeb86d391), 21);
    buf[0] += a;
    buf[1] += b;
    buf[2] += c;
    buf[3] += d;
}