projects / awesomized / libmemcached / blob
? search:


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