[rsync/rsync.git] / lib / mdfour.c

/* 
 * Unix SMB/Netbios implementation.
 * Version 1.9.
 * An implementation of MD4 designed for use in the SMB authentication protocol.
 *
 * Copyright (C) 1997-1998 Andrew Tridgell
 * Copyright (C) 2005 Wayne Davison
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include "rsync.h"

/* NOTE: This code makes no attempt to be fast! 
 *
 * It assumes that a int is at least 32 bits long. */

static struct mdfour *m;

#define MASK32 (0xffffffff)

#define F(X,Y,Z) ((((X)&(Y)) | ((~(X))&(Z))))
#define G(X,Y,Z) ((((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z))))
#define H(X,Y,Z) (((X)^(Y)^(Z)))
#define lshift(x,s) (((((x)<<(s))&MASK32) | (((x)>>(32-(s)))&MASK32)))

#define ROUND1(a,b,c,d,k,s) a = lshift((a + F(b,c,d) + M[k])&MASK32, s)
#define ROUND2(a,b,c,d,k,s) a = lshift((a + G(b,c,d) + M[k] + 0x5A827999)&MASK32,s)
#define ROUND3(a,b,c,d,k,s) a = lshift((a + H(b,c,d) + M[k] + 0x6ED9EBA1)&MASK32,s)

/* this applies md4 to 64 byte chunks */
static void mdfour64(uint32 *M)
{
	uint32 AA, BB, CC, DD;
	uint32 A,B,C,D;

	A = m->A; B = m->B; C = m->C; D = m->D; 
	AA = A; BB = B; CC = C; DD = D;

        ROUND1(A,B,C,D,  0,  3);  ROUND1(D,A,B,C,  1,  7);  
	ROUND1(C,D,A,B,  2, 11);  ROUND1(B,C,D,A,  3, 19);
        ROUND1(A,B,C,D,  4,  3);  ROUND1(D,A,B,C,  5,  7);  
	ROUND1(C,D,A,B,  6, 11);  ROUND1(B,C,D,A,  7, 19);
        ROUND1(A,B,C,D,  8,  3);  ROUND1(D,A,B,C,  9,  7);  
	ROUND1(C,D,A,B, 10, 11);  ROUND1(B,C,D,A, 11, 19);
        ROUND1(A,B,C,D, 12,  3);  ROUND1(D,A,B,C, 13,  7);  
	ROUND1(C,D,A,B, 14, 11);  ROUND1(B,C,D,A, 15, 19);	


        ROUND2(A,B,C,D,  0,  3);  ROUND2(D,A,B,C,  4,  5);  
	ROUND2(C,D,A,B,  8,  9);  ROUND2(B,C,D,A, 12, 13);
        ROUND2(A,B,C,D,  1,  3);  ROUND2(D,A,B,C,  5,  5);  
	ROUND2(C,D,A,B,  9,  9);  ROUND2(B,C,D,A, 13, 13);
        ROUND2(A,B,C,D,  2,  3);  ROUND2(D,A,B,C,  6,  5);  
	ROUND2(C,D,A,B, 10,  9);  ROUND2(B,C,D,A, 14, 13);
        ROUND2(A,B,C,D,  3,  3);  ROUND2(D,A,B,C,  7,  5);  
	ROUND2(C,D,A,B, 11,  9);  ROUND2(B,C,D,A, 15, 13);

	ROUND3(A,B,C,D,  0,  3);  ROUND3(D,A,B,C,  8,  9);  
	ROUND3(C,D,A,B,  4, 11);  ROUND3(B,C,D,A, 12, 15);
        ROUND3(A,B,C,D,  2,  3);  ROUND3(D,A,B,C, 10,  9);  
	ROUND3(C,D,A,B,  6, 11);  ROUND3(B,C,D,A, 14, 15);
        ROUND3(A,B,C,D,  1,  3);  ROUND3(D,A,B,C,  9,  9);  
	ROUND3(C,D,A,B,  5, 11);  ROUND3(B,C,D,A, 13, 15);
        ROUND3(A,B,C,D,  3,  3);  ROUND3(D,A,B,C, 11,  9);  
	ROUND3(C,D,A,B,  7, 11);  ROUND3(B,C,D,A, 15, 15);

	A += AA; B += BB; 
	C += CC; D += DD;
	
	A &= MASK32; B &= MASK32; 
	C &= MASK32; D &= MASK32;

	m->A = A; m->B = B; m->C = C; m->D = D;
}

