[exim.git] / src / src / md5.c

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) University of Cambridge 1995 - 2018 */
/* Copyright (c) The Exim Maintainers 2020 */
/* See the file NOTICE for conditions of use and distribution. */

#ifndef STAND_ALONE
#include "exim.h"

/* For stand-alone testing, we need to have the structure defined, and
to be able to do I/O */

#else
#include <stdio.h>
#include "../mytypes.h"
typedef struct md5 {
  unsigned int length;
  unsigned int abcd[4];
  }
md5;
#endif


/*************************************************
*        Start off a new MD5 computation.        *
*************************************************/

/*
Argument:  pointer to md5 storage structure
Returns:   nothing
*/

void
md5_start(md5 *base)
{
base->abcd[0] = 0x67452301;
base->abcd[1] = 0xefcdab89;
base->abcd[2] = 0x98badcfe;
base->abcd[3] = 0x10325476;
base->length = 0;
}


/*************************************************
*       Process another 64-byte block            *
*************************************************/

/* This function implements central part of the algorithm which is described
in RFC 1321.

Arguments:
  base       pointer to md5 storage structure
  text       pointer to next 64 bytes of subject text

Returns:     nothing
*/

void
md5_mid(md5 *base, const uschar *text)
{
register unsigned int a = base->abcd[0];
register unsigned int b = base->abcd[1];
register unsigned int c = base->abcd[2];
register unsigned int d = base->abcd[3];
unsigned int X[16];
base->length += 64;

/* Load the 64 bytes into a set of working integers, treating them as 32-bit
numbers in little-endian order. */

for (int i = 0; i < 16; i++)
  {
  X[i] = (unsigned int)(text[0]) |
         ((unsigned int)(text[1]) << 8) |
         ((unsigned int)(text[2]) << 16) |
         ((unsigned int)(text[3]) << 24);
  text += 4;
  }

/* For each round of processing there is a function to be applied. We define it
as a macro each time round. */

/***********************************************
*                    Round 1                   *
*            F(X,Y,Z) = XY v not(X) Z          *
* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
***********************************************/

#define OP(a, b, c, d, k, s, ti) \
     a += ((b & c) | (~b & d)) + X[k] + (unsigned int)ti; \
     a = b + ((a << s) | (a >> (32 - s)))

OP(a, b, c, d,  0,  7, 0xd76aa478);
OP(d, a, b, c,  1, 12, 0xe8c7b756);
OP(c, d, a, b,  2, 17, 0x242070db);
OP(b, c, d, a,  3, 22, 0xc1bdceee);
OP(a, b, c, d,  4,  7, 0xf57c0faf);
OP(d, a, b, c,  5, 12, 0x4787c62a);
OP(c, d, a, b,  6, 17, 0xa8304613);
OP(b, c, d, a,  7, 22, 0xfd469501);
OP(a, b, c, d,  8,  7, 0x698098d8);
OP(d, a, b, c,  9, 12, 0x8b44f7af);
OP(c, d, a, b, 10, 17, 0xffff5bb1);
OP(b, c, d, a, 11, 22, 0x895cd7be);
OP(a, b, c, d, 12,  7, 0x6b901122);
OP(d, a, b, c, 13, 12, 0xfd987193);
OP(c, d, a, b, 14, 17, 0xa679438e);
OP(b, c, d, a, 15, 22, 0x49b40821);

#undef OP

/***********************************************
*                    Round 2                   *
*            F(X,Y,Z) = XZ v Y not(Z)          *
* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
***********************************************/

#define OP(a, b, c, d, k, s, ti) \
     a += ((b & d) | (c & ~d)) + X[k] + (unsigned int)ti; \
     a = b + ((a << s) | (a >> (32 - s)))

OP(a, b, c, d,  1,  5, 0xf61e2562);
OP(d, a, b, c,  6,  9, 0xc040b340);
OP(c, d, a, b, 11, 14, 0x265e5a51);
OP(b, c, d, a,  0, 20, 0xe9b6c7aa);
OP(a, b, c, d,  5,  5, 0xd62f105d);
OP(d, a, b, c, 10,  9, 0x02441453);
OP(c, d, a, b, 15, 14, 0xd8a1e681);
OP(b, c, d, a,  4, 20, 0xe7d3fbc8);
OP(a, b, c, d,  9,  5, 0x21e1cde6);
OP(d, a, b, c, 14,  9, 0xc33707d6);
OP(c, d, a, b,  3, 14, 0xf4d50d87);
OP(b, c, d, a,  8, 20, 0x455a14ed);
OP(a, b, c, d, 13,  5, 0xa9e3e905);
OP(d, a, b, c,  2,  9, 0xfcefa3f8);
OP(c, d, a, b,  7, 14, 0x676f02d9);
OP(b, c, d, a, 12, 20, 0x8d2a4c8a);

#undef OP

/***********************************************
*                    Round 3                   *
*            F(X,Y,Z) = X xor Y xor Z          *
* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
***********************************************/

#define OP(a, b, c, d, k, s, ti) \
     a += (b ^ c ^ d) + X[k] + (unsigned int)ti; \
     a = b + ((a << s) | (a >> (32 - s)))

OP(a, b, c, d,  5,  4, 0xfffa3942);
OP(d, a, b, c,  8, 11, 0x8771f681);
OP(c, d, a, b, 11, 16, 0x6d9d6122);
OP(b, c, d, a, 14, 23, 0xfde5380c);
OP(a, b, c, d,  1,  4, 0xa4beea44);
OP(d, a, b, c,  4, 11, 0x4bdecfa9);
OP(c, d, a, b,  7, 16, 0xf6bb4b60);
OP(b, c, d, a, 10, 23, 0xbebfbc70);
OP(a, b, c, d, 13,  4, 0x289b7ec6);
OP(d, a, b, c,  0, 11, 0xeaa127fa);
OP(c, d, a, b,  3, 16, 0xd4ef3085);
OP(b, c, d, a,  6, 23, 0x04881d05);
OP(a, b, c, d,  9,  4, 0xd9d4d039);
OP(d, a, b, c, 12, 11, 0xe6db99e5);
OP(c, d, a, b, 15, 16, 0x1fa27cf8);
OP(b, c, d, a,  2, 23, 0xc4ac5665);

#undef OP

/***********************************************
*                    Round 4                   *
*          F(X,Y,Z) = Y xor (X v not(Z))       *
* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
***********************************************/

#define OP(a, b, c, d, k, s, ti) \
     a += (c ^ (b | ~d)) + X[k] + (unsigned int)ti; \
     a = b + ((a << s) | (a >> (32 - s)))

OP(a, b, c, d,  0,  6, 0xf4292244);
OP(d, a, b, c,  7, 10, 0x432aff97);
OP(c, d, a, b, 14, 15, 0xab9423a7);
OP(b, c, d, a,  5, 21, 0xfc93a039);
OP(a, b, c, d, 12,  6, 0x655b59c3);
OP(d, a, b, c,  3, 10, 0x8f0ccc92);
OP(c, d, a, b, 10, 15, 0xffeff47d);
OP(b, c, d, a,  1, 21, 0x85845dd1);
OP(a, b, c, d,  8,  6, 0x6fa87e4f);
OP(d, a, b, c, 15, 10, 0xfe2ce6e0);
OP(c, d, a, b,  6, 15, 0xa3014314);
OP(b, c, d, a, 13, 21, 0x4e0811a1);
OP(a, b, c, d,  4,  6, 0xf7537e82);
OP(d, a, b, c, 11, 10, 0xbd3af235);
OP(c, d, a, b,  2, 15, 0x2ad7d2bb);
OP(b, c, d, a,  9, 21, 0xeb86d391);

#undef OP

/* Add the new values back into the accumulators. */

base->abcd[0] += a;
base->abcd[1] += b;
base->abcd[2] += c;
base->abcd[3] += d;
}


