[ntk/apt.git] / apt-pkg / contrib / md5.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: md5.cc,v 1.12 2001/05/13 05:15:03 jgg Exp $
/* ######################################################################
   
   MD5Sum - MD5 Message Digest Algorithm.

   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, instantiate the class,
   and repeatedly call one of the Add() members. When finished the Result 
   method will return the Hash and finalize the value.
   
   Changed so as no longer to depend on Colin Plumb's `usual.h' header
   definitions; now uses stuff from dpkg's config.h.
    - Ian Jackson <ijackson@nyx.cs.du.edu>.
   
   Changed into a C++ interface and made work with APT's config.h.
    - Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
   
   Still in the public domain.

   The classes use arrays of char that are a specific size. We cast those
   arrays to uint8_t's and go from there. This allows us to advoid using
   the uncommon inttypes.h in a public header or internally newing memory.
   In theory if C9x becomes nicely accepted
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <config.h>

#include <apt-pkg/md5.h>

#include <stdint.h>
#include <string.h>
									/*}}}*/

// byteSwap - Swap bytes in a buffer					/*{{{*/
// ---------------------------------------------------------------------
/* Swap n 32 bit longs in given buffer */
#ifdef WORDS_BIGENDIAN
static void byteSwap(uint32_t *buf, unsigned words)
{
   uint8_t *p = (uint8_t *)buf;
   
   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
									/*}}}*/
// MD5Transform - Alters an existing MD5 hash				/*{{{*/
// ---------------------------------------------------------------------
/* The core of the MD5 algorithm, this alters an existing MD5 hash to
   reflect the addition of 16 longwords of new data. Add blocks
   the data and converts bytes into longwords for this routine. */

// 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,in,s) \
	 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)

static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
{
   register 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;
}
									/*}}}*/
// MD5Summation::MD5Summation - Initialize the summer			/*{{{*/
// ---------------------------------------------------------------------
/* This assigns the deep magic initial values */
MD5Summation::MD5Summation()
{
   uint32_t *buf = (uint32_t *)Buf;
   uint32_t *bytes = (uint32_t *)Bytes;
   
   buf[0] = 0x67452301;
   buf[1] = 0xefcdab89;
   buf[2] = 0x98badcfe;
   buf[3] = 0x10325476;
   
   bytes[0] = 0;
   bytes[1] = 0;
   Done = false;
}
									/*}}}*/
// MD5Summation::Add - 'Add' a data set to the hash			/*{{{*/
// ---------------------------------------------------------------------
/* */
bool MD5Summation::Add(const unsigned char *data,unsigned long long len)
{
   if (Done == true)
      return false;

   uint32_t *buf = (uint32_t *)Buf;
   uint32_t *bytes = (uint32_t *)Bytes;
   uint32_t *in = (uint32_t *)In;

   // Update byte count and carry (this could be done with a long long?)
   uint32_t t = bytes[0];
   if ((bytes[0] = t + len) < t)
      bytes[1]++;	

   // Space available (at least 1)
   t = 64 - (t & 0x3f);	
   if (t > len) 
   {
      memcpy((unsigned char *)in + 64 - t,data,len);
      return true;
   }

   // First chunk is an odd size
   memcpy((unsigned char *)in + 64 - t,data,t);
   byteSwap(in, 16);
   MD5Transform(buf,in);
   data += t;
   len -= t;
   
   // Process data in 64-byte chunks
   while (len >= 64)
   {
      memcpy(in,data,64);
      byteSwap(in,16);
      MD5Transform(buf,in);
      data += 64;
      len -= 64;
   }

   // Handle any remaining bytes of data.
   memcpy(in,data,len);

   return true;   
}
									/*}}}*/
// MD5Summation::Result - Returns the value of the sum			/*{{{*/
// ---------------------------------------------------------------------
/* Because this must add in the last bytes of the series it prevents anyone
   from calling add after. */
MD5SumValue MD5Summation::Result()
{
   uint32_t *buf = (uint32_t *)Buf;
   uint32_t *bytes = (uint32_t *)Bytes;
   uint32_t *in = (uint32_t *)In;
   
   if (Done == false)
   {
      // Number of bytes in In
      int count = bytes[0] & 0x3f;	
      unsigned char *p = (unsigned char *)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;
      
      // Padding forces an extra block 
      if (count < 0) 
      {
	 memset(p,0,count + 8);
	 byteSwap(in, 16);
	 MD5Transform(buf,in);
	 p = (unsigned char *)in;
	 count = 56;
      }
      
      memset(p, 0, count);
      byteSwap(in, 14);
      
      // Append length in bits and transform
      in[14] = bytes[0] << 3;
      in[15] = bytes[1] << 3 | bytes[0] >> 29;
      MD5Transform(buf,in);   
      byteSwap(buf,4);
      Done = true;
   }
   
   MD5SumValue V;
   V.Set((unsigned char *)buf);
   return V;
}
									/*}}}*/