static void copy64(uint32 *M, unsigned char *in)
{
	int i;

	for (i=0;i<16;i++)
		M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) |
			(in[i*4+1]<<8) | (in[i*4+0]<<0);
}

static void copy4(unsigned char *out,uint32 x)
{
	out[0] = x&0xFF;
	out[1] = (x>>8)&0xFF;
	out[2] = (x>>16)&0xFF;
	out[3] = (x>>24)&0xFF;
}

void mdfour_begin(struct mdfour *md)
{
	md->A = 0x67452301;
	md->B = 0xefcdab89;
	md->C = 0x98badcfe;
	md->D = 0x10325476;
	md->totalN = 0;
	md->totalN2 = 0;
}


static void mdfour_tail(unsigned char *in, uint32 n)
{
	unsigned char buf[128];
	uint32 M[16];
	extern int protocol_version;

	/*
	 * Count total number of bits, modulo 2^64
	 */
	m->totalN += n << 3;
	if (m->totalN < (n << 3)) {
		m->totalN2++;
	}
	m->totalN2 += n >> 29;

	memset(buf, 0, 128);
	if (n) memcpy(buf, in, n);
	buf[n] = 0x80;

	if (n <= 55) {
		copy4(buf+56, m->totalN);
		/*
		 * Prior to protocol version 27 only the number of bits
		 * modulo 2^32 was included.  MD4 requires the number
		 * of bits modulo 2^64, which was fixed starting with
		 * protocol version 27.
		 */
		if (protocol_version >= 27) {
			copy4(buf+60, m->totalN2);
		}
		copy64(M, buf);
		mdfour64(M);
	} else {
		copy4(buf+120, m->totalN); 
		/*
		 * Prior to protocol version 27 only the number of bits
		 * modulo 2^32 was included.  MD4 requires the number
		 * of bits modulo 2^64, which was fixed starting with
		 * protocol version 27.
		 */
		if (protocol_version >= 27) {
			copy4(buf+124, m->totalN2); 
		}
		copy64(M, buf);
		mdfour64(M);
		copy64(M, buf+64);
		mdfour64(M);
	}
}

void mdfour_update(struct mdfour *md, unsigned char *in, uint32 n)
{
	uint32 M[16];

	m = md;

	if (n == 0) mdfour_tail(in, n);

	while (n >= 64) {
		copy64(M, in);
		mdfour64(M);
		in += 64;
		n -= 64;
		m->totalN += 64 << 3;
		if (m->totalN < 64 << 3) {
			m->totalN2++;
		}
	}

	if (n) mdfour_tail(in, n);
}


void mdfour_result(struct mdfour *md, unsigned char *out)
{
	m = md;

	copy4(out, m->A);
	copy4(out+4, m->B);
	copy4(out+8, m->C);
	copy4(out+12, m->D);
}


void mdfour(unsigned char *out, unsigned char *in, int n)
{
	struct mdfour md;
	mdfour_begin(&md);
	mdfour_update(&md, in, n);
	mdfour_result(&md, out);
}

#ifdef TEST_MDFOUR
int protocol_version = 28;

static void file_checksum1(char *fname)
{
	int fd, i, was_multiple_of_64 = 1;
	struct mdfour md;
	unsigned char buf[64*1024], sum[16];
	
	fd = open(fname,O_RDONLY);
	if (fd == -1) {
		perror("fname");
		exit(1);
	}
	
	mdfour_begin(&md);

	while (1) {
		int n = read(fd, buf, sizeof(buf));
		if (n <= 0)
			break;
		was_multiple_of_64 = !(n % 64);
		mdfour_update(&md, buf, n);
	}
	if (was_multiple_of_64 && protocol_version >= 27)
		mdfour_update(&md, buf, 0);

	close(fd);

	mdfour_result(&md, sum);

	for (i=0;i<16;i++)
		printf("%02X", sum[i]);
	printf("\n");
}

#if 0
#include "../md4.h"

