@@ -1,3 +1,8 @@

+Tue Mar  1 01:13:20 CET 2005 (tk)

+---------------------------------

+  * libclamav: use new MD5 implementation (thanks to Solar Designer

+	       <solar*openwall.com>)

+

 Sun Feb 27 02:26:42 CET 2005 (tk)

 ---------------------------------

   * libclamav: improve metadata scanner

@@ -203,7 +203,7 @@ int cli_scandesc(int desc, const char **virname, long int *scanned, const struct

  	char *buffer, *buff, *endbl, *pt;

 	int bytes, buffsize, length, ret, *partcnt, type = CL_CLEAN;

 	unsigned long int *partoff, offset = 0;

-	struct MD5Context ctx;

+	MD5_CTX ctx;

 	unsigned char digest[16];

 	struct cli_md5_node *md5_node;

@@ -234,7 +234,7 @@ int cli_scandesc(int desc, const char **virname, long int *scanned, const struct

     }

     if(root->md5_hlist)

-	MD5Init(&ctx);

+	MD5_Init(&ctx);

     buff = buffer;

@@ -274,7 +274,7 @@ int cli_scandesc(int desc, const char **virname, long int *scanned, const struct

         length = buffsize;

 	if(root->md5_hlist)

-	    MD5Update(&ctx, buff, bytes);

+	    MD5_Update(&ctx, buff, bytes);

     }

     free(buffer);

@@ -282,7 +282,7 @@ int cli_scandesc(int desc, const char **virname, long int *scanned, const struct

     free(partoff);

     if(root->md5_hlist) {

-	MD5Final(digest, &ctx);

+	MD5_Final(digest, &ctx);

 	if(cli_debug_flag) {

 		char md5str[33];

@@ -1,236 +1,273 @@

 /*

- * 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.

+ * This is an OpenSSL-compatible implementation of the RSA Data Security,

+ * Inc. MD5 Message-Digest Algorithm.

  *

- * 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.

+ * Written by Solar Designer <solar at openwall.com> in 2001, and placed

+ * in the public domain.  There's absolutely no warranty.

  *

- * 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.

+ * This differs from Colin Plumb's older public domain implementation in

+ * that no 32-bit integer data type is required, there's no compile-time

+ * endianness configuration, and the function prototypes match OpenSSL's.

+ * The primary goals are portability and ease of use.

  *

+ * This implementation is meant to be fast, but not as fast as possible.

+ * Some known optimizations are not included to reduce source code size

+ * and avoid compile-time configuration.

  */

 #if HAVE_CONFIG_H

 #include "clamav-config.h"

 #endif

-#include <string.h>		/* for memcpy() */

-#include <sys/types.h>		/* for stupid systems */

-#include <netinet/in.h>		/* for ntohl() */

-

+#include <string.h>

 #include "md5.h"

-#if WORDS_BIGENDIAN

-void

-byteSwap(uint32_t *buf, unsigned words)

-{

-	md5byte *p = (md5byte *)buf;

+/*

+ * The basic MD5 functions.

+ *

+ * F is optimized compared to its RFC 1321 definition just like in Colin

+ * Plumb's implementation.

+ */

+#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))

+#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))

+#define H(x, y, z)			((x) ^ (y) ^ (z))

+#define I(x, y, z)			((y) ^ ((x) | ~(z)))

-	do {

-		*buf++ = (uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |

-			((unsigned)p[1] << 8 | p[0]);

-		p += 4;

-	} while (--words);

-}

+/*

+ * The MD5 transformation for all four rounds.

+ */

+#define STEP(f, a, b, c, d, x, t, s) \

+	(a) += f((b), (c), (d)) + (x) + (t); \

+	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \

+	(a) += (b);

+

+/*

+ * SET reads 4 input bytes in little-endian byte order and stores them

+ * in a properly aligned word in host byte order.

+ *

+ * The check for little-endian architectures which tolerate unaligned

+ * memory accesses is just an optimization.  Nothing will break if it

+ * doesn't work.

+ */

+#if defined(__i386__) || defined(__vax__)

+#define SET(n) \

+	(*(MD5_u32plus *)&ptr[(n) * 4])

+#define GET(n) \

+	SET(n)

 #else

-#define byteSwap(buf,words)

+#define SET(n) \

+	(ctx->block[(n)] = \

+	(MD5_u32plus)ptr[(n) * 4] | \

+	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \

+	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \

+	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))

+#define GET(n) \

+	(ctx->block[(n)])

 #endif

 /*

- * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious

- * initialization constants.

+ * This processes one or more 64-byte data blocks, but does NOT update

+ * the bit counters.  There're no alignment requirements.

  */

-void

-MD5Init(struct MD5Context *ctx)

+static void *body(MD5_CTX *ctx, void *data, unsigned long size)

 {

-	ctx->buf[0] = 0x67452301;

-	ctx->buf[1] = 0xefcdab89;

-	ctx->buf[2] = 0x98badcfe;

-	ctx->buf[3] = 0x10325476;

+	unsigned char *ptr;

+	MD5_u32plus a, b, c, d;

+	MD5_u32plus saved_a, saved_b, saved_c, saved_d;

+

+	ptr = data;

+

+	a = ctx->a;

+	b = ctx->b;

+	c = ctx->c;

+	d = ctx->d;

+

+	do {

+		saved_a = a;

+		saved_b = b;

+		saved_c = c;

+		saved_d = d;

+

+/* Round 1 */

+		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)

+		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)

+		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)

+		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)

+		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)

+		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)

