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