@@ -1,3 +1,7 @@

+Wed Sep  1 16:11:40 CEST 2004 (tk)

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

+  * libclamav: replace current MD5 implementation with another one

+

 Wed Sep  1 03:32:28 CEST 2004 (tk)

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

   * libclamav/cvd.c: display warning if loaded database is older than 7 days

@@ -288,7 +288,7 @@ int cli_cvdverify(FILE *fd, struct cl_cvd *cvdpt)

     if(cvdpt)

 	memcpy(cvdpt, cvd, sizeof(struct cl_cvd));

-    md5 = cli_md5stream(fd);

+    md5 = cli_md5stream(fd, NULL);

     cli_dbgmsg("MD5(.tar.gz) = %s\n", md5);

     if(strncmp(md5, cvd->md5, 32)) {

@@ -80,8 +80,8 @@ 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 md5_ctx ctx;

-        unsigned char md5buff[16];

+	struct MD5Context ctx;

+	unsigned char digest[16];

 	struct cli_md5_node *md5_node;

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

     }

     if(root->md5_hlist)

-	md5_init_ctx (&ctx);

+	MD5Init(&ctx);

     buff = buffer;

     buff += root->maxpatlen; /* pointer to read data block */

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

 						* length of root->maxpatlen

 						*/

-    pt= buff;

+    pt = buff;

     length = SCANBUFF;

     while((bytes = read(desc, buff, SCANBUFF)) > 0) {

@@ -149,25 +149,8 @@ int cli_scandesc(int desc, const char **virname, long int *scanned, const struct

         pt = buffer;

         length = buffsize;

-	/* compute MD5 */

-

-	if(root->md5_hlist) {

-	    if(bytes % 64 == 0) {

-		md5_process_block(buff, bytes, &ctx);

-	    } else {

-		    int block = bytes;

-		    char *mpt = buff;

-

-		while(block >= MD5_BLOCKSIZE) {

-		    md5_process_block(mpt, MD5_BLOCKSIZE, &ctx);

-		    mpt += MD5_BLOCKSIZE;

-		    block -= MD5_BLOCKSIZE;

-		}

-

-		if(block)

-		    md5_process_bytes(mpt, block, &ctx);

-	    }

-	}

+	if(root->md5_hlist)

+	    MD5Update(&ctx, buff, bytes);

     }

     free(buffer);

@@ -175,9 +158,9 @@ int cli_scandesc(int desc, const char **virname, long int *scanned, const struct

     free(partoff);

     if(root->md5_hlist) {

-	md5_finish_ctx(&ctx, &md5buff);

+	MD5Final(digest, &ctx);

-	if((md5_node = cli_vermd5(md5buff, root))) {

+	if((md5_node = cli_vermd5(digest, root))) {

 		struct stat sb;

 	    if(fstat(desc, &sb))

@@ -1,434 +1,236 @@

-/* Functions to compute MD5 message digest of files or memory blocks.

-   according to the definition of MD5 in RFC 1321 from April 1992.

-   Copyright (C) 1995, 1996, 1997, 1999, 2000 Free Software Foundation, Inc.

-   This file is part of the GNU C Library.

-

-   The GNU C Library is free software; you can redistribute it and/or

-   modify it under the terms of the GNU Library General Public License as

-   published by the Free Software Foundation; either version 2 of the

-   License, or (at your option) any later version.

-

-   The GNU C Library is distributed in the hope that it will be useful,

-   but WITHOUT ANY WARRANTY; without even the implied warranty of

-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

-   Library General Public License for more details.

-

-   You should have received a copy of the GNU Library General Public

-   License along with the GNU C Library; see the file COPYING.LIB.  If not,

-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

-   Boston, MA 02111-1307, USA.  */

-

-/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */

-

-#ifdef HAVE_CONFIG_H

-# include <clamav-config.h>

+/*

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

+ *

+ */

+

+#if HAVE_CONFIG_H

+#include "clamav-config.h"

 #endif

-#include <sys/types.h>

-

-#if STDC_HEADERS || defined _LIBC

-# include <stdlib.h>

-# include <string.h>

-#else

-# ifndef HAVE_MEMCPY

-#  define memcpy(d, s, n) bcopy ((s), (d), (n))

-# endif

-#endif

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

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

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

 #include "md5.h"

-/* Not needed, since endianess is already taken care of by configure

-#ifdef _LIBC

-# include <endian.h>

-# if __BYTE_ORDER == __BIG_ENDIAN

-#  define WORDS_BIGENDIAN 1

-# endif

-#endif

-*/

-

 #if WORDS_BIGENDIAN

-# define SWAP(n)							\

-    (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))

-#else

-# define SWAP(n) (n)

-#endif

-

-

-/* This array contains the bytes used to pad the buffer to the next

-   64-byte boundary.  (RFC 1321, 3.1: Step 1)  */

-static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };

-

-

-/* Initialize structure containing state of computation.

-   (RFC 1321, 3.3: Step 3)  */

 void

-md5_init_ctx (ctx)

-     struct md5_ctx *ctx;

-{

-  ctx->A = 0x67452301;

-  ctx->B = 0xefcdab89;

-  ctx->C = 0x98badcfe;

-  ctx->D = 0x10325476;

-

-  ctx->total[0] = ctx->total[1] = 0;

-  ctx->buflen = 0;

-}

-

-/* Put result from CTX in first 16 bytes following RESBUF.  The result

-   must be in little endian byte order.

-

-   IMPORTANT: On some systems it is required that RESBUF is correctly

-   aligned for a 32 bits value.  */

-void *

-md5_read_ctx (ctx, resbuf)

-     const struct md5_ctx *ctx;

-     void *resbuf;

+byteSwap(uint32_t *buf, unsigned words)

 {

-  ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);

-  ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);

-  ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);

-  ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);