/*************************************************
*     Process the final text string              *
*************************************************/

/* The string may be of any length. It is padded out according to the rules
for computing MD5 digests. The final result is then converted to text form
and returned.

Arguments:
  base      pointer to the md5 storage structure
  text      pointer to the final text vector
  length    length of the final text vector
  digest    points to 16 bytes in which to place the result

Returns:    nothing
*/

void
md5_end(md5 *base, const uschar *text, int length, uschar *digest)
{
uschar work[64];

/* Process in chunks of 64 until we have less than 64 bytes left. */

while (length >= 64)
  {
  md5_mid(base, text);
  text += 64;
  length -= 64;
  }

/* If the remaining string contains more than 55 bytes, we must pad it
out to 64, process it, and then set up the final chunk as 56 bytes of
padding. If it has less than 56 bytes, we pad it out to 56 bytes as the
final chunk. */

memcpy(work, text, length);
work[length] = 0x80;

if (length > 55)
  {
  memset(work+length+1, 0, 63-length);
  md5_mid(base, work);
  base->length -= 64;
  memset(work, 0, 56);
  }
else
  {
  memset(work+length+1, 0, 55-length);
  }

/* The final 8 bytes of the final chunk are a 64-bit representation of the
length of the input string *bits*, before padding, low order word first, and
low order bytes first in each word. This implementation is designed for short
strings, and so operates with a single int counter only. */

length += base->length;   /* Total length in bytes */
length <<= 3;             /* Total length in bits */

work[56] = length         & 0xff;
work[57] = (length >>  8) & 0xff;
work[58] = (length >> 16) & 0xff;
work[59] = (length >> 24) & 0xff;

memset(work+60, 0, 4);

/* Process the final 64-byte chunk */

md5_mid(base, work);

/* Pass back the result, low-order byte first in each word. */

for (int i = 0; i < 4; i++)
  {
  register int x = base->abcd[i];
  *digest++ =  x        & 0xff;
  *digest++ = (x >>  8) & 0xff;
  *digest++ = (x >> 16) & 0xff;
  *digest++ = (x >> 24) & 0xff;
  }
}


