source: rtems/cpukit/pppd/md4.c @ 2129ac8

4.104.114.84.9
Last change on this file since 2129ac8 was d0950ad, checked in by Joel Sherrill <joel.sherrill@…>, on Nov 30, 1999 at 10:12:50 PM

Added port of ppp-2.3.5 from Tomasz Domin <dot@…> of ComArch? SA.
Tomasz only tested this on the mpc823.

The official site for the original source for this PPP implementation is:

ftp://cs.anu.edu.au/pub/software/ppp

NOTE: As of 11/30/1999, the current version of this source is 2.3.10.

  • Property mode set to 100644
File size: 8.4 KB
Line 
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*/
89void
90MD4Print(MDp)
91MD4_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*/
103void
104MD4Init(MDp)
105MD4_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*/
122static void
123MDblock(MDp,Xb)
124MD4_CTX *MDp;
125unsigned 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*/
208void
209MD4Update(MDp,X,count)
210MD4_CTX *MDp;
211unsigned char *X;
212unsigned 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*/
278void
279MD4Final(buf, MD)
280unsigned char *buf;
281MD4_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)***********************************/
Note: See TracBrowser for help on using the repository browser.