/*** SQLite uses this code for testing only.  It is not a part of** the SQLite library.  This file implements two new TCL commands** "md5" and "md5file" that compute md5 checksums on arbitrary text** and on complete files.  These commands are used by the "testfixture"** program to help verify the correct operation of the SQLite library.**** The original use of these TCL commands was to test the ROLLBACK** feature of SQLite.  First compute the MD5-checksum of the database.** Then make some changes but rollback the changes rather than commit** them.  Compute a second MD5-checksum of the file and verify that the** two checksums are the same.  Such is the original use of this code.** New uses may have been added since this comment was written.*//* * This code implements the MD5 message-digest algorithm. * The algorithm is due to Ron Rivest.  This code was * written by Colin Plumb in 1993, no copyright is claimed. * This code is in the public domain; do with it what you wish. * * Equivalent code is available from RSA Data Security, Inc. * This code has been tested against that, and is equivalent, * except that you don't need to include two pages of legalese * with every copy. * * To compute the message digest of a chunk of bytes, declare an * MD5Context structure, pass it to MD5Init, call MD5Update as * needed on buffers full of bytes, and then call MD5Final, which * will fill a supplied 16-byte array with the digest. */#include <tcl.h>#include <string.h>#include "sqlite.h"/* * If compiled on a machine that doesn't have a 32-bit integer, * you just set "uint32" to the appropriate datatype for an * unsigned 32-bit integer.  For example: * *       cc -Duint32='unsigned long' md5.c * */#ifndef uint32#  define uint32 unsigned int#endifstruct Context {  uint32 buf[4];  uint32 bits[2];  unsigned char in[64];};typedef char MD5Context[88];/* * Note: this code is harmless on little-endian machines. */static void byteReverse (unsigned char *buf, unsigned longs){        uint32 t;        do {                t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |                            ((unsigned)buf[1]<<8 | buf[0]);                *(uint32 *)buf = t;                buf += 4;        } while (--longs);}/* The four core functions - F1 is optimized somewhat *//* #define F1(x, y, z) (x & y | ~x & z) */#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(f, w, x, y, z, data, s) \        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += 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 MD5Transform(uint32 buf[4], const uint32 in[16]){        register 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;}/* * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious * initialization constants. */static void MD5Init(MD5Context *pCtx){        struct Context *ctx = (struct Context *)pCtx;        ctx->buf[0] = 0x67452301;        ctx->buf[1] = 0xefcdab89;        ctx->buf[2] = 0x98badcfe;        ctx->buf[3] = 0x10325476;        ctx->bits[0] = 0;        ctx->bits[1] = 0;}/* * Update context to reflect the concatenation of another buffer full * of bytes. */static void MD5Update(MD5Context *pCtx, const unsigned char *buf, unsigned int len){        struct Context *ctx = (struct Context *)pCtx;        uint32 t;        /* Update bitcount */        t = ctx->bits[0];        if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)                ctx->bits[1]++; /* Carry from low to high */        ctx->bits[1] += len >> 29;        t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */        /* Handle any leading odd-sized chunks */        if ( t ) {                unsigned char *p = (unsigned char *)ctx->in + t;                t = 64-t;                if (len < t) {                        memcpy(p, buf, len);                        return;                }                memcpy(p, buf, t);                byteReverse(ctx->in, 16);                MD5Transform(ctx->buf, (uint32 *)ctx->in);                buf += t;                len -= t;        }        /* Process data in 64-byte chunks */        while (len >= 64) {                memcpy(ctx->in, buf, 64);                byteReverse(ctx->in, 16);                MD5Transform(ctx->buf, (uint32 *)ctx->in);                buf += 64;                len -= 64;        }        /* Handle any remaining bytes of data. */        memcpy(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) */static void MD5Final(unsigned char digest[16], MD5Context *pCtx){        struct Context *ctx = (struct Context *)pCtx;        unsigned count;        unsigned char *p;        /* Compute number of bytes mod 64 */        count = (ctx->bits[0] >> 3) & 0x3F;        /* Set the first char of padding to 0x80.  This is safe since there is           always at least one byte free */        p = ctx->in + count;        *p++ = 0x80;        /* Bytes of padding needed to make 64 bytes */        count = 64 - 1 - count;        /* Pad out to 56 mod 64 */        if (count < 8) {                /* Two lots of padding:  Pad the first block to 64 bytes */                memset(p, 0, count);                byteReverse(ctx->in, 16);                MD5Transform(ctx->buf, (uint32 *)ctx->in);                /* Now fill the next block with 56 bytes */                memset(ctx->in, 0, 56);        } else {                /* Pad block to 56 bytes */                memset(p, 0, count-8);        }        byteReverse(ctx->in, 14);        /* Append length in bits and transform */        ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];        ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];        MD5Transform(ctx->buf, (uint32 *)ctx->in);        byteReverse((unsigned char *)ctx->buf, 4);        memcpy(digest, ctx->buf, 16);        memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */}/*** Convert a digest into base-16.  digest should be declared as** "unsigned char digest[16]" in the calling function.  The MD5** digest is stored in the first 16 bytes.  zBuf should** be "char zBuf[33]".*/static void DigestToBase16(unsigned char *digest, char *zBuf){  static char const zEncode[] = "0123456789abcdef";  int i, j;  for(j=i=0; i<16; i++){    int a = digest[i];    zBuf[j++] = zEncode[(a>>4)&0xf];    zBuf[j++] = zEncode[a & 0xf];  }  zBuf[j] = 0;}/*** A TCL command for md5.  The argument is the text to be hashed.  The** Result is the hash in base64.  */static int md5_cmd(void*cd, Tcl_Interp *interp, int argc, const char **argv){  MD5Context ctx;  unsigned char digest[16];  if( argc!=2 ){    Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0],         " TEXT\"", 0);    return TCL_ERROR;  }  MD5Init(&ctx);  MD5Update(&ctx, (unsigned char*)argv[1], (unsigned)strlen(argv[1]));  MD5Final(digest, &ctx);  DigestToBase16(digest, interp->result);  return TCL_OK;}/*** A TCL command to take the md5 hash of a file.  The argument is the** name of the file.*/static int md5file_cmd(void*cd, Tcl_Interp*interp, int argc, const char **argv){  FILE *in;  MD5Context ctx;  unsigned char digest[16];  char zBuf[10240];  if( argc!=2 ){    Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0],         " FILENAME\"", 0);    return TCL_ERROR;  }  in = fopen(argv[1],"rb");  if( in==0 ){    Tcl_AppendResult(interp,"unable to open file \"", argv[1],          "\" for reading", 0);    return TCL_ERROR;  }  MD5Init(&ctx);  for(;;){    int n;    n = fread(zBuf, 1, sizeof(zBuf), in);    if( n<=0 ) break;    MD5Update(&ctx, (unsigned char*)zBuf, (unsigned)n);  }  fclose(in);  MD5Final(digest, &ctx);  DigestToBase16(digest, interp->result);  return TCL_OK;}/*** Register the two TCL commands above with the TCL interpreter.*/int Md5_Init(Tcl_Interp *interp){  Tcl_CreateCommand(interp, "md5", (Tcl_CmdProc*)md5_cmd, 0, 0);  Tcl_CreateCommand(interp, "md5file", (Tcl_CmdProc*)md5file_cmd, 0, 0);  return TCL_OK;}/*** During testing, the special md5sum() aggregate function is available.** inside SQLite.  The following routines implement that function.*/static void md5step(sqlite_func *context, int argc, const char **argv){  MD5Context *p;  int i;  if( argc<1 ) return;  p = sqlite_aggregate_context(context, sizeof(*p));  if( p==0 ) return;  if( sqlite_aggregate_count(context)==1 ){    MD5Init(p);  }  for(i=0; i<argc; i++){    if( argv[i] ){      MD5Update(p, (unsigned char*)argv[i], strlen(argv[i]));    }  }}static void md5finalize(sqlite_func *context){  MD5Context *p;  unsigned char digest[16];  char zBuf[33];  p = sqlite_aggregate_context(context, sizeof(*p));  MD5Final(digest,p);  DigestToBase16(digest, zBuf);  sqlite_set_result_string(context, zBuf, strlen(zBuf));}void Md5_Register(sqlite *db){  sqlite_create_aggregate(db, "md5sum", -1, md5step, md5finalize, 0);}