[mirror_frr.git] / lib / md5.c

/* $USAGI: md5.c,v 1.2 2000/11/02 11:59:24 yoshfuji Exp $ */
/*	$KAME: md5.c,v 1.2 2000/05/27 07:07:48 jinmei Exp $	*/
/*	$Id: md5.c,v 1.6 2006/01/17 23:39:04 vincent Exp $ */

/*
 * Copyright (C) 2004 6WIND
 *                          <Vincent.Jardin@6WIND.com>
 * All rights reserved.
 *
 * This MD5 code is Big endian and Little Endian compatible.
 */

/*
 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <zebra.h>
#include "md5.h"

#define SHIFT(X, s) (((X) << (s)) | ((X) >> (32 - (s))))

#define F(X, Y, Z) (((X) & (Y)) | ((~X) & (Z)))
#define G(X, Y, Z) (((X) & (Z)) | ((Y) & (~Z)))
#define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
#define I(X, Y, Z) ((Y) ^ ((X) | (~Z)))

#define ROUND1(a, b, c, d, k, s, i) { \
	(a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
	(a) = SHIFT((a), (s)); \
	(a) = (b) + (a); \
}

#define ROUND2(a, b, c, d, k, s, i) { \
	(a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
	(a) = SHIFT((a), (s)); \
	(a) = (b) + (a); \
}

#define ROUND3(a, b, c, d, k, s, i) { \
	(a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
	(a) = SHIFT((a), (s)); \
	(a) = (b) + (a); \
}

#define ROUND4(a, b, c, d, k, s, i) { \
	(a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
	(a) = SHIFT((a), (s)); \
	(a) = (b) + (a); \
}

#define Sa	 7
#define Sb	12
#define Sc	17
#define Sd	22

#define Se	 5
#define Sf	 9
#define Sg	14
#define Sh	20

#define Si	 4
#define Sj	11
#define Sk	16
#define Sl	23

#define Sm	 6
#define Sn	10
#define So	15
#define Sp	21

#define MD5_A0	0x67452301
#define MD5_B0	0xefcdab89
#define MD5_C0	0x98badcfe
#define MD5_D0	0x10325476

/* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */
static const uint32_t T[65] = {
	0,
	0xd76aa478, 	0xe8c7b756,	0x242070db,	0xc1bdceee,
	0xf57c0faf,	0x4787c62a, 	0xa8304613,	0xfd469501,
	0x698098d8,	0x8b44f7af,	0xffff5bb1,	0x895cd7be,
	0x6b901122, 	0xfd987193, 	0xa679438e,	0x49b40821,

	0xf61e2562,	0xc040b340, 	0x265e5a51, 	0xe9b6c7aa,
	0xd62f105d,	0x2441453,	0xd8a1e681,	0xe7d3fbc8,
	0x21e1cde6,	0xc33707d6, 	0xf4d50d87, 	0x455a14ed,
	0xa9e3e905,	0xfcefa3f8, 	0x676f02d9, 	0x8d2a4c8a,

	0xfffa3942,	0x8771f681, 	0x6d9d6122, 	0xfde5380c,
	0xa4beea44, 	0x4bdecfa9, 	0xf6bb4b60, 	0xbebfbc70,
	0x289b7ec6, 	0xeaa127fa, 	0xd4ef3085,	0x4881d05,
	0xd9d4d039, 	0xe6db99e5, 	0x1fa27cf8, 	0xc4ac5665,

	0xf4292244, 	0x432aff97, 	0xab9423a7, 	0xfc93a039,
	0x655b59c3, 	0x8f0ccc92, 	0xffeff47d, 	0x85845dd1,
	0x6fa87e4f, 	0xfe2ce6e0, 	0xa3014314, 	0x4e0811a1,
	0xf7537e82, 	0xbd3af235, 	0x2ad7d2bb, 	0xeb86d391,
};

static const uint8_t md5_paddat[MD5_BUFLEN] = {
	0x80,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,
	0,	0,	0,	0,	0,	0,	0,	0,	
};

static void md5_calc (const uint8_t *, md5_ctxt *);

void md5_init(md5_ctxt *ctxt)
{
	ctxt->md5_n = 0;
	ctxt->md5_i = 0;
	ctxt->md5_sta = MD5_A0;
	ctxt->md5_stb = MD5_B0;
	ctxt->md5_stc = MD5_C0;
	ctxt->md5_std = MD5_D0;
	memset (ctxt->md5_buf, 0, sizeof(ctxt->md5_buf));
}