+	md5byte *p = (md5byte *)buf;

-  return resbuf;

+	do {

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

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

+		p += 4;

+	} while (--words);

 }

+#else

+#define byteSwap(buf,words)

+#endif

-/* Process the remaining bytes in the internal buffer and the usual

-   prolog according to the standard and write the result to RESBUF.

-

-   IMPORTANT: On some systems it is required that RESBUF is correctly

-   aligned for a 32 bits value.  */

-void *

-md5_finish_ctx (ctx, resbuf)

-     struct md5_ctx *ctx;

-     void *resbuf;

+/*

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

+ * initialization constants.

+ */

+void

+MD5Init(struct MD5Context *ctx)

 {

-  /* Take yet unprocessed bytes into account.  */

-  md5_uint32 bytes = ctx->buflen;

-  size_t pad;

-

-  /* Now count remaining bytes.  */

-  ctx->total[0] += bytes;

-  if (ctx->total[0] < bytes)

-    ++ctx->total[1];

-

-  pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;

-  memcpy (&ctx->buffer[bytes], fillbuf, pad);

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

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

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

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

-  /* Put the 64-bit file length in *bits* at the end of the buffer.  */

-  *(md5_uint32 *) &ctx->buffer[bytes + pad] = SWAP (ctx->total[0] << 3);

-  *(md5_uint32 *) &ctx->buffer[bytes + pad + 4] = SWAP ((ctx->total[1] << 3) |

-							(ctx->total[0] >> 29));

-

-  /* Process last bytes.  */

-  md5_process_block (ctx->buffer, bytes + pad + 8, ctx);

-

-  return md5_read_ctx (ctx, resbuf);

+	ctx->bytes[0] = 0;

+	ctx->bytes[1] = 0;

 }

-/* Compute MD5 message digest for bytes read from STREAM.  The

-   resulting message digest number will be written into the 16 bytes

-   beginning at RESBLOCK.  */

-int

-md5_stream (stream, resblock)

-     FILE *stream;

-     void *resblock;

+/*

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

+ * of bytes.

+ */