static void file_checksum2(char *fname)
{
	int fd, i;
	MDstruct md;
	unsigned char buf[64], sum[16];

	fd = open(fname,O_RDONLY);
	if (fd == -1) {
		perror("fname");
		exit(1);
	}
	
	MDbegin(&md);

	while (1) {
		int n = read(fd, buf, sizeof(buf));
		if (n <= 0) break;
		MDupdate(&md, buf, n*8);
	}

	if (!md.done) {
		MDupdate(&md, buf, 0);
	}

	close(fd);

	memcpy(sum, md.buffer, 16);

	for (i=0;i<16;i++)
		printf("%02X", sum[i]);
	printf("\n");
}
#endif

 int main(int argc, char *argv[])
{
	file_checksum1(argv[1]);
#if 0
	file_checksum2(argv[1]);
#endif
	return 0;
}
#endif
Commit	Line	Data
8de330a3	1	/*
0f78b815 WD	2	* Unix SMB/Netbios implementation.
	3	* Version 1.9.
	4	* An implementation of MD4 designed for use in the SMB authentication protocol.
	5	*
	6	* Copyright (C) 1997-1998 Andrew Tridgell
	7	* Copyright (C) 2005 Wayne Davison
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
e7c67065 WD	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
0f78b815	22	*/
8de330a3 AT	23
	24	#include "rsync.h"
	25
	26	/* NOTE: This code makes no attempt to be fast!
0f78b815 WD	27	*
0f78b815 WD	28	* It assumes that a int is at least 32 bits long. */
8de330a3 AT	29
	30	static struct mdfour *m;
	31
a7f8404e AT	32	#define MASK32 (0xffffffff)
	33
	34	#define F(X,Y,Z) ((((X)&(Y)) \| ((~(X))&(Z))))
	35	#define G(X,Y,Z) ((((X)&(Y)) \| ((X)&(Z)) \| ((Y)&(Z))))
	36	#define H(X,Y,Z) (((X)^(Y)^(Z)))
	37	#define lshift(x,s) (((((x)<<(s))&MASK32) \| (((x)>>(32-(s)))&MASK32)))
	38
	39	#define ROUND1(a,b,c,d,k,s) a = lshift((a + F(b,c,d) + M[k])&MASK32, s)
	40	#define ROUND2(a,b,c,d,k,s) a = lshift((a + G(b,c,d) + M[k] + 0x5A827999)&MASK32,s)
	41	#define ROUND3(a,b,c,d,k,s) a = lshift((a + H(b,c,d) + M[k] + 0x6ED9EBA1)&MASK32,s)