/*************************************************
**************************************************
*             Stand-alone test program           *
**************************************************
*************************************************/

#if defined STAND_ALONE & !defined CRAM_STAND_ALONE

/* Test values */

static uschar *tests[] = {
  "", "d41d8cd98f00b204e9800998ecf8427e",

  "a", "0cc175b9c0f1b6a831c399e269772661",

  "abc", "900150983cd24fb0d6963f7d28e17f72",

  "message digest", "f96b697d7cb7938d525a2f31aaf161d0",

  "abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b",

  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
     "d174ab98d277d9f5a5611c2c9f419d9f",

  "1234567890123456789012345678901234567890123456789012345678901234567890"
  "1234567890",
    "57edf4a22be3c955ac49da2e2107b67a",

  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
    "a0842fcc02167127b0bb9a7c38e71ba8"
};

int main(void)
{
md5 base;
int i = 0x01020304;
uschar *ctest = US (&i);
uschar buffer[256];
uschar digest[16];
printf("Checking md5: %s-endian\n", (ctest[0] == 0x04)? "little" : "big");

for (i = 0; i < sizeof(tests)/sizeof(uschar *); i += 2)
  {
  uschar s[33];
  printf("%s\nShould be: %s\n", tests[i], tests[i+1]);
  md5_start(&base);
  md5_end(&base, tests[i], strlen(tests[i]), digest);
  for (int j = 0; j < 16; j++) sprintf(s+2*j, "%02x", digest[j]);
  printf("Computed:  %s\n", s);
  if (strcmp(s, tests[i+1]) != 0) printf("*** No match ***\n");
  printf("\n");
  }
}
#endif

/* End of md5.c */
Commit	Line	Data
0756eb3c PH	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
	4
f9ba5e22	5	/* Copyright (c) University of Cambridge 1995 - 2018 */
1e1ddfac	6	/* Copyright (c) The Exim Maintainers 2020 */
0756eb3c PH	7	/* See the file NOTICE for conditions of use and distribution. */
	8
	9	#ifndef STAND_ALONE
