MD4Update takes bytes not bits! Now the regression test of the README.MSCHAP80
[ppp.git] / pppd / md4.c
1 /*
2 ** ********************************************************************
3 ** md4.c -- Implementation of MD4 Message Digest Algorithm           **
4 ** Updated: 2/16/90 by Ronald L. Rivest                              **
5 ** (C) 1990 RSA Data Security, Inc.                                  **
6 ** ********************************************************************
7 */
8
9 /*
10 ** To use MD4:
11 **   -- Include md4.h in your program
12 **   -- Declare an MDstruct MD to hold the state of the digest
13 **          computation.
14 **   -- Initialize MD using MDbegin(&MD)
15 **   -- For each full block (64 bytes) X you wish to process, call
16 **          MD4Update(&MD,X,512)
17 **      (512 is the number of bits in a full block.)
18 **   -- For the last block (less than 64 bytes) you wish to process,
19 **          MD4Update(&MD,X,n)
20 **      where n is the number of bits in the partial block. A partial
21 **      block terminates the computation, so every MD computation
22 **      should terminate by processing a partial block, even if it
23 **      has n = 0.
24 **   -- The message digest is available in MD.buffer[0] ...
25 **      MD.buffer[3].  (Least-significant byte of each word
26 **      should be output first.)
27 **   -- You can print out the digest using MDprint(&MD)
28 */
29
30 /* Implementation notes:
31 ** This implementation assumes that ints are 32-bit quantities.
32 */
33
34 #define TRUE  1
35 #define FALSE 0
36
37 /* Compile-time includes
38 */
39 #include <stdio.h>
40 #include "md4.h"
41 #include "pppd.h"
42
43 /* Compile-time declarations of MD4 "magic constants".
44 */
45 #define I0  0x67452301       /* Initial values for MD buffer */
46 #define I1  0xefcdab89
47 #define I2  0x98badcfe
48 #define I3  0x10325476
49 #define C2  013240474631     /* round 2 constant = sqrt(2) in octal */
50 #define C3  015666365641     /* round 3 constant = sqrt(3) in octal */
51 /* C2 and C3 are from Knuth, The Art of Programming, Volume 2
52 ** (Seminumerical Algorithms), Second Edition (1981), Addison-Wesley.
53 ** Table 2, page 660.
54 */
55
56 #define fs1  3               /* round 1 shift amounts */
57 #define fs2  7
58 #define fs3 11
59 #define fs4 19
60 #define gs1  3               /* round 2 shift amounts */
61 #define gs2  5
62 #define gs3  9
63 #define gs4 13
64 #define hs1  3               /* round 3 shift amounts */
65 #define hs2  9
66 #define hs3 11
67 #define hs4 15
68
69 /* Compile-time macro declarations for MD4.
70 ** Note: The "rot" operator uses the variable "tmp".
71 ** It assumes tmp is declared as unsigned int, so that the >>
72 ** operator will shift in zeros rather than extending the sign bit.
73 */
74 #define f(X,Y,Z)             ((X&Y) | ((~X)&Z))
75 #define g(X,Y,Z)             ((X&Y) | (X&Z) | (Y&Z))
76 #define h(X,Y,Z)             (X^Y^Z)
77 #define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))
78 #define ff(A,B,C,D,i,s)      A = rot((A + f(B,C,D) + X[i]),s)
79 #define gg(A,B,C,D,i,s)      A = rot((A + g(B,C,D) + X[i] + C2),s)
80 #define hh(A,B,C,D,i,s)      A = rot((A + h(B,C,D) + X[i] + C3),s)
81
82 /* MD4print(MDp)
83 ** Print message digest buffer MDp as 32 hexadecimal digits.
84 ** Order is from low-order byte of buffer[0] to high-order byte of
85 ** buffer[3].
86 ** Each byte is printed with high-order hexadecimal digit first.
87 ** This is a user-callable routine.
88 */
89 void
90 MD4Print(MDp)
91 MD4_CTX *MDp;
92 {
93   int i,j;
94   for (i=0;i<4;i++)
95     for (j=0;j<32;j=j+8)
96       printf("%02x",(MDp->buffer[i]>>j) & 0xFF);
97 }
98
99 /* MD4Init(MDp)
100 ** Initialize message digest buffer MDp.
101 ** This is a user-callable routine.
102 */
103 void
104 MD4Init(MDp)
105 MD4_CTX *MDp;
106 {
107   int i;
108   MDp->buffer[0] = I0;
109   MDp->buffer[1] = I1;
110   MDp->buffer[2] = I2;
111   MDp->buffer[3] = I3;
112   for (i=0;i<8;i++) MDp->count[i] = 0;
113   MDp->done = 0;
114 }
115
116 /* MDblock(MDp,X)
117 ** Update message digest buffer MDp->buffer using 16-word data block X.
118 ** Assumes all 16 words of X are full of data.
119 ** Does not update MDp->count.
120 ** This routine is not user-callable.
121 */
122 static void
123 MDblock(MDp,Xb)
124 MD4_CTX *MDp;
125 unsigned char *Xb;
126 {
127   register unsigned int tmp, A, B, C, D;
128   unsigned int X[16];
129   int i;
130
131   for (i = 0; i < 16; ++i) {
132     X[i] = Xb[0] + (Xb[1] << 8) + (Xb[2] << 16) + (Xb[3] << 24);
133     Xb += 4;
134   }
135
136   A = MDp->buffer[0];
137   B = MDp->buffer[1];
138   C = MDp->buffer[2];
139   D = MDp->buffer[3];
140   /* Update the message digest buffer */
141   ff(A , B , C , D ,  0 , fs1); /* Round 1 */
142   ff(D , A , B , C ,  1 , fs2);
143   ff(C , D , A , B ,  2 , fs3);
144   ff(B , C , D , A ,  3 , fs4);
145   ff(A , B , C , D ,  4 , fs1);
146   ff(D , A , B , C ,  5 , fs2);
147   ff(C , D , A , B ,  6 , fs3);
148   ff(B , C , D , A ,  7 , fs4);
149   ff(A , B , C , D ,  8 , fs1);
150   ff(D , A , B , C ,  9 , fs2);
151   ff(C , D , A , B , 10 , fs3);
152   ff(B , C , D , A , 11 , fs4);
153   ff(A , B , C , D , 12 , fs1);
154   ff(D , A , B , C , 13 , fs2);
155   ff(C , D , A , B , 14 , fs3);
156   ff(B , C , D , A , 15 , fs4);
157   gg(A , B , C , D ,  0 , gs1); /* Round 2 */
158   gg(D , A , B , C ,  4 , gs2);
159   gg(C , D , A , B ,  8 , gs3);
160   gg(B , C , D , A , 12 , gs4);
161   gg(A , B , C , D ,  1 , gs1);
162   gg(D , A , B , C ,  5 , gs2);
163   gg(C , D , A , B ,  9 , gs3);
164   gg(B , C , D , A , 13 , gs4);
165   gg(A , B , C , D ,  2 , gs1);
166   gg(D , A , B , C ,  6 , gs2);
167   gg(C , D , A , B , 10 , gs3);
168   gg(B , C , D , A , 14 , gs4);
169   gg(A , B , C , D ,  3 , gs1);
170   gg(D , A , B , C ,  7 , gs2);
171   gg(C , D , A , B , 11 , gs3);
172   gg(B , C , D , A , 15 , gs4);
173   hh(A , B , C , D ,  0 , hs1); /* Round 3 */
174   hh(D , A , B , C ,  8 , hs2);
175   hh(C , D , A , B ,  4 , hs3);
176   hh(B , C , D , A , 12 , hs4);
177   hh(A , B , C , D ,  2 , hs1);
178   hh(D , A , B , C , 10 , hs2);
179   hh(C , D , A , B ,  6 , hs3);
180   hh(B , C , D , A , 14 , hs4);
181   hh(A , B , C , D ,  1 , hs1);
182   hh(D , A , B , C ,  9 , hs2);
183   hh(C , D , A , B ,  5 , hs3);
184   hh(B , C , D , A , 13 , hs4);
185   hh(A , B , C , D ,  3 , hs1);
186   hh(D , A , B , C , 11 , hs2);
187   hh(C , D , A , B ,  7 , hs3);
188   hh(B , C , D , A , 15 , hs4);
189   MDp->buffer[0] += A;
190   MDp->buffer[1] += B;
191   MDp->buffer[2] += C;
192   MDp->buffer[3] += D;
193 }
194
195 /* MD4Update(MDp,X,count)
196 ** Input: X -- a pointer to an array of unsigned characters.
197 **        count -- the number of bits of X to use.
198 **          (if not a multiple of 8, uses high bits of last byte.)
199 ** Update MDp using the number of bits of X given by count.
200 ** This is the basic input routine for an MD4 user.
201 ** The routine completes the MD computation when count < 512, so
202 ** every MD computation should end with one call to MD4Update with a
203 ** count less than 512.  A call with count 0 will be ignored if the
204 ** MD has already been terminated (done != 0), so an extra call with
205 ** count 0 can be given as a "courtesy close" to force termination
206 ** if desired.
207 */
208 void
209 MD4Update(MDp,X,count)
210 MD4_CTX *MDp;
211 unsigned char *X;
212 unsigned int count;
213 {
214   unsigned int i, tmp, bit, byte, mask;
215   unsigned char XX[64];
216   unsigned char *p;
217
218   /* return with no error if this is a courtesy close with count
219   ** zero and MDp->done is true.
220   */
221   if (count == 0 && MDp->done) return;
222   /* check to see if MD is already done and report error */
223   if (MDp->done)
224   { printf("\nError: MD4Update MD already done."); return; }
225
226   /* Add count to MDp->count */
227   tmp = count;
228   p = MDp->count;
229   while (tmp)
230   { tmp += *p;
231   *p++ = tmp;
232   tmp = tmp >> 8;
233   }
234
235   /* Process data */
236   if (count == 512)
237   { /* Full block of data to handle */
238     MDblock(MDp,X);
239   }
240   else if (count > 512) /* Check for count too large */
241   {
242     printf("\nError: MD4Update called with illegal count value %d.",
243            count);
244     return;
245   }
246   else /* partial block -- must be last block so finish up */
247   {
248     /* Find out how many bytes and residual bits there are */
249     byte = count >> 3;
250     bit =  count & 7;
251     /* Copy X into XX since we need to modify it */
252     for (i=0;i<=byte;i++)   XX[i] = X[i];
253     for (i=byte+1;i<64;i++) XX[i] = 0;
254     /* Add padding '1' bit and low-order zeros in last byte */
255     mask = 1 << (7 - bit);
256     XX[byte] = (XX[byte] | mask) & ~( mask - 1);
257     /* If room for bit count, finish up with this block */
258     if (byte <= 55)
259     {
260       for (i=0;i<8;i++) XX[56+i] = MDp->count[i];
261       MDblock(MDp,XX);
262     }
263     else /* need to do two blocks to finish up */
264     {
265       MDblock(MDp,XX);
266       for (i=0;i<56;i++) XX[i] = 0;
267       for (i=0;i<8;i++)  XX[56+i] = MDp->count[i];
268       MDblock(MDp,XX);
269     }
270     /* Set flag saying we're done with MD computation */
271     MDp->done = 1;
272   }
273 }
274
275 /*
276 ** Finish up MD4 computation and return message digest.
277 */
278 void
279 MD4Final(buf, MD)
280 unsigned char *buf;
281 MD4_CTX *MD;
282 {
283   int i, j;
284   unsigned int w;
285
286   MD4Update(MD, NULL, 0);
287   for (i = 0; i < 4; ++i) {
288     w = MD->buffer[i];
289     for (j = 0; j < 4; ++j) {
290       *buf++ = w;
291       w >>= 8;
292     }
293   }
294 }
295
296 /*
297 ** End of md4.c
298 ****************************(cut)***********************************/