+		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)

+		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)

+		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)

+		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)

+		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)

+		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)

+		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)

+		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)

+		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)

+		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)

+

+/* Round 2 */

+		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)

+		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)

+		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)

+		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)

+		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)

+		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)

+		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)

+		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)

+		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)

+		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)

+		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)

+		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)

+		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)

+		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)

+		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)

+		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)

+

+/* Round 3 */

+		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)

+		STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)

+		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)

+		STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)

+		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)

+		STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)

+		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)

+		STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)

+		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)

+		STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)

+		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)

+		STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)

+		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)

+		STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)

+		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)

+		STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)

+

+/* Round 4 */

+		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)

+		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)

+		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)

+		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)

+		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)

+		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)

+		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)

+		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)

+		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)

+		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)

+		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)

+		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)

+		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)

+		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)

+		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)

+		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)

-	ctx->bytes[0] = 0;

-	ctx->bytes[1] = 0;

+		a += saved_a;

+		b += saved_b;

+		c += saved_c;

+		d += saved_d;

+

+		ptr += 64;

+	} while (size -= 64);

+

+	ctx->a = a;

+	ctx->b = b;

+	ctx->c = c;

+	ctx->d = d;

+

+	return ptr;

 }

-/*

- * Update context to reflect the concatenation of another buffer full

- * of bytes.

- */

-void

-MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)

+void MD5_Init(MD5_CTX *ctx)

 {

-	uint32_t t;

+	ctx->a = 0x67452301;

+	ctx->b = 0xefcdab89;

+	ctx->c = 0x98badcfe;

+	ctx->d = 0x10325476;

+

+	ctx->lo = 0;

+	ctx->hi = 0;

+}

+

+void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)

+{

+	MD5_u32plus saved_lo;

+	unsigned long used, free;

+

+	saved_lo = ctx->lo;

+	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)

+		ctx->hi++;

+	ctx->hi += size >> 29;

-	/* Update byte count */

+	used = saved_lo & 0x3f;

-	t = ctx->bytes[0];

-	if ((ctx->bytes[0] = t + len) < t)

-		ctx->bytes[1]++;	/* Carry from low to high */

