[apt-legacy.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							/*{{{*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/md5.h"
#endif

#include <apt-pkg/md5.h>
#include <apt-pkg/strutl.h>

#include <string.h>
#include <unistd.h>
#include <netinet/in.h>                          // For htonl
#include <inttypes.h>
#include <config.h>
#include <system.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;
}
									/*}}}*/
// MD5SumValue::MD5SumValue - Constructs the summation from a string	/*{{{*/
// ---------------------------------------------------------------------
/* The string form of a MD5 is a 32 character hex number */
MD5SumValue::MD5SumValue(string Str)
{
   memset(Sum,0,sizeof(Sum));
   Set(Str);
}
									/*}}}*/
// MD5SumValue::MD5SumValue - Default constructor			/*{{{*/
// ---------------------------------------------------------------------
/* Sets the value to 0 */
MD5SumValue::MD5SumValue()
{
   memset(Sum,0,sizeof(Sum));
}
									/*}}}*/
// MD5SumValue::Set - Set the sum from a string				/*{{{*/
// ---------------------------------------------------------------------
/* Converts the hex string into a set of chars */
bool MD5SumValue::Set(string Str)
{
   return Hex2Num(Str,Sum,sizeof(Sum));
}
									/*}}}*/
// MD5SumValue::Value - Convert the number into a string		/*{{{*/
// ---------------------------------------------------------------------
/* Converts the set of chars into a hex string in lower case */
string MD5SumValue::Value() const
{
   char Conv[16] = {'0','1','2','3','4','5','6','7','8','9','a','b',
                    'c','d','e','f'};
   char Result[33];
   Result[32] = 0;
   
   // Convert each char into two letters
   int J = 0;
   int I = 0;
   for (; I != 32; J++, I += 2)
   {
      Result[I] = Conv[Sum[J] >> 4];
      Result[I + 1] = Conv[Sum[J] & 0xF];
   } 

   return string(Result);
}
									/*}}}*/
// MD5SumValue::operator == - Comparitor				/*{{{*/
// ---------------------------------------------------------------------
/* Call memcmp on the buffer */
bool MD5SumValue::operator ==(const MD5SumValue &rhs) const
{
   return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
}
									/*}}}*/
// 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 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::AddFD - Add the contents of a FD to the hash		/*{{{*/
// ---------------------------------------------------------------------
/* */
bool MD5Summation::AddFD(int Fd,unsigned long Size)
{
   unsigned char Buf[64*64];
   int Res = 0;
   while (Size != 0)
   {
      Res = read(Fd,Buf,min(Size,(unsigned long)sizeof(Buf)));
      if (Res < 0 || (unsigned)Res != min(Size,(unsigned long)sizeof(Buf)))
	 return false;
      Size -= Res;
      Add(Buf,Res);
   }
   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;
   memcpy(V.Sum,buf,16);
   return V;
}
									/*}}}*/
Commit	Line	Data
da6ee469 JF	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	// $Id: md5.cc,v 1.12 2001/05/13 05:15:03 jgg Exp $
	4	/* ######################################################################
	5
	6	MD5Sum - MD5 Message Digest Algorithm.
	7
	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.
	12
	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
	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
	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
	34
	35	##################################################################### */
	36	/}}}/
	37	// Include Files /{{{/
	38	#ifdef __GNUG__
	39	#pragma implementation "apt-pkg/md5.h"
	40	#endif
	41
	42	#include <apt-pkg/md5.h>
	43	#include <apt-pkg/strutl.h>
	44
	45	#include <string.h>
	46	#include <unistd.h>
	47	#include <netinet/in.h> // For htonl
	48	#include <inttypes.h>
	49	#include <config.h>
	50	#include <system.h>
	51	/}}}/
	52
	53	// byteSwap - Swap bytes in a buffer /{{{/
	54	// ---------------------------------------------------------------------
	55	/* Swap n 32 bit longs in given buffer */
	56	#ifdef WORDS_BIGENDIAN
	57	static void byteSwap(uint32_t *buf, unsigned words)
	58	{
	59	uint8_t p = (uint8_t )buf;
	60
	61	do
	62	{
	63	*buf++ = (uint32_t)((unsigned)p[3] << 8 \| p[2]) << 16 \|
	64	((unsigned)p[1] << 8 \| p[0]);
65	p += 4;
66	} while (--words);
67	}
68	#else
69	#define byteSwap(buf,words)
70	#endif
71	/}}}/
72	// MD5Transform - Alters an existing MD5 hash /{{{/
73	// ---------------------------------------------------------------------
74	/* The core of the MD5 algorithm, this alters an existing MD5 hash to
75	reflect the addition of 16 longwords of new data. Add blocks
76	the data and converts bytes into longwords for this routine. */
77
78	// The four core functions - F1 is optimized somewhat
79	// #define F1(x, y, z) (x & y \| ~x & z)
80	#define F1(x, y, z) (z ^ (x & (y ^ z)))
81	#define F2(x, y, z) F1(z, x, y)
82	#define F3(x, y, z) (x ^ y ^ z)
83	#define F4(x, y, z) (y ^ (x \| ~z))
84
85	// This is the central step in the MD5 algorithm.
86	#define MD5STEP(f,w,x,y,z,in,s) \
87	(w += f(x,y,z) + in, w = (w<<s \| w>>(32-s)) + x)
88
89	static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
90	{
91	register uint32_t a, b, c, d;
92
93	a = buf[0];
94	b = buf[1];
95	c = buf[2];
96	d = buf[3];
97
98	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
99	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
100	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
101	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
102	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
103	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
104	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
105	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
106	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
107	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
108	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
109	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
110	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
111	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
112	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
113	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
114
115	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
116	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
117	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
118	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
119	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
120	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
121	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
122	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
123	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
124	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
125	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
126	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
127	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
128	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
129	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
130	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
131
132	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
133	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
134	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
135	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
136	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
137	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
138	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
139	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
140	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
141	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
142	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
143	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
144	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
145	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
146	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
147	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
148
149	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
150	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
151	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
152	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
153	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
154	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
155	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
156	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
157	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
158	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
159	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
160	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
161	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
162	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
163	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
164	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
165
166	buf[0] += a;
167	buf[1] += b;
168	buf[2] += c;
169	buf[3] += d;
170	}
171	/}}}/
172	// MD5SumValue::MD5SumValue - Constructs the summation from a string /{{{/
173	// ---------------------------------------------------------------------
174	/* The string form of a MD5 is a 32 character hex number */
175	MD5SumValue::MD5SumValue(string Str)
176	{
177	memset(Sum,0,sizeof(Sum));
178	Set(Str);
179	}
180	/}}}/
181	// MD5SumValue::MD5SumValue - Default constructor /{{{/
182	// ---------------------------------------------------------------------
183	/* Sets the value to 0 */
184	MD5SumValue::MD5SumValue()
185	{
186	memset(Sum,0,sizeof(Sum));
187	}
188	/}}}/
189	// MD5SumValue::Set - Set the sum from a string /{{{/
190	// ---------------------------------------------------------------------
191	/* Converts the hex string into a set of chars */
192	bool MD5SumValue::Set(string Str)
193	{
194	return Hex2Num(Str,Sum,sizeof(Sum));
195	}
196	/}}}/
197	// MD5SumValue::Value - Convert the number into a string /{{{/
198	// ---------------------------------------------------------------------
199	/* Converts the set of chars into a hex string in lower case */
200	string MD5SumValue::Value() const
201	{
202	char Conv[16] = {'0','1','2','3','4','5','6','7','8','9','a','b',
203	'c','d','e','f'};
204	char Result[33];
205	Result[32] = 0;
206
207	// Convert each char into two letters
208	int J = 0;
209	int I = 0;
210	for (; I != 32; J++, I += 2)
211	{
212	Result[I] = Conv[Sum[J] >> 4];
213	Result[I + 1] = Conv[Sum[J] & 0xF];
214	}
215
216	return string(Result);
217	}
218	/}}}/
219	// MD5SumValue::operator == - Comparitor /{{{/
220	// ---------------------------------------------------------------------
221	/* Call memcmp on the buffer */
222	bool MD5SumValue::operator ==(const MD5SumValue &rhs) const
223	{
224	return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
225	}
226	/}}}/
227	// MD5Summation::MD5Summation - Initialize the summer /{{{/
228	// ---------------------------------------------------------------------
229	/* This assigns the deep magic initial values */
230	MD5Summation::MD5Summation()
231	{
232	uint32_t buf = (uint32_t )Buf;
233	uint32_t bytes = (uint32_t )Bytes;
234
235	buf[0] = 0x67452301;
236	buf[1] = 0xefcdab89;
237	buf[2] = 0x98badcfe;
238	buf[3] = 0x10325476;
239
240	bytes[0] = 0;
241	bytes[1] = 0;
242	Done = false;
243	}
244	/}}}/
245	// MD5Summation::Add - 'Add' a data set to the hash /{{{/
246	// ---------------------------------------------------------------------
247	/* */
248	bool MD5Summation::Add(const unsigned char *data,unsigned long len)
249	{
250	if (Done == true)
251	return false;
252
253	uint32_t buf = (uint32_t )Buf;
254	uint32_t bytes = (uint32_t )Bytes;
255	uint32_t in = (uint32_t )In;
256
257	// Update byte count and carry (this could be done with a long long?)
258	uint32_t t = bytes[0];
259	if ((bytes[0] = t + len) < t)
260	bytes[1]++;
261
262	// Space available (at least 1)
263	t = 64 - (t & 0x3f);
264	if (t > len)
265	{
266	memcpy((unsigned char *)in + 64 - t,data,len);
267	return true;
268	}
269
270	// First chunk is an odd size
271	memcpy((unsigned char *)in + 64 - t,data,t);
272	byteSwap(in, 16);
273	MD5Transform(buf,in);
274	data += t;
275	len -= t;
276
277	// Process data in 64-byte chunks
278	while (len >= 64)
279	{
280	memcpy(in,data,64);
281	byteSwap(in,16);
282	MD5Transform(buf,in);
283	data += 64;
284	len -= 64;
285	}
286
287	// Handle any remaining bytes of data.
288	memcpy(in,data,len);
289
290	return true;
291	}
292	/}}}/
293	// MD5Summation::AddFD - Add the contents of a FD to the hash /{{{/
294	// ---------------------------------------------------------------------
295	/* */
296	bool MD5Summation::AddFD(int Fd,unsigned long Size)
297	{
298	unsigned char Buf[64*64];
299	int Res = 0;
300	while (Size != 0)
301	{
302	Res = read(Fd,Buf,min(Size,(unsigned long)sizeof(Buf)));
303	if (Res < 0 \|\| (unsigned)Res != min(Size,(unsigned long)sizeof(Buf)))
304	return false;
305	Size -= Res;
306	Add(Buf,Res);
307	}
308	return true;
309	}
310	/}}}/
311	// MD5Summation::Result - Returns the value of the sum /{{{/
312	// ---------------------------------------------------------------------
313	/* Because this must add in the last bytes of the series it prevents anyone
314	from calling add after. */
315	MD5SumValue MD5Summation::Result()
316	{
317	uint32_t buf = (uint32_t )Buf;
318	uint32_t bytes = (uint32_t )Bytes;
319	uint32_t in = (uint32_t )In;
320
321	if (Done == false)
322	{
323	// Number of bytes in In
324	int count = bytes[0] & 0x3f;
325	unsigned char p = (unsigned char )in + count;
326
327	// Set the first char of padding to 0x80. There is always room.
328	*p++ = 0x80;
329
330	// Bytes of padding needed to make 56 bytes (-8..55)
331	count = 56 - 1 - count;
332
333	// Padding forces an extra block
334	if (count < 0)
335	{
336	memset(p,0,count + 8);
337	byteSwap(in, 16);
338	MD5Transform(buf,in);
339	p = (unsigned char *)in;
340	count = 56;
341	}
342
343	memset(p, 0, count);
344	byteSwap(in, 14);
345
346	// Append length in bits and transform
347	in[14] = bytes[0] << 3;
348	in[15] = bytes[1] << 3 \| bytes[0] >> 29;
349	MD5Transform(buf,in);
350	byteSwap(buf,4);
351	Done = true;
352	}
353
354	MD5SumValue V;
355	memcpy(V.Sum,buf,16);
356	return V;
357	}
358	/}}}/