4
An implementation of MD4 designed for use in the samba SMB
5
authentication protocol
7
Copyright (C) 1997-1998 Andrew Tridgell
9
This program is free software; you can redistribute it and/or
10
modify it under the terms of the GNU General Public License
11
as published by the Free Software Foundation; either version 2
12
of the License, or (at your option) any later version.
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.
18
See the GNU General Public License for more details.
20
You should have received a copy of the GNU General Public License
21
along with this program; if not, write to:
23
Free Software Foundation, Inc.
24
59 Temple Place - Suite 330
25
Boston, MA 02111-1307, USA
27
$Id: mdfour.c,v 1.1 2002/08/23 22:03:27 abster Exp $
39
/* NOTE: This code makes no attempt to be fast!
41
It assumes that a int is at least 32 bits long
44
static struct mdfour *m;
46
#define F(X,Y,Z) (((X)&(Y)) | ((~(X))&(Z)))
47
#define G(X,Y,Z) (((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z)))
48
#define H(X,Y,Z) ((X)^(Y)^(Z))
49
#define lshift(x,s) (((x)<<(s)) | ((x)>>(32-(s))))
51
#define ROUND1(a,b,c,d,k,s) a = lshift(a + F(b,c,d) + X[k], s)
52
#define ROUND2(a,b,c,d,k,s) a = lshift(a + G(b,c,d) + X[k] + 0x5A827999,s)
53
#define ROUND3(a,b,c,d,k,s) a = lshift(a + H(b,c,d) + X[k] + 0x6ED9EBA1,s)
55
/* this applies md4 to 64 byte chunks */
56
static void mdfour64(uint32_t *M)
59
uint32_t AA, BB, CC, DD;
66
A = m->A; B = m->B; C = m->C; D = m->D;
67
AA = A; BB = B; CC = C; DD = D;
69
ROUND1(A,B,C,D, 0, 3); ROUND1(D,A,B,C, 1, 7);
70
ROUND1(C,D,A,B, 2, 11); ROUND1(B,C,D,A, 3, 19);
71
ROUND1(A,B,C,D, 4, 3); ROUND1(D,A,B,C, 5, 7);
72
ROUND1(C,D,A,B, 6, 11); ROUND1(B,C,D,A, 7, 19);
73
ROUND1(A,B,C,D, 8, 3); ROUND1(D,A,B,C, 9, 7);
74
ROUND1(C,D,A,B, 10, 11); ROUND1(B,C,D,A, 11, 19);
75
ROUND1(A,B,C,D, 12, 3); ROUND1(D,A,B,C, 13, 7);
76
ROUND1(C,D,A,B, 14, 11); ROUND1(B,C,D,A, 15, 19);
78
ROUND2(A,B,C,D, 0, 3); ROUND2(D,A,B,C, 4, 5);
79
ROUND2(C,D,A,B, 8, 9); ROUND2(B,C,D,A, 12, 13);
80
ROUND2(A,B,C,D, 1, 3); ROUND2(D,A,B,C, 5, 5);
81
ROUND2(C,D,A,B, 9, 9); ROUND2(B,C,D,A, 13, 13);
82
ROUND2(A,B,C,D, 2, 3); ROUND2(D,A,B,C, 6, 5);
83
ROUND2(C,D,A,B, 10, 9); ROUND2(B,C,D,A, 14, 13);
84
ROUND2(A,B,C,D, 3, 3); ROUND2(D,A,B,C, 7, 5);
85
ROUND2(C,D,A,B, 11, 9); ROUND2(B,C,D,A, 15, 13);
87
ROUND3(A,B,C,D, 0, 3); ROUND3(D,A,B,C, 8, 9);
88
ROUND3(C,D,A,B, 4, 11); ROUND3(B,C,D,A, 12, 15);
89
ROUND3(A,B,C,D, 2, 3); ROUND3(D,A,B,C, 10, 9);
90
ROUND3(C,D,A,B, 6, 11); ROUND3(B,C,D,A, 14, 15);
91
ROUND3(A,B,C,D, 1, 3); ROUND3(D,A,B,C, 9, 9);
92
ROUND3(C,D,A,B, 5, 11); ROUND3(B,C,D,A, 13, 15);
93
ROUND3(A,B,C,D, 3, 3); ROUND3(D,A,B,C, 11, 9);
94
ROUND3(C,D,A,B, 7, 11); ROUND3(B,C,D,A, 15, 15);
96
A += AA; B += BB; C += CC; D += DD;
101
m->A = A; m->B = B; m->C = C; m->D = D;
104
static void copy64(uint32_t *M, byte *in)
109
M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) |
110
(in[i*4+1]<<8) | (in[i*4+0]<<0);
113
static void copy4(byte *out,uint32_t x)
116
out[1] = (x>>8)&0xFF;
117
out[2] = (x>>16)&0xFF;
118
out[3] = (x>>24)&0xFF;
121
void mdfour_begin(struct mdfour *md)
131
static void mdfour_tail(byte *in, int n)
141
Com_Memset(buf, 0, 128);
142
if (n) Com_Memcpy(buf, in, n);
158
static void mdfour_update(struct mdfour *md, byte *in, int n)
164
if (n == 0) mdfour_tail(in, n);
178
static void mdfour_result(struct mdfour *md, byte *out)
188
static void mdfour(byte *out, byte *in, int n)
192
mdfour_update(&md, in, n);
193
mdfour_result(&md, out);
196
//===================================================================
198
unsigned Com_BlockChecksum (const void *buffer, int length)
203
mdfour( (byte *)digest, (byte *)buffer, length );
205
val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
added
removed
code/qcommon/md4.c
