Mercurial > projects > hoofbaby

comparison deps/Platinum/ThirdParty/Neptune/ThirdParty/axTLS/crypto/md5.c @ 0:3425707ddbf6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial import (hopefully this mercurial stuff works...)
author fraserofthenight
date Mon, 06 Jul 2009 08:06:28 -0700
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:3425707ddbf6
1 /*
2 * Copyright (c) 2007, Cameron Rich
3 *
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * * Redistributions of source code must retain the above copyright notice,
10 * this list of conditions and the following disclaimer.
11 * * Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 * * Neither the name of the axTLS project nor the names of its contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
22 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 /**
32 * This file implements the MD5 algorithm as defined in RFC1321
33 */
34
35 #include <string.h>
36 #include "crypto.h"
37
38 /* Constants for MD5Transform routine.
39 */
40 #define S11 7
41 #define S12 12
42 #define S13 17
43 #define S14 22
44 #define S21 5
45 #define S22 9
46 #define S23 14
47 #define S24 20
48 #define S31 4
49 #define S32 11
50 #define S33 16
51 #define S34 23
52 #define S41 6
53 #define S42 10
54 #define S43 15
55 #define S44 21
56
57 /* ----- static functions ----- */
58 static void MD5Transform(uint32_t state[4], const uint8_t block[64]);
59 static void Encode(uint8_t *output, uint32_t *input, uint32_t len);
60 static void Decode(uint32_t *output, const uint8_t *input, uint32_t len);
61
62 static const uint8_t PADDING[64] =
63 {
64 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
66 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
67 };
68
69 /* F, G, H and I are basic MD5 functions.
70 */
71 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
72 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
73 #define H(x, y, z) ((x) ^ (y) ^ (z))
74 #define I(x, y, z) ((y) ^ ((x) | (~z)))
75
76 /* ROTATE_LEFT rotates x left n bits. */
77 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
78
79 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
80 Rotation is separate from addition to prevent recomputation. */
81 #define FF(a, b, c, d, x, s, ac) { \
82 (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
83 (a) = ROTATE_LEFT ((a), (s)); \
84 (a) += (b); \
85 }
86 #define GG(a, b, c, d, x, s, ac) { \
87 (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
88 (a) = ROTATE_LEFT ((a), (s)); \
89 (a) += (b); \
90 }
91 #define HH(a, b, c, d, x, s, ac) { \
92 (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
93 (a) = ROTATE_LEFT ((a), (s)); \
94 (a) += (b); \
95 }
96 #define II(a, b, c, d, x, s, ac) { \
97 (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
98 (a) = ROTATE_LEFT ((a), (s)); \
99 (a) += (b); \
100 }
101
102 /**
103 * MD5 initialization - begins an MD5 operation, writing a new ctx.
104 */
105 EXP_FUNC void STDCALL MD5_Init(MD5_CTX *ctx)
106 {
107 ctx->count[0] = ctx->count[1] = 0;
108
109 /* Load magic initialization constants.
110 */
111 ctx->state[0] = 0x67452301;
112 ctx->state[1] = 0xefcdab89;
113 ctx->state[2] = 0x98badcfe;
114 ctx->state[3] = 0x10325476;
115 }
116
117 /**
118 * Accepts an array of octets as the next portion of the message.
119 */
120 EXP_FUNC void STDCALL MD5_Update(MD5_CTX *ctx, const uint8_t * msg, int len)
121 {
122 uint32_t x;
123 int i, partLen;
124
125 /* Compute number of bytes mod 64 */
126 x = (uint32_t)((ctx->count[0] >> 3) & 0x3F);
127
128 /* Update number of bits */
129 if ((ctx->count[0] += ((uint32_t)len << 3)) < ((uint32_t)len << 3))
130 ctx->count[1]++;
131 ctx->count[1] += ((uint32_t)len >> 29);
132
133 partLen = 64 - x;
134
135 /* Transform as many times as possible. */
136 if (len >= partLen)
137 {
138 memcpy(&ctx->buffer[x], msg, partLen);
139 MD5Transform(ctx->state, ctx->buffer);
140
141 for (i = partLen; i + 63 < len; i += 64)
142 MD5Transform(ctx->state, &msg[i]);
143
144 x = 0;
145 }
146 else
147 i = 0;
148
149 /* Buffer remaining input */
150 memcpy(&ctx->buffer[x], &msg[i], len-i);
151 }
152
153 /**
154 * Return the 128-bit message digest into the user's array
155 */
156 EXP_FUNC void STDCALL MD5_Final(uint8_t *digest, MD5_CTX *ctx)
157 {
158 uint8_t bits[8];
159 uint32_t x, padLen;
160
161 /* Save number of bits */
162 Encode(bits, ctx->count, 8);
163
164 /* Pad out to 56 mod 64.
165 */
166 x = (uint32_t)((ctx->count[0] >> 3) & 0x3f);
167 padLen = (x < 56) ? (56 - x) : (120 - x);
168 MD5_Update(ctx, PADDING, padLen);
169
170 /* Append length (before padding) */
171 MD5_Update(ctx, bits, 8);
172
173 /* Store state in digest */
174 Encode(digest, ctx->state, MD5_SIZE);
175 }
176
177 /**
178 * MD5 basic transformation. Transforms state based on block.
179 */
180 static void MD5Transform(uint32_t state[4], const uint8_t block[64])
181 {
182 uint32_t a = state[0], b = state[1], c = state[2],
183 d = state[3], x[MD5_SIZE];
184
185 Decode(x, block, 64);
186
187 /* Round 1 */
188 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
189 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
190 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
191 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
192 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
193 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
194 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
195 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
196 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
197 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
198 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
199 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
200 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
201 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
202 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
203 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
204
205 /* Round 2 */
206 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
207 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
208 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
209 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
210 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
211 GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
212 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
213 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
214 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
215 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
216 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
217 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
218 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
219 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
220 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
221 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
222
223 /* Round 3 */
224 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
225 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
226 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
227 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
228 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
229 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
230 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
231 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
232 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
233 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
234 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
235 HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
236 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
237 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
238 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
239 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
240
241 /* Round 4 */
242 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
243 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
244 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
245 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
246 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
247 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
248 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
249 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
250 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
251 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
252 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
253 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
254 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
255 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
256 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
257 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
258
259 state[0] += a;
260 state[1] += b;
261 state[2] += c;
262 state[3] += d;
263 }
264
265 /**
266 * Encodes input (uint32_t) into output (uint8_t). Assumes len is
267 * a multiple of 4.
268 */
269 static void Encode(uint8_t *output, uint32_t *input, uint32_t len)
270 {
271 uint32_t i, j;
272
273 for (i = 0, j = 0; j < len; i++, j += 4)
274 {
275 output[j] = (uint8_t)(input[i] & 0xff);
276 output[j+1] = (uint8_t)((input[i] >> 8) & 0xff);
277 output[j+2] = (uint8_t)((input[i] >> 16) & 0xff);
278 output[j+3] = (uint8_t)((input[i] >> 24) & 0xff);
279 }
280 }
281
282 /**
283 * Decodes input (uint8_t) into output (uint32_t). Assumes len is
284 * a multiple of 4.
285 */
286 static void Decode(uint32_t *output, const uint8_t *input, uint32_t len)
287 {
288 uint32_t i, j;
289
290 for (i = 0, j = 0; j < len; i++, j += 4)
291 output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) |
292 (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
293 }