/*

 * ** **************************************************************************

 * ** md5.c -- Implementation of MD5 Message Digest Algorithm                 **

 * ** Updated: 2/16/90 by Ronald L. Rivest                                    **

 * ** (C) 1990 RSA Data Security, Inc.                                        **

 * ** **************************************************************************

 */

/*

 * ** To use MD5:

 * **   -- Include md5.h in your program

 * **   -- Declare an MDstruct MD to hold the state of the digest computation.

 * **   -- Initialize MD using MDbegin(&MD)

 * **   -- For each full block (64 bytes) X you wish to process, call

 * **          MDupdate(&MD,X,512)

 * **      (512 is the number of bits in a full block.)

 * **   -- For the last block (less than 64 bytes) you wish to process,

 * **          MDupdate(&MD,X,n)

 * **      where n is the number of bits in the partial block. A partial

 * **      block terminates the computation, so every MD computation should

 * **      terminate by processing a partial block, even if it has n = 0.

 * **   -- The message digest is available in MD.buffer[0] ... MD.buffer[3].

 * **      (Least-significant byte of each word should be output first.)

 * **   -- You can print out the digest using MDprint(&MD)

 */

/*

 * Implementation notes:

 * ** This implementation assumes that ints are 32-bit quantities.

 * ** If the machine stores the least-significant byte of an int in the

 * ** least-addressed byte (eg., VAX and 8086), then LOWBYTEFIRST should be

 * ** set to TRUE.  Otherwise (eg., SUNS), LOWBYTEFIRST should be set to

 * ** FALSE.  Note that on machines with LOWBYTEFIRST FALSE the routine

 * ** MDupdate modifies has a side-effect on its input array (the order of bytes

 * ** in each word are reversed).  If this is undesired a call to MDreverse(X) can

 * ** reverse the bytes of X back into order after each call to MDupdate.

 */

/*

 * code uses WORDS_BIGENDIAN defined by configure now  -- WH 9/27/95 

 */

/*

 * Compile-time includes 

 */

#include <net-snmp/net-snmp-config.h>

#ifndef NETSNMP_DISABLE_MD5

#include <stdio.h>

#include <sys/types.h>

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/utilities.h>

#include <net-snmp/library/md5.h>

/*

 * Compile-time declarations of MD5 ``magic constants''.

 */

#define I0  0x67452301          /* Initial values for MD buffer */

#define I1  0xefcdab89

#define I2  0x98badcfe

#define I3  0x10325476

#define fs1  7                  /* round 1 shift amounts */

#define fs2 12

#define fs3 17

#define fs4 22

#define gs1  5                  /* round 2 shift amounts */

#define gs2  9

#define gs3 14

#define gs4 20

#define hs1  4                  /* round 3 shift amounts */

#define hs2 11

#define hs3 16

#define hs4 23

#define is1  6                  /* round 4 shift amounts */

#define is2 10

#define is3 15

#define is4 21

/*

 * Compile-time macro declarations for MD5.

 * ** Note: The ``rot'' operator uses the variable ``tmp''.

 * ** It assumes tmp is declared as unsigned int, so that the >>

 * ** operator will shift in zeros rather than extending the sign bit.

 */

#define	f(X,Y,Z)             ((X&Y) | ((~X)&Z))

#define	g(X,Y,Z)             ((X&Z) | (Y&(~Z)))

#define h(X,Y,Z)             (X^Y^Z)

#define i_(X,Y,Z)            (Y ^ ((X) | (~Z)))

#define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))

#define ff(A,B,C,D,i,s,lp)   A = rot((A + f(B,C,D) + X[i] + lp),s) + B

#define gg(A,B,C,D,i,s,lp)   A = rot((A + g(B,C,D) + X[i] + lp),s) + B

#define hh(A,B,C,D,i,s,lp)   A = rot((A + h(B,C,D) + X[i] + lp),s) + B

#define ii(A,B,C,D,i,s,lp)   A = rot((A + i_(B,C,D) + X[i] + lp),s) + B

#ifdef STDC_HEADERS

#define Uns(num) num##U

#else

#define Uns(num) num

#endif                          /* STDC_HEADERS */

void            MDreverse(unsigned int *);

static void     MDblock(MDptr, const unsigned int *);

#ifdef NETSNMP_ENABLE_TESTING_CODE

/*

 * MDprint(MDp)

 * ** Print message digest buffer MDp as 32 hexadecimal digits.

 * ** Order is from low-order byte of buffer[0] to high-order byte of buffer[3].

 * ** Each byte is printed with high-order hexadecimal digit first.

 * ** This is a user-callable routine.

 */

void

MDprint(MDptr MDp)

{

    int             i, j;

    for (i = 0; i < 4; i++)

        for (j = 0; j < 32; j = j + 8)

            printf("%02x", (MDp->buffer[i] >> j) & 0xFF);

    printf("\n");

    fflush(stdout);

}