void md5_loop(md5_ctxt *ctxt, const void *vinput, uint len)
{
	uint gap, i;
	const uint8_t *input = vinput;

	ctxt->md5_n += len * 8; /* byte to bit */
	gap = MD5_BUFLEN - ctxt->md5_i;

	if (len >= gap) {
		memcpy (ctxt->md5_buf + ctxt->md5_i, input, gap);
		md5_calc(ctxt->md5_buf, ctxt);

		for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
			md5_calc((input + i), ctxt);
		}
		
		ctxt->md5_i = len - i;
		memcpy (ctxt->md5_buf, (input + i), ctxt->md5_i);
	} else {
		memcpy (ctxt->md5_buf + ctxt->md5_i, input, len);
		ctxt->md5_i += len;
	}
}

void md5_pad(md5_ctxt *ctxt)
{
	uint gap;

	/* Don't count up padding. Keep md5_n. */	
	gap = MD5_BUFLEN - ctxt->md5_i;
	if (gap > 8) {
		memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat, 
			gap - sizeof(ctxt->md5_n));
	} else {
		/* including gap == 8 */
		memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat, gap);
		md5_calc (ctxt->md5_buf, ctxt);
		memcpy (ctxt->md5_buf, md5_paddat + gap,
			MD5_BUFLEN - sizeof(ctxt->md5_n));
	}

	/* 8 byte word */	
	if (BYTE_ORDER == LITTLE_ENDIAN)
	  memcpy (&ctxt->md5_buf[56], &ctxt->md5_n8[0], 8);
	else
	  {
	    ctxt->md5_buf[56] = ctxt->md5_n8[7];
	    ctxt->md5_buf[57] = ctxt->md5_n8[6];
	    ctxt->md5_buf[58] = ctxt->md5_n8[5];
	    ctxt->md5_buf[59] = ctxt->md5_n8[4];
	    ctxt->md5_buf[60] = ctxt->md5_n8[3];
	    ctxt->md5_buf[61] = ctxt->md5_n8[2];
	    ctxt->md5_buf[62] = ctxt->md5_n8[1];
	    ctxt->md5_buf[63] = ctxt->md5_n8[0];
	  }
	md5_calc(ctxt->md5_buf, ctxt);
}

void md5_result(uint8_t *digest, md5_ctxt *ctxt)
{
	/* 4 byte words */
	if (BYTE_ORDER == LITTLE_ENDIAN)
	  memcpy (digest, &ctxt->md5_st8[0], 16);
	else if (BYTE_ORDER == BIG_ENDIAN)
	  {
	    digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
	    digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
	    digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
	    digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
	    digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
	    digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
	    digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
	    digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
	  }
}

