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