#endif                          /* NETSNMP_ENABLE_TESTING_CODE */

/*

 * MDbegin(MDp)

 * ** Initialize message digest buffer MDp. 

 * ** This is a user-callable routine.

 */

void

MDbegin(MDptr MDp)

{

    int             i;

    MDp->buffer[0] = I0;

    MDp->buffer[1] = I1;

    MDp->buffer[2] = I2;

    MDp->buffer[3] = I3;

    for (i = 0; i < 8; i++)

        MDp->count[i] = 0;

    MDp->done = 0;

}

/*

 * MDreverse(X)

 * ** Reverse the byte-ordering of every int in X.

 * ** Assumes X is an array of 16 ints.

 * ** The macro revx reverses the byte-ordering of the next word of X.

 */

#define revx { t = (*X << 16) | (*X >> 16); \

	       *X++ = ((t & 0xFF00FF00) >> 8) | ((t & 0x00FF00FF) << 8); }

void

MDreverse(unsigned int *X)

{

    register unsigned int t;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

    revx;

}

/*

 * MDblock(MDp,X)

 * ** Update message digest buffer MDp->buffer using 16-word data block X.

 * ** Assumes all 16 words of X are full of data.

 * ** Does not update MDp->count.

 * ** This routine is not user-callable. 

 */

static void

MDblock(MDptr MDp, const unsigned int *X)

{

    register unsigned int tmp, A, B, C, D;      /* hpux sysv sun */

#ifdef WORDS_BIGENDIAN

    MDreverse(X);

#endif

    A = MDp->buffer[0];

    B = MDp->buffer[1];

    C = MDp->buffer[2];

    D = MDp->buffer[3];

    /*

     * Update the message digest buffer 

     */

    ff(A, B, C, D, 0, fs1, Uns(3614090360));    /* Round 1 */

    ff(D, A, B, C, 1, fs2, Uns(3905402710));

    ff(C, D, A, B, 2, fs3, Uns(606105819));

    ff(B, C, D, A, 3, fs4, Uns(3250441966));

    ff(A, B, C, D, 4, fs1, Uns(4118548399));

    ff(D, A, B, C, 5, fs2, Uns(1200080426));

    ff(C, D, A, B, 6, fs3, Uns(2821735955));

    ff(B, C, D, A, 7, fs4, Uns(4249261313));

    ff(A, B, C, D, 8, fs1, Uns(1770035416));

    ff(D, A, B, C, 9, fs2, Uns(2336552879));

    ff(C, D, A, B, 10, fs3, Uns(4294925233));

    ff(B, C, D, A, 11, fs4, Uns(2304563134));

    ff(A, B, C, D, 12, fs1, Uns(1804603682));

    ff(D, A, B, C, 13, fs2, Uns(4254626195));

    ff(C, D, A, B, 14, fs3, Uns(2792965006));

    ff(B, C, D, A, 15, fs4, Uns(1236535329));

    gg(A, B, C, D, 1, gs1, Uns(4129170786));    /* Round 2 */

    gg(D, A, B, C, 6, gs2, Uns(3225465664));

    gg(C, D, A, B, 11, gs3, Uns(643717713));

    gg(B, C, D, A, 0, gs4, Uns(3921069994));

    gg(A, B, C, D, 5, gs1, Uns(3593408605));

    gg(D, A, B, C, 10, gs2, Uns(38016083));

    gg(C, D, A, B, 15, gs3, Uns(3634488961));

    gg(B, C, D, A, 4, gs4, Uns(3889429448));

    gg(A, B, C, D, 9, gs1, Uns(568446438));

    gg(D, A, B, C, 14, gs2, Uns(3275163606));

    gg(C, D, A, B, 3, gs3, Uns(4107603335));

    gg(B, C, D, A, 8, gs4, Uns(1163531501));

    gg(A, B, C, D, 13, gs1, Uns(2850285829));

    gg(D, A, B, C, 2, gs2, Uns(4243563512));

    gg(C, D, A, B, 7, gs3, Uns(1735328473));

    gg(B, C, D, A, 12, gs4, Uns(2368359562));

    hh(A, B, C, D, 5, hs1, Uns(4294588738));    /* Round 3 */

    hh(D, A, B, C, 8, hs2, Uns(2272392833));

    hh(C, D, A, B, 11, hs3, Uns(1839030562));

    hh(B, C, D, A, 14, hs4, Uns(4259657740));

    hh(A, B, C, D, 1, hs1, Uns(2763975236));

    hh(D, A, B, C, 4, hs2, Uns(1272893353));

    hh(C, D, A, B, 7, hs3, Uns(4139469664));

    hh(B, C, D, A, 10, hs4, Uns(3200236656));

    hh(A, B, C, D, 13, hs1, Uns(681279174));

    hh(D, A, B, C, 0, hs2, Uns(3936430074));

    hh(C, D, A, B, 3, hs3, Uns(3572445317));

    hh(B, C, D, A, 6, hs4, Uns(76029189));

    hh(A, B, C, D, 9, hs1, Uns(3654602809));

    hh(D, A, B, C, 12, hs2, Uns(3873151461));

    hh(C, D, A, B, 15, hs3, Uns(530742520));

    hh(B, C, D, A, 2, hs4, Uns(3299628645));

    ii(A, B, C, D, 0, is1, Uns(4096336452));    /* Round 4 */

    ii(D, A, B, C, 7, is2, Uns(1126891415));

    ii(C, D, A, B, 14, is3, Uns(2878612391));

    ii(B, C, D, A, 5, is4, Uns(4237533241));

    ii(A, B, C, D, 12, is1, Uns(1700485571));

    ii(D, A, B, C, 3, is2, Uns(2399980690));

    ii(C, D, A, B, 10, is3, Uns(4293915773));

    ii(B, C, D, A, 1, is4, Uns(2240044497));

    ii(A, B, C, D, 8, is1, Uns(1873313359));

    ii(D, A, B, C, 15, is2, Uns(4264355552));

    ii(C, D, A, B, 6, is3, Uns(2734768916));

    ii(B, C, D, A, 13, is4, Uns(1309151649));

    ii(A, B, C, D, 4, is1, Uns(4149444226));

    ii(D, A, B, C, 11, is2, Uns(3174756917));

    ii(C, D, A, B, 2, is3, Uns(718787259));

    ii(B, C, D, A, 9, is4, Uns(3951481745));

    MDp->buffer[0] += A;

    MDp->buffer[1] += B;

    MDp->buffer[2] += C;

    MDp->buffer[3] += D;

#ifdef WORDS_BIGENDIAN

    MDreverse(X);

#endif

}