+	if (used) {

+		free = 64 - used;

-	t = 64 - (t & 0x3f);	/* Space available in ctx->in (at least 1) */

-	if (t > len) {

-		memcpy((md5byte *)ctx->in + 64 - t, buf, len);

-		return;

+		if (size < free) {

+			memcpy(&ctx->buffer[used], data, size);

+			return;

+		}

+

+		memcpy(&ctx->buffer[used], data, free);

+		data = (unsigned char *)data + free;

+		size -= free;

+		body(ctx, ctx->buffer, 64);

 	}

-	/* First chunk is an odd size */

-	memcpy((md5byte *)ctx->in + 64 - t, buf, t);

-	byteSwap(ctx->in, 16);

-	MD5Transform(ctx->buf, ctx->in);

-	buf += t;

-	len -= t;

-

-	/* Process data in 64-byte chunks */

-	while (len >= 64) {

-		memcpy(ctx->in, buf, 64);

-		byteSwap(ctx->in, 16);

-		MD5Transform(ctx->buf, ctx->in);

-		buf += 64;

-		len -= 64;

+

+	if (size >= 64) {

+		data = body(ctx, data, size & ~(unsigned long)0x3f);

+		size &= 0x3f;

 	}

-	/* Handle any remaining bytes of data. */

-	memcpy(ctx->in, buf, len);

+	memcpy(ctx->buffer, data, size);

 }

-/*

- * Final wrapup - pad to 64-byte boundary with the bit pattern 

- * 1 0* (64-bit count of bits processed, MSB-first)

- */

-void

-MD5Final(md5byte *digest, struct MD5Context *ctx)

+void MD5_Final(unsigned char *result, MD5_CTX *ctx)

 {

-	int count = ctx->bytes[0] & 0x3f;	/* Number of bytes in ctx->in */

-	md5byte *p = (md5byte *)ctx->in + count;

+	unsigned long used, free;

-	/* Set the first char of padding to 0x80.  There is always room. */

-	*p++ = 0x80;

+	used = ctx->lo & 0x3f;

-	/* Bytes of padding needed to make 56 bytes (-8..55) */

-	count = 56 - 1 - count;

+	ctx->buffer[used++] = 0x80;

-	if (count < 0) {	/* Padding forces an extra block */

-		memset(p, 0, count + 8);

-		byteSwap(ctx->in, 16);

-		MD5Transform(ctx->buf, ctx->in);

-		p = (md5byte *)ctx->in;

-		count = 56;

-	}

-	memset(p, 0, count);

-	byteSwap(ctx->in, 14);

+	free = 64 - used;

-	/* Append length in bits and transform */

-	ctx->in[14] = ctx->bytes[0] << 3;

-	ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;

-	MD5Transform(ctx->buf, ctx->in);

+	if (free < 8) {

+		memset(&ctx->buffer[used], 0, free);

+		body(ctx, ctx->buffer, 64);

+		used = 0;

+		free = 64;

+	}

-	byteSwap(ctx->buf, 4);

-	memcpy(digest, ctx->buf, 16);

-	memset(ctx, 0, sizeof(ctx));	/* In case it's sensitive */

-}

+	memset(&ctx->buffer[used], 0, free - 8);

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

+	ctx->lo <<= 3;

+	ctx->buffer[56] = ctx->lo;

+	ctx->buffer[57] = ctx->lo >> 8;

+	ctx->buffer[58] = ctx->lo >> 16;

+	ctx->buffer[59] = ctx->lo >> 24;

+	ctx->buffer[60] = ctx->hi;

+	ctx->buffer[61] = ctx->hi >> 8;

+	ctx->buffer[62] = ctx->hi >> 16;

+	ctx->buffer[63] = ctx->hi >> 24;

-/* #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))

+	body(ctx, ctx->buffer, 64);

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

-#define MD5STEP(f,w,x,y,z,in,s) \

-	 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)

+	result[0] = ctx->a;

+	result[1] = ctx->a >> 8;

+	result[2] = ctx->a >> 16;

+	result[3] = ctx->a >> 24;

+	result[4] = ctx->b;

+	result[5] = ctx->b >> 8;

+	result[6] = ctx->b >> 16;

+	result[7] = ctx->b >> 24;

+	result[8] = ctx->c;

+	result[9] = ctx->c >> 8;

+	result[10] = ctx->c >> 16;

+	result[11] = ctx->c >> 24;

+	result[12] = ctx->d;

+	result[13] = ctx->d >> 8;

+	result[14] = ctx->d >> 16;

+	result[15] = ctx->d >> 24;

-/*

- * 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.

- */

-void

-MD5Transform(uint32_t buf[4], uint32_t const in[16])

-{

-	uint32_t 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;

+	memset(ctx, 0, sizeof(*ctx));

 }

@@ -1,37 +1,26 @@

 /*

- * This is the header file for 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.

+ * This is an OpenSSL-compatible implementation of the RSA Data Security,

+ * Inc. MD5 Message-Digest Algorithm.

  *

+ * Written by Solar Designer <solar at openwall.com> in 2001, and placed

+ * in the public domain.  See md5.c for more information.

  */

 #ifndef __MD5_H

 #define __MD5_H

-#define md5byte unsigned char

-

-#include "cltypes.h"

+/* Any 32-bit or wider unsigned integer data type will do */

+typedef unsigned long MD5_u32plus;

-struct MD5Context {

-	uint32_t buf[4];

-	uint32_t bytes[2];

-	uint32_t in[16];

-};

+typedef struct {

+	MD5_u32plus lo, hi;

+	MD5_u32plus a, b, c, d;

+	unsigned char buffer[64];

+	MD5_u32plus block[16];

+} MD5_CTX;

-void MD5Init(struct MD5Context *context);

-void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);

-void MD5Final(unsigned char *digest, struct MD5Context *context);

-void MD5Transform(uint32_t buf[4], uint32_t const in[16]);

+extern void MD5_Init(MD5_CTX *ctx);

+extern void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size);

+extern void MD5_Final(unsigned char *result, MD5_CTX *ctx);

 #endif

@@ -196,17 +196,17 @@ char *cli_md5stream(FILE *fs, unsigned char *digcpy)

 {

 	unsigned char digest[16];

 	char buff[FILEBUFF];

-	struct MD5Context ctx;

+	MD5_CTX ctx;

 	char *md5str, *pt;

 	int i, bytes;

-    MD5Init(&ctx);

+    MD5_Init(&ctx);

     while((bytes = fread(buff, 1, FILEBUFF, fs)))

-	MD5Update(&ctx, buff, bytes);

+	MD5_Update(&ctx, buff, bytes);

-    MD5Final(digest, &ctx);

+    MD5_Final(digest, &ctx);

     if(!(md5str = (char *) cli_calloc(32 + 1, sizeof(char))))

 	return NULL;

@@ -244,13 +244,13 @@ static char *cli_md5buff(const char *buffer, unsigned int len)

 {

 	unsigned char digest[16];

 	char *md5str, *pt;

-	struct MD5Context ctx;

+	MD5_CTX ctx;

 	int i;

-    MD5Init(&ctx);

-    MD5Update(&ctx, buffer, len);

-    MD5Final(digest, &ctx);

+    MD5_Init(&ctx);

+    MD5_Update(&ctx, (unsigned char *) buffer, len);

+    MD5_Final(digest, &ctx);

     memcpy(oldmd5buff, digest, 16);

     if(!(md5str = (char *) cli_calloc(32 + 1, sizeof(char))))