static void md5_calc(const uint8_t *b64, md5_ctxt * ctxt)
{
	uint32_t A = ctxt->md5_sta;
	uint32_t B = ctxt->md5_stb;
	uint32_t C = ctxt->md5_stc;
	uint32_t D = ctxt->md5_std;
#if (BYTE_ORDER == LITTLE_ENDIAN)
	const uint32_t *X = (const uint32_t *)b64;
#elif (BYTE_ORDER == BIG_ENDIAN)
	uint32_t X[16];

	if (BYTE_ORDER == BIG_ENDIAN)
	  {
	    /* 4 byte words */
	    /* what a brute force but fast! */
	    uint8_t *y = (uint8_t *)X;
	    y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
	    y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
	    y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
	    y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
	    y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
	    y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
	    y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
	    y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
	    y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
	    y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
	    y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
	    y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
	    y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
	    y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
	    y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
	    y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
	  }
#endif

	ROUND1(A, B, C, D,  0, Sa,  1); ROUND1(D, A, B, C,  1, Sb,  2);
	ROUND1(C, D, A, B,  2, Sc,  3); ROUND1(B, C, D, A,  3, Sd,  4);
	ROUND1(A, B, C, D,  4, Sa,  5); ROUND1(D, A, B, C,  5, Sb,  6);
	ROUND1(C, D, A, B,  6, Sc,  7); ROUND1(B, C, D, A,  7, Sd,  8);
	ROUND1(A, B, C, D,  8, Sa,  9); ROUND1(D, A, B, C,  9, Sb, 10);
	ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
	ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
	ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
	
	ROUND2(A, B, C, D,  1, Se, 17); ROUND2(D, A, B, C,  6, Sf, 18);
	ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A,  0, Sh, 20);
	ROUND2(A, B, C, D,  5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
	ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A,  4, Sh, 24);
	ROUND2(A, B, C, D,  9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
	ROUND2(C, D, A, B,  3, Sg, 27); ROUND2(B, C, D, A,  8, Sh, 28);
	ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C,  2, Sf, 30);
	ROUND2(C, D, A, B,  7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);

	ROUND3(A, B, C, D,  5, Si, 33); ROUND3(D, A, B, C,  8, Sj, 34);
	ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
	ROUND3(A, B, C, D,  1, Si, 37); ROUND3(D, A, B, C,  4, Sj, 38);
	ROUND3(C, D, A, B,  7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
	ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C,  0, Sj, 42);
	ROUND3(C, D, A, B,  3, Sk, 43); ROUND3(B, C, D, A,  6, Sl, 44);
	ROUND3(A, B, C, D,  9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
	ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A,  2, Sl, 48);
	
	ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50);	
	ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52);	
	ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54);	
	ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56);	
	ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58);	
	ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60);	
	ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62);	
	ROUND4(C, D, A, B,  2, So, 63); ROUND4(B, C, D, A,  9, Sp, 64);

	ctxt->md5_sta += A;
	ctxt->md5_stb += B;
	ctxt->md5_stc += C;
	ctxt->md5_std += D;
}
Commit	Line	Data
c1a03d47	1	/* $USAGI: md5.c,v 1.2 2000/11/02 11:59:24 yoshfuji Exp $ */
c1a03d47	2	/* $KAME: md5.c,v 1.2 2000/05/27 07:07:48 jinmei Exp $ */
eac314c7	3	/* $Id: md5.c,v 1.6 2006/01/17 23:39:04 vincent Exp $ */
c1a03d47	4
	5	/*
	6	* Copyright (C) 2004 6WIND
	7	* <Vincent.Jardin@6WIND.com>
	8	* All rights reserved.
	9	*
	10	* This MD5 code is Big endian and Little Endian compatible.
	11	*/
	12
	13	/*
	14	* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
	15	* All rights reserved.
	16	*
	17	* Redistribution and use in source and binary forms, with or without
	18	* modification, are permitted provided that the following conditions
	19	* are met:
	20	* 1. Redistributions of source code must retain the above copyright
	21	* notice, this list of conditions and the following disclaimer.
	22	* 2. Redistributions in binary form must reproduce the above copyright
	23	* notice, this list of conditions and the following disclaimer in the
	24	* documentation and/or other materials provided with the distribution.
	25	* 3. Neither the name of the project nor the names of its contributors
	26	* may be used to endorse or promote products derived from this software
	27	* without specific prior written permission.
	28	*
	29	* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
	30	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	31	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	32	* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
	33	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	34	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	35	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	36	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	37	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	38	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	39	* SUCH DAMAGE.
	40	*/
	41
34204aac	42	#include <zebra.h>
c1a03d47	43	#include "md5.h"
	44
	45	#define SHIFT(X, s) (((X) << (s)) \| ((X) >> (32 - (s))))
	46
	47	#define F(X, Y, Z) (((X) & (Y)) \| ((~X) & (Z)))
	48	#define G(X, Y, Z) (((X) & (Z)) \| ((Y) & (~Z)))
	49	#define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
	50	#define I(X, Y, Z) ((Y) ^ ((X) \| (~Z)))
	51
	52	#define ROUND1(a, b, c, d, k, s, i) { \
	53	(a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
	54	(a) = SHIFT((a), (s)); \
	55	(a) = (b) + (a); \
718e3744	56	}
718e3744	57
c1a03d47	58	#define ROUND2(a, b, c, d, k, s, i) { \
	59	(a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
	60	(a) = SHIFT((a), (s)); \
	61	(a) = (b) + (a); \
	62	}
718e3744	63
c1a03d47	64	#define ROUND3(a, b, c, d, k, s, i) { \
	65	(a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
	66	(a) = SHIFT((a), (s)); \
	67	(a) = (b) + (a); \
718e3744	68	}
718e3744	69
c1a03d47	70	#define ROUND4(a, b, c, d, k, s, i) { \
	71	(a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
	72	(a) = SHIFT((a), (s)); \
	73	(a) = (b) + (a); \
	74	}
718e3744	75
c1a03d47	76	#define Sa 7
	77	#define Sb 12
	78	#define Sc 17
	79	#define Sd 22
	80
	81	#define Se 5
	82	#define Sf 9
	83	#define Sg 14
	84	#define Sh 20
	85
	86	#define Si 4
	87	#define Sj 11
	88	#define Sk 16
	89	#define Sl 23
	90
	91	#define Sm 6
	92	#define Sn 10
	93	#define So 15
	94	#define Sp 21
	95
	96	#define MD5_A0 0x67452301
	97	#define MD5_B0 0xefcdab89
	98	#define MD5_C0 0x98badcfe
	99	#define MD5_D0 0x10325476
	100
	101	/* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */
34204aac	102	static const uint32_t T[65] = {
c1a03d47	103	0,
	104	0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
	105	0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
	106	0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
	107	0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
	108
	109	0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
	110	0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
	111	0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
	112	0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
	113
	114	0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
	115	0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
	116	0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
	117	0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
	118
	119	0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
	120	0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
	121	0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
	122	0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
	123	};
	124
34204aac	125	static const uint8_t md5_paddat[MD5_BUFLEN] = {
c1a03d47	126	0x80, 0, 0, 0, 0, 0, 0, 0,
	127	0, 0, 0, 0, 0, 0, 0, 0,
	128	0, 0, 0, 0, 0, 0, 0, 0,
	129	0, 0, 0, 0, 0, 0, 0, 0,
	130	0, 0, 0, 0, 0, 0, 0, 0,
	131	0, 0, 0, 0, 0, 0, 0, 0,
	132	0, 0, 0, 0, 0, 0, 0, 0,
	133	0, 0, 0, 0, 0, 0, 0, 0,
	134	};
	135
34204aac	136	static void md5_calc (const uint8_t , md5_ctxt );
c1a03d47	137
34204aac	138	void md5_init(md5_ctxt *ctxt)
718e3744	139	{
c1a03d47	140	ctxt->md5_n = 0;
	141	ctxt->md5_i = 0;
	142	ctxt->md5_sta = MD5_A0;
	143	ctxt->md5_stb = MD5_B0;
	144	ctxt->md5_stc = MD5_C0;
	145	ctxt->md5_std = MD5_D0;
34204aac	146	memset (ctxt->md5_buf, 0, sizeof(ctxt->md5_buf));
718e3744	147	}
718e3744	148
7d0b0c4b	149	void md5_loop(md5_ctxt ctxt, const void vinput, uint len)
718e3744	150	{
34204aac	151	uint gap, i;
eac314c7	152	const uint8_t *input = vinput;
c1a03d47	153
	154	ctxt->md5_n += len * 8; /* byte to bit */
	155	gap = MD5_BUFLEN - ctxt->md5_i;
	156
	157	if (len >= gap) {
34204aac	158	memcpy (ctxt->md5_buf + ctxt->md5_i, input, gap);
c1a03d47	159	md5_calc(ctxt->md5_buf, ctxt);
	160
	161	for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
34204aac	162	md5_calc((input + i), ctxt);
c1a03d47	163	}
	164
	165	ctxt->md5_i = len - i;
34204aac	166	memcpy (ctxt->md5_buf, (input + i), ctxt->md5_i);
c1a03d47	167	} else {
34204aac	168	memcpy (ctxt->md5_buf + ctxt->md5_i, input, len);
c1a03d47	169	ctxt->md5_i += len;
718e3744	170	}
718e3744	171	}
718e3744	172
34204aac	173	void md5_pad(md5_ctxt *ctxt)
718e3744	174	{
34204aac	175	uint gap;
c1a03d47	176
	177	/* Don't count up padding. Keep md5_n. */
	178	gap = MD5_BUFLEN - ctxt->md5_i;
	179	if (gap > 8) {
34204aac	180	memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat,
34204aac	181	gap - sizeof(ctxt->md5_n));
c1a03d47	182	} else {
c1a03d47	183	/* including gap == 8 */
34204aac	184	memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat, gap);
	185	md5_calc (ctxt->md5_buf, ctxt);
	186	memcpy (ctxt->md5_buf, md5_paddat + gap,
	187	MD5_BUFLEN - sizeof(ctxt->md5_n));
c1a03d47	188	}
718e3744	189
c1a03d47	190	/* 8 byte word */
34204aac	191	if (BYTE_ORDER == LITTLE_ENDIAN)
	192	memcpy (&ctxt->md5_buf[56], &ctxt->md5_n8[0], 8);
	193	else
	194	{
	195	ctxt->md5_buf[56] = ctxt->md5_n8[7];
	196	ctxt->md5_buf[57] = ctxt->md5_n8[6];
	197	ctxt->md5_buf[58] = ctxt->md5_n8[5];
	198	ctxt->md5_buf[59] = ctxt->md5_n8[4];
	199	ctxt->md5_buf[60] = ctxt->md5_n8[3];
	200	ctxt->md5_buf[61] = ctxt->md5_n8[2];
	201	ctxt->md5_buf[62] = ctxt->md5_n8[1];
	202	ctxt->md5_buf[63] = ctxt->md5_n8[0];
	203	}