+void

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

 {

-  /* Important: BLOCKSIZE must be a multiple of 64.  */

-#define BLOCKSIZE 4096

-  struct md5_ctx ctx;

-  char buffer[BLOCKSIZE + 72];

-  size_t sum;

+	uint32_t t;

-  /* Initialize the computation context.  */

-  md5_init_ctx (&ctx);

+	/* Update byte count */

-  /* Iterate over full file contents.  */

-  while (1)

-    {

-      /* We read the file in blocks of BLOCKSIZE bytes.  One call of the

-	 computation function processes the whole buffer so that with the

-	 next round of the loop another block can be read.  */

-      size_t n;

-      sum = 0;

+	t = ctx->bytes[0];

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

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

-      /* Read block.  Take care for partial reads.  */

-      do

-	{

-	  n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);

-

-	  sum += n;

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

+	if (t > len) {

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

+		return;

+	}

+	/* 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;

 	}

-      while (sum < BLOCKSIZE && n != 0);

-      if (n == 0 && ferror (stream))

-        return 1;

-

-      /* If end of file is reached, end the loop.  */

-      if (n == 0)

-	break;

-

-      /* Process buffer with BLOCKSIZE bytes.  Note that

-			BLOCKSIZE % 64 == 0

-       */

-      md5_process_block (buffer, BLOCKSIZE, &ctx);

-    }

-

-  /* Add the last bytes if necessary.  */

-  if (sum > 0)

-    md5_process_bytes (buffer, sum, &ctx);

-

-  /* Construct result in desired memory.  */

-  md5_finish_ctx (&ctx, resblock);

-  return 0;

-}

-

-/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The

-   result is always in little endian byte order, so that a byte-wise

-   output yields to the wanted ASCII representation of the message

-   digest.  */

-void *

-md5_buffer (buffer, len, resblock)

-     const char *buffer;

-     size_t len;

-     void *resblock;

-{

-  struct md5_ctx ctx;

-

-  /* Initialize the computation context.  */

-  md5_init_ctx (&ctx);

-

-  /* Process whole buffer but last len % 64 bytes.  */

-  md5_process_bytes (buffer, len, &ctx);

-  /* Put result in desired memory area.  */

-  return md5_finish_ctx (&ctx, resblock);

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

+ */

 void

-md5_process_bytes (buffer, len, ctx)

-     const void *buffer;

-     size_t len;

-     struct md5_ctx *ctx;

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

 {

-  /* When we already have some bits in our internal buffer concatenate

-     both inputs first.  */

-  if (ctx->buflen != 0)

-    {

-      size_t left_over = ctx->buflen;

-      size_t add = 128 - left_over > len ? len : 128 - left_over;

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

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

-      /* Only put full words in the buffer.  */

-      add -= add % __alignof__ (md5_uint32);

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

+	*p++ = 0x80;

-      memcpy (&ctx->buffer[left_over], buffer, add);

-      ctx->buflen += add;

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

+	count = 56 - 1 - count;

-      if (ctx->buflen > 64)

-	{

-	  md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);

-

-	  ctx->buflen &= 63;

-	  /* The regions in the following copy operation cannot overlap.  */

-	  memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],

-		  ctx->buflen);

+	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);

-      buffer = (const char *) buffer + add;

-      len -= add;

-    }

-

-  /* Process available complete blocks.  */

-  if (len > 64)

-    {

-      md5_process_block (buffer, len & ~63, ctx);

-      buffer = (const char *) buffer + (len & ~63);

-      len &= 63;

-    }

-

-  /* Move remaining bytes in internal buffer.  */

-  if (len > 0)