/*

 * MDupdate(MDp,X,count)

 * ** Input: MDp -- an MDptr

 * **        X -- a pointer to an array of unsigned characters.

 * **        count -- the number of bits of X to use.

 * **                 (if not a multiple of 8, uses high bits of last byte.)

 * ** Update MDp using the number of bits of X given by count.

 * ** This is the basic input routine for an MD5 user.

 * ** The routine completes the MD computation when count < 512, so

 * ** every MD computation should end with one call to MDupdate with a

 * ** count less than 512.  A call with count 0 will be ignored if the

 * ** MD has already been terminated (done != 0), so an extra call with count

 * ** 0 can be given as a ``courtesy close'' to force termination if desired.

 * ** Returns : 0 if processing succeeds or was already done;

 * **          -1 if processing was already done

 * **          -2 if count was too large

 */

int

MDupdate(MDptr MDp, const unsigned char *X, unsigned int count)

{

    unsigned int    i, tmp, bit, byte, mask;

    unsigned char   XX[64];

    unsigned char  *p;

    /*

     * return with no error if this is a courtesy close with count

     * ** zero and MDp->done is true.

     */

    if (count == 0 && MDp->done)

        return 0;

    /*

     * check to see if MD is already done and report error 

     */

    if (MDp->done) {

        return -1;

    }

    /*

     * if (MDp->done) { fprintf(stderr,"\nError: MDupdate MD already done."); return; }

     */

    /*

     * Add count to MDp->count 

     */

    tmp = count;

    p = MDp->count;

    while (tmp) {

        tmp += *p;

        *p++ = tmp;

        tmp = tmp >> 8;

    }

    /*

     * Process data 

     */

    if (count == 512) {         /* Full block of data to handle */

        MDblock(MDp, (const unsigned int *) X);

    } else if (count > 512)     /* Check for count too large */

        return -2;

    /*

     * { fprintf(stderr,"\nError: MDupdate called with illegal count value %d.",count);

     * return;

     * }

     */

    else {                      /* partial block -- must be last block so finish up */

        /*

         * Find out how many bytes and residual bits there are 

         */

        int             copycount;

        byte = count >> 3;

        bit = count & 7;

        copycount = byte;

        if (bit)

            copycount++;

        /*

         * Copy X into XX since we need to modify it 

         */

        memset(XX, 0, sizeof(XX));

        memcpy(XX, X, copycount);

        /*

         * Add padding '1' bit and low-order zeros in last byte 

         */

        mask = ((unsigned long) 1) << (7 - bit);

        XX[byte] = (XX[byte] | mask) & ~(mask - 1);

        /*

         * If room for bit count, finish up with this block 

         */

        if (byte <= 55) {

            for (i = 0; i < 8; i++)

                XX[56 + i] = MDp->count[i];

            MDblock(MDp, (unsigned int *) XX);

        } else {                /* need to do two blocks to finish up */

            MDblock(MDp, (unsigned int *) XX);

            for (i = 0; i < 56; i++)

                XX[i] = 0;

            for (i = 0; i < 8; i++)

                XX[56 + i] = MDp->count[i];

            MDblock(MDp, (unsigned int *) XX);

        }

        /*

         * Set flag saying we're done with MD computation 

         */

        MDp->done = 1;

    }

    return 0;

}

