5dc7652028b37bc93151dc3c30da57b9942f9e02
[ppp.git] / pppd / plugins / radius / radiusclient / lib / md5.c
1 /*
2  * $Id: md5.c,v 1.1 2002/01/22 16:03:02 dfs Exp $
3  */
4
5 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
6  */
7
8 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
9 rights reserved.
10
11 License to copy and use this software is granted provided that it
12 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
13 Algorithm" in all material mentioning or referencing this software
14 or this function.
15
16 License is also granted to make and use derivative works provided
17 that such works are identified as "derived from the RSA Data
18 Security, Inc. MD5 Message-Digest Algorithm" in all material
19 mentioning or referencing the derived work.
20
21 RSA Data Security, Inc. makes no representations concerning either
22 the merchantability of this software or the suitability of this
23 software for any particular purpose. It is provided "as is"
24 without express or implied warranty of any kind.
25
26 These notices must be retained in any copies of any part of this
27 documentation and/or software.
28  */
29
30 #include <string.h>
31
32 #include <config.h>
33 #include <includes.h>
34 #include <radiusclient.h>
35
36 typedef unsigned char           *POINTER;
37
38 /* MD5 context. */
39 typedef struct
40 {
41         UINT4           state[4];  /* state (ABCD) */
42         UINT4           count[2];  /* number of bits, modulo 2^64 (lsb first) */
43         unsigned char   buffer[64]; /* input buffer */
44 } MD5_CTX;
45
46 static void MD5Init    (MD5_CTX *);
47 static void MD5Update  (MD5_CTX *, unsigned char *, unsigned int);
48 static void MD5Final   (unsigned char[16], MD5_CTX *);
49
50 /* Constants for MD5Transform routine.
51  */
52 #define S11 7
53 #define S12 12
54 #define S13 17
55 #define S14 22
56 #define S21 5
57 #define S22 9
58 #define S23 14
59 #define S24 20
60 #define S31 4
61 #define S32 11
62 #define S33 16
63 #define S34 23
64 #define S41 6
65 #define S42 10
66 #define S43 15
67 #define S44 21
68
69 static void MD5Transform (UINT4[4], unsigned char[64]);
70 static void Encode (unsigned char *, UINT4 *, unsigned int);
71 static void Decode (UINT4 *, unsigned char *, unsigned int);
72 static void MD5_memcpy (POINTER, POINTER, unsigned int);
73 static void MD5_memset (POINTER, int, unsigned int);
74
75 static unsigned char PADDING[64] = {
76         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
77         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
79 };
80
81 /* F, G, H and I are basic MD5 functions.
82  */
83 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
84 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
85 #define H(x, y, z) ((x) ^ (y) ^ (z))
86 #define I(x, y, z) ((y) ^ ((x) | (~z)))
87
88 /* ROTATE_LEFT rotates x left n bits.
89  */
90 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
91
92 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
93 Rotation is separate from addition to prevent recomputation.
94  */
95 #define FF(a, b, c, d, x, s, ac) { \
96  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
97  (a) = ROTATE_LEFT ((a), (s)); \
98  (a) += (b); \
99   }
100 #define GG(a, b, c, d, x, s, ac) { \
101  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
102  (a) = ROTATE_LEFT ((a), (s)); \
103  (a) += (b); \
104   }
105 #define HH(a, b, c, d, x, s, ac) { \
106  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
107  (a) = ROTATE_LEFT ((a), (s)); \
108  (a) += (b); \
109   }
110 #define II(a, b, c, d, x, s, ac) { \
111  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
112  (a) = ROTATE_LEFT ((a), (s)); \
113  (a) += (b); \
114   }
115
116 void rc_md5_calc (unsigned char *output, unsigned char *input, unsigned int inlen)
117 {
118         MD5_CTX         context;
119
120         MD5Init (&context);
121         MD5Update (&context, input, inlen);
122         MD5Final (output, &context);
123 }
124
125 /* MD5 initialization. Begins an MD5 operation, writing a new context.
126  */
127 static void MD5Init (MD5_CTX *context)
128 {
129         context->count[0] = context->count[1] = 0;
130
131         /*
132          * Load magic initialization constants.
133          */
134         context->state[0] = 0x67452301;
135         context->state[1] = 0xefcdab89;
136         context->state[2] = 0x98badcfe;
137         context->state[3] = 0x10325476;
138 }
139
140 /* MD5 block update operation. Continues an MD5 message-digest
141   operation, processing another message block, and updating the
142   context.
143  */
144 static void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
145 {
146         unsigned int    i,
147                         index,
148                         partLen;
149
150         /* Compute number of bytes mod 64 */
151         index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
152
153         /* Update number of bits */
154         if ((context->count[0] += ((UINT4) inputLen << 3))
155                         < ((UINT4) inputLen << 3))
156                 context->count[1]++;
157         context->count[1] += ((UINT4) inputLen >> 29);
158
159         partLen = 64 - index;
160
161         /*
162          * Transform as many times as possible.
163          */
164         if (inputLen >= partLen)
165         {
166                 MD5_memcpy
167                         ((POINTER) & context->buffer[index], (POINTER) input, partLen);
168                 MD5Transform (context->state, context->buffer);
169
170                 for (i = partLen; i + 63 < inputLen; i += 64)
171                         MD5Transform (context->state, &input[i]);
172
173                 index = 0;
174         }
175         else
176                 i = 0;
177
178         /* Buffer remaining input */
179         MD5_memcpy
180                 ((POINTER) & context->buffer[index], (POINTER) & input[i],
181                  inputLen - i);
182 }
183
184 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
185   the message digest and zeroizing the context.
186  */
187 static void MD5Final (unsigned char *digest, MD5_CTX *context)
188 {
189         unsigned char   bits[8];
190         unsigned int    index,
191                         padLen;
192
193         /* Save number of bits */
194         Encode (bits, context->count, 8);
195
196         /*
197          * Pad out to 56 mod 64.
198          */
199         index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
200         padLen = (index < 56) ? (56 - index) : (120 - index);
201         MD5Update (context, PADDING, padLen);
202
203         /* Append length (before padding) */
204         MD5Update (context, bits, 8);
205
206         /* Store state in digest */
207         Encode (digest, context->state, 16);
208
209         /*
210          * Zeroize sensitive information.
211          */
212         MD5_memset ((POINTER) context, 0, sizeof (*context));
213 }
214
215 /* MD5 basic transformation. Transforms state based on block.
216  */
217 static void MD5Transform (UINT4 *state, unsigned char *block)
218 {
219         UINT4           a = state[0],
220                         b = state[1],
221                         c = state[2],
222                         d = state[3],
223                         x[16];
224
225         Decode (x, block, 64);
226
227         /* Round 1 */
228         FF (a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
229         FF (d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
230         FF (c, d, a, b, x[2], S13, 0x242070db); /* 3 */
231         FF (b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
232         FF (a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
233         FF (d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
234         FF (c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
235         FF (b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
236         FF (a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
237         FF (d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
238         FF (c, d, a, b, x[10], S13, 0xffff5bb1);        /* 11 */
239         FF (b, c, d, a, x[11], S14, 0x895cd7be);        /* 12 */
240         FF (a, b, c, d, x[12], S11, 0x6b901122);        /* 13 */
241         FF (d, a, b, c, x[13], S12, 0xfd987193);        /* 14 */
242         FF (c, d, a, b, x[14], S13, 0xa679438e);        /* 15 */
243         FF (b, c, d, a, x[15], S14, 0x49b40821);        /* 16 */
244
245         /* Round 2 */
246         GG (a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
247         GG (d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
248         GG (c, d, a, b, x[11], S23, 0x265e5a51);        /* 19 */
249         GG (b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
250         GG (a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
251         GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
252         GG (c, d, a, b, x[15], S23, 0xd8a1e681);        /* 23 */
253         GG (b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
254         GG (a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
255         GG (d, a, b, c, x[14], S22, 0xc33707d6);        /* 26 */
256         GG (c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
257         GG (b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
258         GG (a, b, c, d, x[13], S21, 0xa9e3e905);        /* 29 */
259         GG (d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
260         GG (c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
261         GG (b, c, d, a, x[12], S24, 0x8d2a4c8a);        /* 32 */
262
263         /* Round 3 */
264         HH (a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
265         HH (d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
266         HH (c, d, a, b, x[11], S33, 0x6d9d6122);        /* 35 */
267         HH (b, c, d, a, x[14], S34, 0xfde5380c);        /* 36 */
268         HH (a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
269         HH (d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
270         HH (c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
271         HH (b, c, d, a, x[10], S34, 0xbebfbc70);        /* 40 */
272         HH (a, b, c, d, x[13], S31, 0x289b7ec6);        /* 41 */
273         HH (d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
274         HH (c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
275         HH (b, c, d, a, x[6], S34, 0x4881d05);  /* 44 */
276         HH (a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
277         HH (d, a, b, c, x[12], S32, 0xe6db99e5);        /* 46 */
278         HH (c, d, a, b, x[15], S33, 0x1fa27cf8);        /* 47 */
279         HH (b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
280
281         /* Round 4 */
282         II (a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
283         II (d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
284         II (c, d, a, b, x[14], S43, 0xab9423a7);        /* 51 */
285         II (b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
286         II (a, b, c, d, x[12], S41, 0x655b59c3);        /* 53 */
287         II (d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
288         II (c, d, a, b, x[10], S43, 0xffeff47d);        /* 55 */
289         II (b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
290         II (a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
291         II (d, a, b, c, x[15], S42, 0xfe2ce6e0);        /* 58 */
292         II (c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
293         II (b, c, d, a, x[13], S44, 0x4e0811a1);        /* 60 */
294         II (a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
295         II (d, a, b, c, x[11], S42, 0xbd3af235);        /* 62 */
296         II (c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
297         II (b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
298
299         state[0] += a;
300         state[1] += b;
301         state[2] += c;
302         state[3] += d;
303
304         /*
305          * Zeroize sensitive information.
306          */
307         MD5_memset ((POINTER) x, 0, sizeof (x));
308 }
309
310 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
311   a multiple of 4.
312  */
313 static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
314 {
315         unsigned int    i,
316                         j;
317
318         for (i = 0, j = 0; j < len; i++, j += 4)
319         {
320                 output[j] = (unsigned char) (input[i] & 0xff);
321                 output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
322                 output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
323                 output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
324         }
325 }
326
327 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
328   a multiple of 4.
329  */
330 static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
331 {
332         unsigned int    i,
333                         j;
334
335         for (i = 0, j = 0; j < len; i++, j += 4)
336                 output[i] = ((UINT4) input[j]) | (((UINT4) input[j + 1]) << 8) |
337                         (((UINT4) input[j + 2]) << 16) | (((UINT4) input[j + 3]) << 24);
338 }
339
340 static void MD5_memcpy (POINTER output, POINTER input, unsigned int len)
341 {
342         memcpy(output, input, len);
343 }
344
345 static void MD5_memset (POINTER output, int value, unsigned int len)
346 {
347         memset(output, value, len);
348 }