-    {

-      size_t left_over = ctx->buflen;

+	/* 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);

-      memcpy (&ctx->buffer[left_over], buffer, len);

-      left_over += len;

-      if (left_over >= 64)

-	{

-	  md5_process_block (ctx->buffer, 64, ctx);

-	  left_over -= 64;

-	  memcpy (ctx->buffer, &ctx->buffer[64], left_over);

-	}

-      ctx->buflen = left_over;

-    }

+	byteSwap(ctx->buf, 4);

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

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

 }

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

-/* These are the four functions used in the four steps of the MD5 algorithm

-   and defined in the RFC 1321.  The first function is a little bit optimized

-   (as found in Colin Plumbs public domain implementation).  */

-/* #define FF(b, c, d) ((b & c) | (~b & d)) */

-#define FF(b, c, d) (d ^ (b & (c ^ d)))

-#define FG(b, c, d) FF (d, b, c)

-#define FH(b, c, d) (b ^ c ^ d)

-#define FI(b, c, d) (c ^ (b | ~d))

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

-/* Process LEN bytes of BUFFER, accumulating context into CTX.

-   It is assumed that LEN % 64 == 0.  */

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

+/*

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

-md5_process_block (buffer, len, ctx)

-     const void *buffer;

-     size_t len;

-     struct md5_ctx *ctx;

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

 {

-  md5_uint32 correct_words[16];

-  const md5_uint32 *words = buffer;

-  size_t nwords = len / sizeof (md5_uint32);

-  const md5_uint32 *endp = words + nwords;

-  md5_uint32 A = ctx->A;

-  md5_uint32 B = ctx->B;

-  md5_uint32 C = ctx->C;

-  md5_uint32 D = ctx->D;

-

-  /* First increment the byte count.  RFC 1321 specifies the possible

-     length of the file up to 2^64 bits.  Here we only compute the

-     number of bytes.  Do a double word increment.  */

-  ctx->total[0] += len;

-  if (ctx->total[0] < len)

-    ++ctx->total[1];

-

-  /* Process all bytes in the buffer with 64 bytes in each round of

-     the loop.  */

-  while (words < endp)

-    {

-      md5_uint32 *cwp = correct_words;

-      md5_uint32 A_save = A;

-      md5_uint32 B_save = B;

-      md5_uint32 C_save = C;

-      md5_uint32 D_save = D;

-

-      /* First round: using the given function, the context and a constant

-	 the next context is computed.  Because the algorithms processing

-	 unit is a 32-bit word and it is determined to work on words in

-	 little endian byte order we perhaps have to change the byte order

-	 before the computation.  To reduce the work for the next steps

-	 we store the swapped words in the array CORRECT_WORDS.  */

-

-#define OP(a, b, c, d, s, T)						\

-      do								\

-        {								\

-	  a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;		\

-	  ++words;							\

-	  CYCLIC (a, s);						\

-	  a += b;							\

-        }								\

-      while (0)

-

-      /* It is unfortunate that C does not provide an operator for

-	 cyclic rotation.  Hope the C compiler is smart enough.  */

-#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))

-

-      /* Before we start, one word to the strange constants.

-	 They are defined in RFC 1321 as

-

-	 T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64

-       */

-

-      /* Round 1.  */

-      OP (A, B, C, D,  7, 0xd76aa478);

-      OP (D, A, B, C, 12, 0xe8c7b756);

-      OP (C, D, A, B, 17, 0x242070db);

-      OP (B, C, D, A, 22, 0xc1bdceee);

-      OP (A, B, C, D,  7, 0xf57c0faf);

-      OP (D, A, B, C, 12, 0x4787c62a);

-      OP (C, D, A, B, 17, 0xa8304613);

-      OP (B, C, D, A, 22, 0xfd469501);

-      OP (A, B, C, D,  7, 0x698098d8);

-      OP (D, A, B, C, 12, 0x8b44f7af);

-      OP (C, D, A, B, 17, 0xffff5bb1);

-      OP (B, C, D, A, 22, 0x895cd7be);

-      OP (A, B, C, D,  7, 0x6b901122);

-      OP (D, A, B, C, 12, 0xfd987193);

-      OP (C, D, A, B, 17, 0xa679438e);

-      OP (B, C, D, A, 22, 0x49b40821);

-

-      /* For the second to fourth round we have the possibly swapped words

-	 in CORRECT_WORDS.  Redefine the macro to take an additional first

-	 argument specifying the function to use.  */

-#undef OP

-#define OP(f, a, b, c, d, k, s, T)					\

-      do 								\

-	{								\

-	  a += f (b, c, d) + correct_words[k] + T;			\

-	  CYCLIC (a, s);						\

-	  a += b;							\

-	}								\

-      while (0)

-

-      /* Round 2.  */

-      OP (FG, A, B, C, D,  1,  5, 0xf61e2562);

-      OP (FG, D, A, B, C,  6,  9, 0xc040b340);

-      OP (FG, C, D, A, B, 11, 14, 0x265e5a51);

-      OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);

-      OP (FG, A, B, C, D,  5,  5, 0xd62f105d);

-      OP (FG, D, A, B, C, 10,  9, 0x02441453);

-      OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);