8de330a3 AT	42
	43	/* this applies md4 to 64 byte chunks */
	44	static void mdfour64(uint32 *M)
	45	{
8de330a3	46	uint32 AA, BB, CC, DD;
8de330a3 AT	47	uint32 A,B,C,D;
8de330a3 AT	48
8de330a3 AT	49	A = m->A; B = m->B; C = m->C; D = m->D;
	50	AA = A; BB = B; CC = C; DD = D;
	51
	52	ROUND1(A,B,C,D, 0, 3); ROUND1(D,A,B,C, 1, 7);
	53	ROUND1(C,D,A,B, 2, 11); ROUND1(B,C,D,A, 3, 19);
	54	ROUND1(A,B,C,D, 4, 3); ROUND1(D,A,B,C, 5, 7);
	55	ROUND1(C,D,A,B, 6, 11); ROUND1(B,C,D,A, 7, 19);
	56	ROUND1(A,B,C,D, 8, 3); ROUND1(D,A,B,C, 9, 7);
	57	ROUND1(C,D,A,B, 10, 11); ROUND1(B,C,D,A, 11, 19);
	58	ROUND1(A,B,C,D, 12, 3); ROUND1(D,A,B,C, 13, 7);
	59	ROUND1(C,D,A,B, 14, 11); ROUND1(B,C,D,A, 15, 19);
	60
a7f8404e	61
8de330a3 AT	62	ROUND2(A,B,C,D, 0, 3); ROUND2(D,A,B,C, 4, 5);
	63	ROUND2(C,D,A,B, 8, 9); ROUND2(B,C,D,A, 12, 13);
	64	ROUND2(A,B,C,D, 1, 3); ROUND2(D,A,B,C, 5, 5);
	65	ROUND2(C,D,A,B, 9, 9); ROUND2(B,C,D,A, 13, 13);
	66	ROUND2(A,B,C,D, 2, 3); ROUND2(D,A,B,C, 6, 5);
	67	ROUND2(C,D,A,B, 10, 9); ROUND2(B,C,D,A, 14, 13);
	68	ROUND2(A,B,C,D, 3, 3); ROUND2(D,A,B,C, 7, 5);
	69	ROUND2(C,D,A,B, 11, 9); ROUND2(B,C,D,A, 15, 13);
	70
	71	ROUND3(A,B,C,D, 0, 3); ROUND3(D,A,B,C, 8, 9);
	72	ROUND3(C,D,A,B, 4, 11); ROUND3(B,C,D,A, 12, 15);
	73	ROUND3(A,B,C,D, 2, 3); ROUND3(D,A,B,C, 10, 9);
	74	ROUND3(C,D,A,B, 6, 11); ROUND3(B,C,D,A, 14, 15);
	75	ROUND3(A,B,C,D, 1, 3); ROUND3(D,A,B,C, 9, 9);
	76	ROUND3(C,D,A,B, 5, 11); ROUND3(B,C,D,A, 13, 15);
	77	ROUND3(A,B,C,D, 3, 3); ROUND3(D,A,B,C, 11, 9);
	78	ROUND3(C,D,A,B, 7, 11); ROUND3(B,C,D,A, 15, 15);
	79
a7f8404e AT	80	A += AA; B += BB;
a7f8404e AT	81	C += CC; D += DD;
8de330a3	82
a7f8404e AT	83	A &= MASK32; B &= MASK32;
a7f8404e AT	84	C &= MASK32; D &= MASK32;
8de330a3 AT	85
	86	m->A = A; m->B = B; m->C = C; m->D = D;
	87	}
	88
	89	static void copy64(uint32 M, unsigned char in)
	90	{
	91	int i;
	92
	93	for (i=0;i<16;i++)
	94	M[i] = (in[i4+3]<<24) \| (in[i4+2]<<16) \|
	95	(in[i4+1]<<8) \| (in[i4+0]<<0);
	96	}
	97
	98	static void copy4(unsigned char *out,uint32 x)
	99	{
	100	out[0] = x&0xFF;
	101	out[1] = (x>>8)&0xFF;
	102	out[2] = (x>>16)&0xFF;
	103	out[3] = (x>>24)&0xFF;
	104	}
	105
	106	void mdfour_begin(struct mdfour *md)
	107	{
	108	md->A = 0x67452301;
	109	md->B = 0xefcdab89;
	110	md->C = 0x98badcfe;
	111	md->D = 0x10325476;
	112	md->totalN = 0;
fc1ae658	113	md->totalN2 = 0;
8de330a3 AT	114	}
	115
	116