d6e81e5f	10	#include "exim.h"
0756eb3c PH	11
	12	/* For stand-alone testing, we need to have the structure defined, and
	13	to be able to do I/O */
	14
	15	#else
	16	#include <stdio.h>
	17	#include "../mytypes.h"
	18	typedef struct md5 {
	19	unsigned int length;
	20	unsigned int abcd[4];
	21	}
	22	md5;
	23	#endif
	24
	25
	26
	27	/*************************************************
	28	* Start off a new MD5 computation. *
	29	*************************************************/
	30
	31	/*
	32	Argument: pointer to md5 storage structure
	33	Returns: nothing
	34	*/
	35
	36	void
	37	md5_start(md5 *base)
	38	{
	39	base->abcd[0] = 0x67452301;
	40	base->abcd[1] = 0xefcdab89;
	41	base->abcd[2] = 0x98badcfe;
	42	base->abcd[3] = 0x10325476;
	43	base->length = 0;
	44	}
	45
	46
	47
	48	/*************************************************
	49	* Process another 64-byte block *
	50	*************************************************/
	51
	52	/* This function implements central part of the algorithm which is described
	53	in RFC 1321.
	54
	55	Arguments:
	56	base pointer to md5 storage structure
	57	text pointer to next 64 bytes of subject text
	58
	59	Returns: nothing
	60	*/
	61
	62	void
	63	md5_mid(md5 base, const uschar text)
	64	{
	65	register unsigned int a = base->abcd[0];
	66	register unsigned int b = base->abcd[1];
	67	register unsigned int c = base->abcd[2];
	68	register unsigned int d = base->abcd[3];
0756eb3c PH	69	unsigned int X[16];
	70	base->length += 64;
	71
	72	/* Load the 64 bytes into a set of working integers, treating them as 32-bit
	73	numbers in little-endian order. */
	74
d7978c0f	75	for (int i = 0; i < 16; i++)
0756eb3c PH	76	{
	77	X[i] = (unsigned int)(text[0]) \|
	78	((unsigned int)(text[1]) << 8) \|
	79	((unsigned int)(text[2]) << 16) \|
	80	((unsigned int)(text[3]) << 24);
	81	text += 4;
	82	}
	83
	84	/* For each round of processing there is a function to be applied. We define it
	85	as a macro each time round. */
	86
	87	/***********************************************
	88	* Round 1 *
	89	* F(X,Y,Z) = XY v not(X) Z *
	90	* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
	91	***********************************************/
	92
	93	#define OP(a, b, c, d, k, s, ti) \
	94	a += ((b & c) \| (~b & d)) + X[k] + (unsigned int)ti; \
	95	a = b + ((a << s) \| (a >> (32 - s)))
	96
	97	OP(a, b, c, d, 0, 7, 0xd76aa478);
	98	OP(d, a, b, c, 1, 12, 0xe8c7b756);
	99	OP(c, d, a, b, 2, 17, 0x242070db);
	100	OP(b, c, d, a, 3, 22, 0xc1bdceee);
	101	OP(a, b, c, d, 4, 7, 0xf57c0faf);
	102	OP(d, a, b, c, 5, 12, 0x4787c62a);
	103	OP(c, d, a, b, 6, 17, 0xa8304613);
	104	OP(b, c, d, a, 7, 22, 0xfd469501);
	105	OP(a, b, c, d, 8, 7, 0x698098d8);
	106	OP(d, a, b, c, 9, 12, 0x8b44f7af);
	107	OP(c, d, a, b, 10, 17, 0xffff5bb1);
	108	OP(b, c, d, a, 11, 22, 0x895cd7be);
	109	OP(a, b, c, d, 12, 7, 0x6b901122);
	110	OP(d, a, b, c, 13, 12, 0xfd987193);
	111	OP(c, d, a, b, 14, 17, 0xa679438e);
	112	OP(b, c, d, a, 15, 22, 0x49b40821);
	113
	114	#undef OP
	115
	116	/***********************************************
	117	* Round 2 *
	118	* F(X,Y,Z) = XZ v Y not(Z) *
	119	* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
	120	***********************************************/
	121
	122	#define OP(a, b, c, d, k, s, ti) \
	123	a += ((b & d) \| (c & ~d)) + X[k] + (unsigned int)ti; \
	124	a = b + ((a << s) \| (a >> (32 - s)))
	125
	126	OP(a, b, c, d, 1, 5, 0xf61e2562);
	127	OP(d, a, b, c, 6, 9, 0xc040b340);
	128	OP(c, d, a, b, 11, 14, 0x265e5a51);
	129	OP(b, c, d, a, 0, 20, 0xe9b6c7aa);
	130	OP(a, b, c, d, 5, 5, 0xd62f105d);
	131	OP(d, a, b, c, 10, 9, 0x02441453);
	132	OP(c, d, a, b, 15, 14, 0xd8a1e681);
	133	OP(b, c, d, a, 4, 20, 0xe7d3fbc8);
	134	OP(a, b, c, d, 9, 5, 0x21e1cde6);
	135	OP(d, a, b, c, 14, 9, 0xc33707d6);
	136	OP(c, d, a, b, 3, 14, 0xf4d50d87);
	137	OP(b, c, d, a, 8, 20, 0x455a14ed);
	138	OP(a, b, c, d, 13, 5, 0xa9e3e905);
	139	OP(d, a, b, c, 2, 9, 0xfcefa3f8);
140	OP(c, d, a, b, 7, 14, 0x676f02d9);
141	OP(b, c, d, a, 12, 20, 0x8d2a4c8a);
142
143	#undef OP
144
145	/***********************************************
146	* Round 3 *
147	* F(X,Y,Z) = X xor Y xor Z *
148	* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
149	***********************************************/
150
151	#define OP(a, b, c, d, k, s, ti) \
152	a += (b ^ c ^ d) + X[k] + (unsigned int)ti; \
153	a = b + ((a << s) \| (a >> (32 - s)))
154
155	OP(a, b, c, d, 5, 4, 0xfffa3942);
156	OP(d, a, b, c, 8, 11, 0x8771f681);
157	OP(c, d, a, b, 11, 16, 0x6d9d6122);
158	OP(b, c, d, a, 14, 23, 0xfde5380c);
159	OP(a, b, c, d, 1, 4, 0xa4beea44);
160	OP(d, a, b, c, 4, 11, 0x4bdecfa9);
161	OP(c, d, a, b, 7, 16, 0xf6bb4b60);
162	OP(b, c, d, a, 10, 23, 0xbebfbc70);
163	OP(a, b, c, d, 13, 4, 0x289b7ec6);
164	OP(d, a, b, c, 0, 11, 0xeaa127fa);
165	OP(c, d, a, b, 3, 16, 0xd4ef3085);
166	OP(b, c, d, a, 6, 23, 0x04881d05);
167	OP(a, b, c, d, 9, 4, 0xd9d4d039);
168	OP(d, a, b, c, 12, 11, 0xe6db99e5);
169	OP(c, d, a, b, 15, 16, 0x1fa27cf8);
170	OP(b, c, d, a, 2, 23, 0xc4ac5665);
171
172	#undef OP
173
174	/***********************************************
175	* Round 4 *
176	* F(X,Y,Z) = Y xor (X v not(Z)) *
177	* a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) *
178	***********************************************/
179
180	#define OP(a, b, c, d, k, s, ti) \
181	a += (c ^ (b \| ~d)) + X[k] + (unsigned int)ti; \
182	a = b + ((a << s) \| (a >> (32 - s)))
183
184	OP(a, b, c, d, 0, 6, 0xf4292244);
185	OP(d, a, b, c, 7, 10, 0x432aff97);
186	OP(c, d, a, b, 14, 15, 0xab9423a7);
187	OP(b, c, d, a, 5, 21, 0xfc93a039);
188	OP(a, b, c, d, 12, 6, 0x655b59c3);
189	OP(d, a, b, c, 3, 10, 0x8f0ccc92);
190	OP(c, d, a, b, 10, 15, 0xffeff47d);
191	OP(b, c, d, a, 1, 21, 0x85845dd1);
192	OP(a, b, c, d, 8, 6, 0x6fa87e4f);
193	OP(d, a, b, c, 15, 10, 0xfe2ce6e0);
194	OP(c, d, a, b, 6, 15, 0xa3014314);
195	OP(b, c, d, a, 13, 21, 0x4e0811a1);
196	OP(a, b, c, d, 4, 6, 0xf7537e82);
197	OP(d, a, b, c, 11, 10, 0xbd3af235);
198	OP(c, d, a, b, 2, 15, 0x2ad7d2bb);
199	OP(b, c, d, a, 9, 21, 0xeb86d391);
200
201	#undef OP
202
203	/* Add the new values back into the accumulators. */
204
205	base->abcd[0] += a;
206	base->abcd[1] += b;
207	base->abcd[2] += c;
208	base->abcd[3] += d;
209	}
210
211
212
213
214	/*************************************************
215	* Process the final text string *
216	*************************************************/
217
218	/* The string may be of any length. It is padded out according to the rules
219	for computing MD5 digests. The final result is then converted to text form
220	and returned.
221
222	Arguments:
223	base pointer to the md5 storage structure
224	text pointer to the final text vector
225	length length of the final text vector
226	digest points to 16 bytes in which to place the result
227
228	Returns: nothing
229	*/
230
231	void
232	md5_end(md5 base, const uschar text, int length, uschar *digest)
233	{
0756eb3c PH	234	uschar work[64];
	235
	236	/* Process in chunks of 64 until we have less than 64 bytes left. */
	237
	238	while (length >= 64)
	239	{
	240	md5_mid(base, text);
	241	text += 64;
	242	length -= 64;
	243	}
	244
	245	/* If the remaining string contains more than 55 bytes, we must pad it
	246	out to 64, process it, and then set up the final chunk as 56 bytes of
	247	padding. If it has less than 56 bytes, we pad it out to 56 bytes as the
	248	final chunk. */
	249
	250	memcpy(work, text, length);
	251	work[length] = 0x80;
	252
	253	if (length > 55)
	254	{
	255	memset(work+length+1, 0, 63-length);
	256	md5_mid(base, work);
	257	base->length -= 64;
	258	memset(work, 0, 56);
	259	}
	260	else
	261	{
	262	memset(work+length+1, 0, 55-length);
	263	}
	264
	265	/* The final 8 bytes of the final chunk are a 64-bit representation of the
	266	length of the input string bits, before padding, low order word first, and
	267	low order bytes first in each word. This implementation is designed for short
	268	strings, and so operates with a single int counter only. */
	269
	270	length += base->length; /* Total length in bytes */
	271	length <<= 3; /* Total length in bits */
	272
	273	work[56] = length & 0xff;
	274	work[57] = (length >> 8) & 0xff;
	275	work[58] = (length >> 16) & 0xff;
	276	work[59] = (length >> 24) & 0xff;
	277
	278	memset(work+60, 0, 4);
	279
	280	/* Process the final 64-byte chunk */
	281
	282	md5_mid(base, work);
	283
	284	/* Pass back the result, low-order byte first in each word. */
	285
d7978c0f	286	for (int i = 0; i < 4; i++)
0756eb3c PH	287	{
	288	register int x = base->abcd[i];
	289	*digest++ = x & 0xff;
	290	*digest++ = (x >> 8) & 0xff;
	291	*digest++ = (x >> 16) & 0xff;
	292	*digest++ = (x >> 24) & 0xff;
	293	}
	294	}
	295
	296
	297
	298	/*************************************************
	299	**************************************************
	300	* Stand-alone test program *
	301	**************************************************
	302	*************************************************/
	303
	304	#if defined STAND_ALONE & !defined CRAM_STAND_ALONE
	305
	306	/* Test values */
	307
	308	static uschar *tests[] = {
	309	"", "d41d8cd98f00b204e9800998ecf8427e",
	310
	311	"a", "0cc175b9c0f1b6a831c399e269772661",
	312
	313	"abc", "900150983cd24fb0d6963f7d28e17f72",
	314
	315	"message digest", "f96b697d7cb7938d525a2f31aaf161d0",
	316
	317	"abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b",
	318
	319	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
	320	"d174ab98d277d9f5a5611c2c9f419d9f",
	321
	322	"1234567890123456789012345678901234567890123456789012345678901234567890"
	323	"1234567890",
	324	"57edf4a22be3c955ac49da2e2107b67a",
	325
	326	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
	327	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
	328	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
	329	"a0842fcc02167127b0bb9a7c38e71ba8"
	330	};
	331
	332	int main(void)
	333	{
	334	md5 base;
	335	int i = 0x01020304;
5903c6ff	336	uschar *ctest = US (&i);
0756eb3c PH	337	uschar buffer[256];
	338	uschar digest[16];
	339	printf("Checking md5: %s-endian\n", (ctest[0] == 0x04)? "little" : "big");
	340
	341	for (i = 0; i < sizeof(tests)/sizeof(uschar *); i += 2)
	342	{
0756eb3c PH	343	uschar s[33];
	344	printf("%s\nShould be: %s\n", tests[i], tests[i+1]);
	345	md5_start(&base);
	346	md5_end(&base, tests[i], strlen(tests[i]), digest);
d7978c0f	347	for (int j = 0; j < 16; j++) sprintf(s+2*j, "%02x", digest[j]);
0756eb3c PH	348	printf("Computed: %s\n", s);
	349	if (strcmp(s, tests[i+1]) != 0) printf("* No match *\n");
	350	printf("\n");
	351	}
	352	}
	353	#endif
	354
	355	/* End of md5.c */