-      OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);

-      OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);

-      OP (FG, D, A, B, C, 14,  9, 0xc33707d6);

-      OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);

-      OP (FG, B, C, D, A,  8, 20, 0x455a14ed);

-      OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);

-      OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);

-      OP (FG, C, D, A, B,  7, 14, 0x676f02d9);

-      OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);

-

-      /* Round 3.  */

-      OP (FH, A, B, C, D,  5,  4, 0xfffa3942);

-      OP (FH, D, A, B, C,  8, 11, 0x8771f681);

-      OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);

-      OP (FH, B, C, D, A, 14, 23, 0xfde5380c);

-      OP (FH, A, B, C, D,  1,  4, 0xa4beea44);

-      OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);

-      OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);

-      OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);

-      OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);

-      OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);

-      OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);

-      OP (FH, B, C, D, A,  6, 23, 0x04881d05);

-      OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);

-      OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);

-      OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);

-      OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);

-

-      /* Round 4.  */

-      OP (FI, A, B, C, D,  0,  6, 0xf4292244);

-      OP (FI, D, A, B, C,  7, 10, 0x432aff97);

-      OP (FI, C, D, A, B, 14, 15, 0xab9423a7);

-      OP (FI, B, C, D, A,  5, 21, 0xfc93a039);

-      OP (FI, A, B, C, D, 12,  6, 0x655b59c3);

-      OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);

-      OP (FI, C, D, A, B, 10, 15, 0xffeff47d);

-      OP (FI, B, C, D, A,  1, 21, 0x85845dd1);

-      OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);

-      OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);

-      OP (FI, C, D, A, B,  6, 15, 0xa3014314);

-      OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);

-      OP (FI, A, B, C, D,  4,  6, 0xf7537e82);

-      OP (FI, D, A, B, C, 11, 10, 0xbd3af235);

-      OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);

-      OP (FI, B, C, D, A,  9, 21, 0xeb86d391);

-

-      /* Add the starting values of the context.  */

-      A += A_save;

-      B += B_save;

-      C += C_save;

-      D += D_save;

-    }

-

-  /* Put checksum in context given as argument.  */

-  ctx->A = A;

-  ctx->B = B;

-  ctx->C = C;

-  ctx->D = D;

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

 }

@@ -1,164 +1,37 @@

-/* Declaration of functions and data types used for MD5 sum computing

-   library functions.

-   Copyright (C) 1995, 1996, 1997, 1999, 2000 Free Software Foundation, Inc.

-   This file is part of the GNU C Library.

-

-   The GNU C Library is free software; you can redistribute it and/or

-   modify it under the terms of the GNU Library General Public License as

-   published by the Free Software Foundation; either version 2 of the

-   License, or (at your option) any later version.

-

-   The GNU C Library is distributed in the hope that it will be useful,

-   but WITHOUT ANY WARRANTY; without even the implied warranty of

-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

-   Library General Public License for more details.

-

-   You should have received a copy of the GNU Library General Public

-   License along with the GNU C Library; see the file COPYING.LIB.  If not,

-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

-   Boston, MA 02111-1307, USA.  */

-

-#ifndef _MD5_H

-#define _MD5_H 1

-

-#include <stdio.h>

-

-#if defined HAVE_LIMITS_H || _LIBC

-# include <limits.h>

-#endif