/*

 * MDchecksum(data, len, MD5): do a checksum on an arbirtrary amount of data 

 */

int

MDchecksum(const u_char * data, size_t len, u_char * mac, size_t maclen)

{

    MDstruct        md;

    MDstruct       *MD = &md;

    int             rc = 0;

    MDbegin(MD);

    while (len >= 64) {

        rc = MDupdate(MD, data, 64 * 8);

        if (rc)

            goto check_end;

        data += 64;

        len -= 64;

    }

    rc = MDupdate(MD, data, len * 8);

    if (rc)

        goto check_end;

    /*

     * copy the checksum to the outgoing data (all of it that is requested). 

     */

    MDget(MD, mac, maclen);

  check_end:

    memset(&md, 0, sizeof(md));

    return rc;

}

/*

 * MDsign(data, len, MD5): do a checksum on an arbirtrary amount

 * of data, and prepended with a secret in the standard fashion 

 */

int

MDsign(const u_char * data, size_t len, u_char * mac, size_t maclen,

       const u_char * secret, size_t secretlen)

{

#define HASHKEYLEN 64

    MDstruct        MD;

    u_char          K1[HASHKEYLEN];

    u_char          K2[HASHKEYLEN];

    u_char          extendedAuthKey[HASHKEYLEN];

    u_char          buf[HASHKEYLEN];

    size_t          i;

    const u_char   *cp;

    u_char         *newdata = NULL;

    int             rc = 0;

    /*

     * memset(K1,0,HASHKEYLEN);

     * memset(K2,0,HASHKEYLEN);

     * memset(buf,0,HASHKEYLEN);

     * memset(extendedAuthKey,0,HASHKEYLEN);

     */

    if (secretlen != 16 || secret == NULL || mac == NULL || data == NULL ||

        len <= 0 || maclen <= 0) {

        /*

         * DEBUGMSGTL(("md5","MD5 signing not properly initialized")); 

         */

        return -1;

    }

    memset(extendedAuthKey, 0, HASHKEYLEN);

    memcpy(extendedAuthKey, secret, secretlen);

    for (i = 0; i < HASHKEYLEN; i++) {

        K1[i] = extendedAuthKey[i] ^ 0x36;

        K2[i] = extendedAuthKey[i] ^ 0x5c;

    }

    MDbegin(&MD;;

    rc = MDupdate(&MD, K1, HASHKEYLEN * 8);

    if (rc)

        goto update_end;

    i = len;

    if (((uintptr_t) data) % sizeof(long) != 0) {

        /*

         * this relies on the ability to use integer math and thus we

         * must rely on data that aligns on 32-bit-word-boundries 

         */

        newdata = netsnmp_memdup(data, len);

        cp = newdata;

    } else {

        cp = data;

    }

    while (i >= 64) {

        rc = MDupdate(&MD, cp, 64 * 8);

        if (rc)

            goto update_end;

        cp += 64;

        i -= 64;

    }

    rc = MDupdate(&MD, cp, i * 8);

    if (rc)

        goto update_end;

    memset(buf, 0, HASHKEYLEN);

    MDget(&MD, buf, HASHKEYLEN);

    MDbegin(&MD;;

    rc = MDupdate(&MD, K2, HASHKEYLEN * 8);

    if (rc)

        goto update_end;

    rc = MDupdate(&MD, buf, 16 * 8);

    if (rc)

        goto update_end;

    /*

     * copy the sign checksum to the outgoing pointer 

     */

    MDget(&MD, mac, maclen);

  update_end:

    memset(buf, 0, HASHKEYLEN);

    memset(K1, 0, HASHKEYLEN);

    memset(K2, 0, HASHKEYLEN);

    memset(extendedAuthKey, 0, HASHKEYLEN);

    memset(&MD, 0, sizeof(MD));

    if (newdata)

        free(newdata);

    return rc;

}

void

MDget(MDstruct * MD, u_char * buf, size_t buflen)

{

    int             i, j;

    /*

     * copy the checksum to the outgoing data (all of it that is requested). 

     */

    for (i = 0; i < 4 && i * 4 < (int) buflen; i++)

        for (j = 0; j < 4 && i * 4 + j < (int) buflen; j++)

            buf[i * 4 + j] = (MD->buffer[i] >> j * 8) & 0xff;

}

/*

 * ** End of md5.c

 * ****************************(cut)****************************************

 */

#endif /* NETSNMP_DISABLE_MD5 */