Commit	Line	Data
17a10bf5 AL	1	// -- mode: cpp; mode: fold --
17a10bf5 AL	2	// Description /{{{/
c1ebf56d	3	// $Id: md5.cc,v 1.12 2001/05/13 05:15:03 jgg Exp $
17a10bf5 AL	4	/* ######################################################################
	5
	6	MD5Sum - MD5 Message Digest Algorithm.
	7
6e52073f AL	8	This code implements the MD5 message-digest algorithm. The algorithm is
	9	due to Ron Rivest. This code was written by Colin Plumb in 1993, no
	10	copyright is claimed. This code is in the public domain; do with it what
	11	you wish.
17a10bf5	12
6e52073f AL	13	Equivalent code is available from RSA Data Security, Inc. This code has
	14	been tested against that, and is equivalent, except that you don't need to
	15	include two pages of legalese with every copy.
	16
	17	To compute the message digest of a chunk of bytes, instantiate the class,
	18	and repeatedly call one of the Add() members. When finished the Result
	19	method will return the Hash and finalize the value.
	20
17a10bf5 AL	21	Changed so as no longer to depend on Colin Plumb's `usual.h' header
	22	definitions; now uses stuff from dpkg's config.h.
	23	- Ian Jackson <ijackson@nyx.cs.du.edu>.
	24
	25	Changed into a C++ interface and made work with APT's config.h.
	26	- Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
	27
	28	Still in the public domain.
	29
	30	The classes use arrays of char that are a specific size. We cast those
67a51bcc AL	31	arrays to uint8_t's and go from there. This allows us to advoid using
	32	the uncommon inttypes.h in a public header or internally newing memory.
	33	In theory if C9x becomes nicely accepted
17a10bf5	34
17a10bf5 AL	35	##################################################################### */
	36	/}}}/
	37	// Include Files /{{{/
ea542140 DK	38	#include <config.h>
ea542140 DK	39
17a10bf5	40	#include <apt-pkg/md5.h>
6e52073f	41
453b82a3	42	#include <stdint.h>
17a10bf5	43	#include <string.h>
17a10bf5 AL	44	/}}}/
	45
	46	// byteSwap - Swap bytes in a buffer /{{{/
	47	// ---------------------------------------------------------------------
67a51bcc	48	/* Swap n 32 bit longs in given buffer */
83ab33fc	49	#ifdef WORDS_BIGENDIAN
95baf595	50	static void byteSwap(uint32_t *buf, unsigned words)
17a10bf5	51	{
83ab33fc AL	52	uint8_t p = (uint8_t )buf;
	53
	54	do
17a10bf5	55	{
59257a21	56	*buf++ = (uint32_t)((unsigned)p[3] << 8 \| p[2]) << 16 \|
83ab33fc AL	57	((unsigned)p[1] << 8 \| p[0]);
	58	p += 4;
	59	} while (--words);
17a10bf5	60	}
83ab33fc AL	61	#else
	62	#define byteSwap(buf,words)
	63	#endif
17a10bf5 AL	64	/}}}/
	65	// MD5Transform - Alters an existing MD5 hash /{{{/
	66	// ---------------------------------------------------------------------
	67	/* The core of the MD5 algorithm, this alters an existing MD5 hash to
6e52073f	68	reflect the addition of 16 longwords of new data. Add blocks
17a10bf5 AL	69	the data and converts bytes into longwords for this routine. */
	70
	71	// The four core functions - F1 is optimized somewhat
	72	// #define F1(x, y, z) (x & y \| ~x & z)
	73	#define F1(x, y, z) (z ^ (x & (y ^ z)))
	74	#define F2(x, y, z) F1(z, x, y)
	75	#define F3(x, y, z) (x ^ y ^ z)
	76	#define F4(x, y, z) (y ^ (x \| ~z))
	77
	78	// This is the central step in the MD5 algorithm.
	79	#define MD5STEP(f,w,x,y,z,in,s) \
	80	(w += f(x,y,z) + in, w = (w<<s \| w>>(32-s)) + x)
	81