-

-/* The following contortions are an attempt to use the C preprocessor

-   to determine an unsigned integral type that is 32 bits wide.  An

-   alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but

-   doing that would require that the configure script compile and *run*

-   the resulting executable.  Locally running cross-compiled executables

-   is usually not possible.  */

-

-#ifdef _LIBC

-# include <sys/types.h>

-typedef u_int32_t md5_uint32;

-#else

-# if defined __STDC__ && __STDC__

-#  define UINT_MAX_32_BITS 4294967295U

-# else

-#  define UINT_MAX_32_BITS 0xFFFFFFFF

-# endif

-

-/* If UINT_MAX isn't defined, assume it's a 32-bit type.

-   This should be valid for all systems GNU cares about because

-   that doesn't include 16-bit systems, and only modern systems

-   (that certainly have <limits.h>) have 64+-bit integral types.  */

-

-# ifndef UINT_MAX

-#  define UINT_MAX UINT_MAX_32_BITS

-# endif

-

-# if UINT_MAX == UINT_MAX_32_BITS

-   typedef unsigned int md5_uint32;

-# else

-#  if USHRT_MAX == UINT_MAX_32_BITS

-    typedef unsigned short md5_uint32;

-#  else

-#   if ULONG_MAX == UINT_MAX_32_BITS

-     typedef unsigned long md5_uint32;

-#   else

-     /* The following line is intended to evoke an error.

-        Using #error is not portable enough.  */

-     "Cannot determine unsigned 32-bit data type."

-#   endif

-#  endif

-# endif

-#endif

-

-#undef __P

-#if defined (__STDC__) && __STDC__

-# define __P(x) x

-#else

-# define __P(x) ()

-#endif

-

-/* Structure to save state of computation between the single steps.  */

-struct md5_ctx

-{

-  md5_uint32 A;

-  md5_uint32 B;

-  md5_uint32 C;

-  md5_uint32 D;

-

-  md5_uint32 total[2];

-  md5_uint32 buflen;

-#ifndef __attribute__

-  char buffer[128];

-#else

-  char buffer[128] __attribute__ ((__aligned__ (__alignof__ (md5_uint32))));

-#endif

-};

-

-#ifndef __attribute__

-#define __alignof__(a)	sizeof(a)

-#endif

-

 /*

- * The following three functions are build up the low level used in

- * the functions `md5_stream' and `md5_buffer'.

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

+ *

  */

-/* Initialize structure containing state of computation.

-   (RFC 1321, 3.3: Step 3)  */

-extern void __md5_init_ctx __P ((struct md5_ctx *ctx));

-

-/* Starting with the result of former calls of this function (or the

-   initialization function update the context for the next LEN bytes

-   starting at BUFFER.

-   It is necessary that LEN is a multiple of 64!!! */

-extern void __md5_process_block __P ((const void *buffer, size_t len,

-				      struct md5_ctx *ctx));

-

-/* Starting with the result of former calls of this function (or the

-   initialization function update the context for the next LEN bytes

-   starting at BUFFER.

-   It is NOT required that LEN is a multiple of 64.  */

-extern void __md5_process_bytes __P ((const void *buffer, size_t len,

-				      struct md5_ctx *ctx));

+#ifndef __MD5_H

+#define __MD5_H

-/* Process the remaining bytes in the buffer and put result from CTX

-   in first 16 bytes following RESBUF.  The result is always in little

-   endian byte order, so that a byte-wise output yields to the wanted

-   ASCII representation of the message digest.

+#define md5byte unsigned char

-   IMPORTANT: On some systems it is required that RESBUF is correctly

-   aligned for a 32 bits value.  */

-extern void *__md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));

-

-

-/* Put result from CTX in first 16 bytes following RESBUF.  The result is

-   always in little endian byte order, so that a byte-wise output yields

-   to the wanted ASCII representation of the message digest.

-

-   IMPORTANT: On some systems it is required that RESBUF is correctly

-   aligned for a 32 bits value.  */

-extern void *__md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));

-