c1a03d47	204	md5_calc(ctxt->md5_buf, ctxt);
718e3744	205	}
718e3744	206
34204aac	207	void md5_result(uint8_t digest, md5_ctxt ctxt)
718e3744	208	{
c1a03d47	209	/* 4 byte words */
34204aac	210	if (BYTE_ORDER == LITTLE_ENDIAN)
	211	memcpy (digest, &ctxt->md5_st8[0], 16);
	212	else if (BYTE_ORDER == BIG_ENDIAN)
	213	{
	214	digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
	215	digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
	216	digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
	217	digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
	218	digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
	219	digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
	220	digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
	221	digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
	222	}
718e3744	223	}
718e3744	224
34204aac	225	static void md5_calc(const uint8_t b64, md5_ctxt ctxt)
718e3744	226	{
34204aac	227	uint32_t A = ctxt->md5_sta;
	228	uint32_t B = ctxt->md5_stb;
	229	uint32_t C = ctxt->md5_stc;
	230	uint32_t D = ctxt->md5_std;
	231	#if (BYTE_ORDER == LITTLE_ENDIAN)
	232	const uint32_t X = (const uint32_t )b64;
	233	#elif (BYTE_ORDER == BIG_ENDIAN)
	234	uint32_t X[16];
3949a60c	235
34204aac	236	if (BYTE_ORDER == BIG_ENDIAN)
	237	{
	238	/* 4 byte words */
	239	/* what a brute force but fast! */
	240	uint8_t y = (uint8_t )X;
	241	y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
	242	y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
	243	y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
	244	y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
	245	y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
	246	y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
	247	y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
	248	y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
	249	y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
	250	y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
	251	y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
	252	y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
	253	y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
	254	y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
	255	y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
	256	y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
	257	}
3949a60c	258	#endif
c1a03d47	259
	260	ROUND1(A, B, C, D, 0, Sa, 1); ROUND1(D, A, B, C, 1, Sb, 2);
	261	ROUND1(C, D, A, B, 2, Sc, 3); ROUND1(B, C, D, A, 3, Sd, 4);
	262	ROUND1(A, B, C, D, 4, Sa, 5); ROUND1(D, A, B, C, 5, Sb, 6);
	263	ROUND1(C, D, A, B, 6, Sc, 7); ROUND1(B, C, D, A, 7, Sd, 8);
	264	ROUND1(A, B, C, D, 8, Sa, 9); ROUND1(D, A, B, C, 9, Sb, 10);
	265	ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
	266	ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
	267	ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
	268
	269	ROUND2(A, B, C, D, 1, Se, 17); ROUND2(D, A, B, C, 6, Sf, 18);
	270	ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A, 0, Sh, 20);
	271	ROUND2(A, B, C, D, 5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
	272	ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A, 4, Sh, 24);
	273	ROUND2(A, B, C, D, 9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
	274	ROUND2(C, D, A, B, 3, Sg, 27); ROUND2(B, C, D, A, 8, Sh, 28);
	275	ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C, 2, Sf, 30);
	276	ROUND2(C, D, A, B, 7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);
	277
	278	ROUND3(A, B, C, D, 5, Si, 33); ROUND3(D, A, B, C, 8, Sj, 34);
	279	ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
	280	ROUND3(A, B, C, D, 1, Si, 37); ROUND3(D, A, B, C, 4, Sj, 38);
	281	ROUND3(C, D, A, B, 7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
	282	ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C, 0, Sj, 42);
	283	ROUND3(C, D, A, B, 3, Sk, 43); ROUND3(B, C, D, A, 6, Sl, 44);
	284	ROUND3(A, B, C, D, 9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
	285	ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A, 2, Sl, 48);
	286
	287	ROUND4(A, B, C, D, 0, Sm, 49); ROUND4(D, A, B, C, 7, Sn, 50);
	288	ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A, 5, Sp, 52);
	289	ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C, 3, Sn, 54);
	290	ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A, 1, Sp, 56);
	291	ROUND4(A, B, C, D, 8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58);
	292	ROUND4(C, D, A, B, 6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60);
	293	ROUND4(A, B, C, D, 4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62);
	294	ROUND4(C, D, A, B, 2, So, 63); ROUND4(B, C, D, A, 9, Sp, 64);
	295
	296	ctxt->md5_sta += A;
	297	ctxt->md5_stb += B;
	298	ctxt->md5_stc += C;
	299	ctxt->md5_std += D;
	300	}