fc1ae658	117	static void mdfour_tail(unsigned char *in, uint32 n)
8de330a3 AT	118	{
	119	unsigned char buf[128];
	120	uint32 M[16];
d04e9c51	121	extern int protocol_version;
fc1ae658 S	122
	123	/*
	124	* Count total number of bits, modulo 2^64
	125	*/
	126	m->totalN += n << 3;
	127	if (m->totalN < (n << 3)) {
	128	m->totalN2++;
	129	}
	130	m->totalN2 += n >> 29;
8de330a3 AT	131
	132	memset(buf, 0, 128);
	133	if (n) memcpy(buf, in, n);
	134	buf[n] = 0x80;
	135
	136	if (n <= 55) {
fc1ae658 S	137	copy4(buf+56, m->totalN);
	138	/*
	139	* Prior to protocol version 27 only the number of bits
	140	* modulo 2^32 was included. MD4 requires the number
	141	* of bits modulo 2^64, which was fixed starting with
	142	* protocol version 27.
	143	*/
d04e9c51	144	if (protocol_version >= 27) {
fc1ae658 S	145	copy4(buf+60, m->totalN2);
fc1ae658 S	146	}
8de330a3 AT	147	copy64(M, buf);
	148	mdfour64(M);
	149	} else {
fc1ae658 S	150	copy4(buf+120, m->totalN);
	151	/*
	152	* Prior to protocol version 27 only the number of bits
	153	* modulo 2^32 was included. MD4 requires the number
	154	* of bits modulo 2^64, which was fixed starting with
	155	* protocol version 27.
	156	*/
d04e9c51	157	if (protocol_version >= 27) {
fc1ae658 S	158	copy4(buf+124, m->totalN2);
fc1ae658 S	159	}
8de330a3 AT	160	copy64(M, buf);
	161	mdfour64(M);
	162	copy64(M, buf+64);
	163	mdfour64(M);
	164	}
8de330a3 AT	165	}
8de330a3 AT	166
fc1ae658	167	void mdfour_update(struct mdfour md, unsigned char in, uint32 n)
8de330a3 AT	168	{
	169	uint32 M[16];
	170
8de330a3 AT	171	m = md;
8de330a3 AT	172
fc1ae658 S	173	if (n == 0) mdfour_tail(in, n);
fc1ae658 S	174
8de330a3 AT	175	while (n >= 64) {
	176	copy64(M, in);
	177	mdfour64(M);
	178	in += 64;
	179	n -= 64;
fc1ae658 S	180	m->totalN += 64 << 3;
	181	if (m->totalN < 64 << 3) {
	182	m->totalN2++;
	183	}
8de330a3 AT	184	}
	185
	186	if (n) mdfour_tail(in, n);
	187	}
	188
	189
	190	void mdfour_result(struct mdfour md, unsigned char out)
	191	{
	192	m = md;
	193
	194	copy4(out, m->A);
	195	copy4(out+4, m->B);
	196	copy4(out+8, m->C);
	197	copy4(out+12, m->D);
	198	}
	199
	200
	201	void mdfour(unsigned char out, unsigned char in, int n)
	202	{
	203	struct mdfour md;
	204	mdfour_begin(&md);
	205	mdfour_update(&md, in, n);
	206	mdfour_result(&md, out);
	207	}
	208
	209	#ifdef TEST_MDFOUR
d82773ff WD	210	int protocol_version = 28;
d82773ff WD	211
8de330a3 AT	212	static void file_checksum1(char *fname)
8de330a3 AT	213	{
d82773ff	214	int fd, i, was_multiple_of_64 = 1;
8de330a3	215	struct mdfour md;
2fb27e91 AT	216	unsigned char buf[64*1024], sum[16];
2fb27e91 AT	217
8de330a3 AT	218	fd = open(fname,O_RDONLY);
	219	if (fd == -1) {
	220	perror("fname");
	221	exit(1);
	222	}
	223
	224	mdfour_begin(&md);
	225
	226	while (1) {
	227	int n = read(fd, buf, sizeof(buf));
d82773ff WD	228	if (n <= 0)
	229	break;
	230	was_multiple_of_64 = !(n % 64);
8de330a3 AT	231	mdfour_update(&md, buf, n);
8de330a3 AT	232	}
d82773ff WD	233	if (was_multiple_of_64 && protocol_version >= 27)
d82773ff WD	234	mdfour_update(&md, buf, 0);
8de330a3 AT	235
	236	close(fd);
	237
	238	mdfour_result(&md, sum);
	239
	240	for (i=0;i<16;i++)
	241	printf("%02X", sum[i]);
	242	printf("\n");
	243	}
	244
2fb27e91	245	#if 0
8de330a3 AT	246	#include "../md4.h"
	247
	248	static void file_checksum2(char *fname)
	249	{
	250	int fd, i;
	251	MDstruct md;
	252	unsigned char buf[64], sum[16];
	253
	254	fd = open(fname,O_RDONLY);
	255	if (fd == -1) {
	256	perror("fname");
	257	exit(1);
	258	}
	259
	260	MDbegin(&md);
	261
	262	while (1) {
	263	int n = read(fd, buf, sizeof(buf));
	264	if (n <= 0) break;
	265	MDupdate(&md, buf, n*8);
	266	}
	267
	268	if (!md.done) {
	269	MDupdate(&md, buf, 0);
	270	}
	271
	272	close(fd);
	273
	274	memcpy(sum, md.buffer, 16);
	275
	276	for (i=0;i<16;i++)
	277	printf("%02X", sum[i]);
	278	printf("\n");
	279	}
2fb27e91	280	#endif
8de330a3 AT	281
	282	int main(int argc, char *argv[])
	283	{
	284	file_checksum1(argv[1]);
2fb27e91	285	#if 0
8de330a3	286	file_checksum2(argv[1]);
2fb27e91	287	#endif
8de330a3 AT	288	return 0;
	289	}
	290	#endif