021988ea	82	static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
17a10bf5	83	{
021988ea	84	register uint32_t a, b, c, d;
17a10bf5 AL	85
	86	a = buf[0];
	87	b = buf[1];
	88	c = buf[2];
	89	d = buf[3];
	90
	91	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
	92	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
	93	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
	94	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
	95	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
	96	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
	97	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
	98	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
	99	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
	100	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
	101	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
	102	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
	103	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
	104	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
	105	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
	106	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
	107
	108	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
	109	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
	110	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
	111	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
	112	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
	113	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
	114	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
	115	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
	116	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
	117	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
	118	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
	119	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
	120	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
	121	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
	122	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
	123	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
	124
	125	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
	126	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
	127	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
	128	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
	129	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
	130	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
	131	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
	132	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
	133	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
	134	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
	135	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
	136	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
	137	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
	138	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
	139	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
	140	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
	141
	142	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
	143	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
	144	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
	145	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
	146	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
	147	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
	148	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
149	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
150	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
151	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
152	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
153	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
154	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
155	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
156	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
157	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
158
159	buf[0] += a;
160	buf[1] += b;
161	buf[2] += c;
162	buf[3] += d;
163	}
164	/}}}/
17a10bf5 AL	165	// MD5Summation::MD5Summation - Initialize the summer /{{{/
	166	// ---------------------------------------------------------------------
	167	/* This assigns the deep magic initial values */
	168	MD5Summation::MD5Summation()
	169	{
021988ea AL	170	uint32_t buf = (uint32_t )Buf;
021988ea AL	171	uint32_t bytes = (uint32_t )Bytes;
17a10bf5 AL	172
	173	buf[0] = 0x67452301;
	174	buf[1] = 0xefcdab89;
	175	buf[2] = 0x98badcfe;
	176	buf[3] = 0x10325476;
	177
	178	bytes[0] = 0;
	179	bytes[1] = 0;
	180	Done = false;
	181	}
	182	/}}}/
6e52073f	183	// MD5Summation::Add - 'Add' a data set to the hash /{{{/
17a10bf5 AL	184	// ---------------------------------------------------------------------
17a10bf5 AL	185	/* */
650faab0	186	bool MD5Summation::Add(const unsigned char *data,unsigned long long len)
17a10bf5 AL	187	{
	188	if (Done == true)
	189	return false;
	190
021988ea AL	191	uint32_t buf = (uint32_t )Buf;
	192	uint32_t bytes = (uint32_t )Bytes;
	193	uint32_t in = (uint32_t )In;
17a10bf5 AL	194
17a10bf5 AL	195	// Update byte count and carry (this could be done with a long long?)
021988ea	196	uint32_t t = bytes[0];
17a10bf5 AL	197	if ((bytes[0] = t + len) < t)
	198	bytes[1]++;
	199
6e52073f	200	// Space available (at least 1)
17a10bf5 AL	201	t = 64 - (t & 0x3f);
	202	if (t > len)
	203	{
	204	memcpy((unsigned char *)in + 64 - t,data,len);
	205	return true;
	206	}
	207
	208	// First chunk is an odd size
	209	memcpy((unsigned char *)in + 64 - t,data,t);
95baf595	210	byteSwap(in, 16);
17a10bf5 AL	211	MD5Transform(buf,in);
	212	data += t;
	213	len -= t;
	214
	215	// Process data in 64-byte chunks
	216	while (len >= 64)
	217	{
	218	memcpy(in,data,64);
95baf595	219	byteSwap(in,16);
17a10bf5 AL	220	MD5Transform(buf,in);
	221	data += 64;
	222	len -= 64;
	223	}
	224
	225	// Handle any remaining bytes of data.
	226	memcpy(in,data,len);
	227
	228	return true;
	229	}
	230	/}}}/
17a10bf5 AL	231	// MD5Summation::Result - Returns the value of the sum /{{{/
	232	// ---------------------------------------------------------------------
	233	/* Because this must add in the last bytes of the series it prevents anyone
	234	from calling add after. */
	235	MD5SumValue MD5Summation::Result()
	236	{
021988ea AL	237	uint32_t buf = (uint32_t )Buf;
	238	uint32_t bytes = (uint32_t )Bytes;
	239	uint32_t in = (uint32_t )In;
17a10bf5 AL	240
	241	if (Done == false)
	242	{
	243	// Number of bytes in In
	244	int count = bytes[0] & 0x3f;
	245	unsigned char p = (unsigned char )in + count;
	246
	247	// Set the first char of padding to 0x80. There is always room.
	248	*p++ = 0x80;
	249
	250	// Bytes of padding needed to make 56 bytes (-8..55)
	251	count = 56 - 1 - count;
	252
	253	// Padding forces an extra block
	254	if (count < 0)
	255	{
	256	memset(p,0,count + 8);
95baf595	257	byteSwap(in, 16);
17a10bf5 AL	258	MD5Transform(buf,in);
	259	p = (unsigned char *)in;
	260	count = 56;
	261	}
	262
	263	memset(p, 0, count);
95baf595	264	byteSwap(in, 14);
17a10bf5 AL	265
	266	// Append length in bits and transform
	267	in[14] = bytes[0] << 3;
	268	in[15] = bytes[1] << 3 \| bytes[0] >> 29;
	269	MD5Transform(buf,in);
95baf595	270	byteSwap(buf,4);
17a10bf5 AL	271	Done = true;
	272	}
	273
	274	MD5SumValue V;
64767f14	275	V.Set((unsigned char *)buf);
17a10bf5 AL	276	return V;
	277	}
	278	/}}}/