Merge from Master
[l2tpns.git] / md5.c
1 /*
2 * This is an OpenSSL-compatible implementation of the RSA Data Security,
3 * Inc. MD5 Message-Digest Algorithm.
4 *
5 * Written by Solar Designer <solar at openwall.com> in 2001, and placed
6 * in the public domain. There's absolutely no warranty.
7 *
8 * This differs from Colin Plumb's older public domain implementation in
9 * that no 32-bit integer data type is required, there's no compile-time
10 * endianness configuration, and the function prototypes match OpenSSL's.
11 * The primary goals are portability and ease of use.
12 *
13 * This implementation is meant to be fast, but not as fast as possible.
14 * Some known optimizations are not included to reduce source code size
15 * and avoid compile-time configuration.
16 */
17
18 #include <string.h>
19 #include "md5.h"
20
21 /*
22 * The basic MD5 functions.
23 *
24 * F is optimized compared to its RFC 1321 definition just like in Colin
25 * Plumb's implementation.
26 */
27 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
28 #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
29 #define H(x, y, z) ((x) ^ (y) ^ (z))
30 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
31
32 /*
33 * The MD5 transformation for all four rounds.
34 */
35 #define STEP(f, a, b, c, d, x, t, s) \
36 (a) += f((b), (c), (d)) + (x) + (t); \
37 (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
38 (a) += (b);
39
40 /*
41 * SET reads 4 input bytes in little-endian byte order and stores them
42 * in a properly aligned word in host byte order.
43 *
44 * The check for little-endian architectures which tolerate unaligned
45 * memory accesses is just an optimization. Nothing will break if it
46 * doesn't work.
47 */
48 #if defined(__i386__) || defined(__vax__)
49 # define SET(n) (*(MD5_u32plus *)&ptr[(n) * 4])
50 # define GET(n) SET(n)
51 #else
52 # define SET(n) \
53 (ctx->block[(n)] = \
54 (MD5_u32plus)ptr[(n) * 4] | \
55 ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
56 ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
57 ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
58 # define GET(n) \
59 (ctx->block[(n)])
60 #endif
61
62 /*
63 * This processes one or more 64-byte data blocks, but does NOT update
64 * the bit counters. There're no alignment requirements.
65 */
66 static void *body(MD5_CTX *ctx, void *data, unsigned long size)
67 {
68 unsigned char *ptr;
69 MD5_u32plus a, b, c, d;
70 MD5_u32plus saved_a, saved_b, saved_c, saved_d;
71
72 ptr = data;
73
74 a = ctx->a;
75 b = ctx->b;
76 c = ctx->c;
77 d = ctx->d;
78
79 do {
80 saved_a = a;
81 saved_b = b;
82 saved_c = c;
83 saved_d = d;
84
85 /* Round 1 */
86 STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
87 STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
88 STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
89 STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
90 STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
91 STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
92 STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
93 STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
94 STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
95 STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
96 STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
97 STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
98 STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
99 STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
100 STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
101 STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
102
103 /* Round 2 */
104 STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
105 STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
106 STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
107 STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
108 STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
109 STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
110 STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
111 STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
112 STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
113 STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
114 STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
115 STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
116 STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
117 STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
118 STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
119 STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
120
121 /* Round 3 */
122 STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
123 STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
124 STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
125 STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
126 STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
127 STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
128 STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
129 STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
130 STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
131 STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
132 STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
133 STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
134 STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
135 STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
136 STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
137 STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
138
139 /* Round 4 */
140 STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
141 STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
142 STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
143 STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
144 STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
145 STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
146 STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
147 STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
148 STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
149 STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
150 STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
151 STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
152 STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
153 STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
154 STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
155 STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
156
157 a += saved_a;
158 b += saved_b;
159 c += saved_c;
160 d += saved_d;
161
162 ptr += MD5_BLOCK_SZ;
163 } while (size -= MD5_BLOCK_SZ);
164
165 ctx->a = a;
166 ctx->b = b;
167 ctx->c = c;
168 ctx->d = d;
169
170 return ptr;
171 }
172
173 void MD5_Init(MD5_CTX *ctx)
174 {
175 ctx->a = 0x67452301;
176 ctx->b = 0xefcdab89;
177 ctx->c = 0x98badcfe;
178 ctx->d = 0x10325476;
179
180 ctx->lo = 0;
181 ctx->hi = 0;
182 }
183
184 void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)
185 {
186 MD5_u32plus saved_lo;
187 unsigned long used, free;
188
189 saved_lo = ctx->lo;
190 if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
191 ctx->hi++;
192
193 ctx->hi += size >> 29;
194
195 used = saved_lo & 0x3f;
196
197 if (used)
198 {
199 free = MD5_BLOCK_SZ - used;
200
201 if (size < free)
202 {
203 memcpy(&ctx->buffer[used], data, size);
204 return;
205 }
206
207 memcpy(&ctx->buffer[used], data, free);
208 data = (unsigned char *)data + free;
209 size -= free;
210 body(ctx, ctx->buffer, MD5_BLOCK_SZ);
211 }
212
213 if (size >= MD5_BLOCK_SZ)
214 {
215 data = body(ctx, data, size & ~(unsigned long)0x3f);
216 size &= 0x3f;
217 }
218
219 memcpy(ctx->buffer, data, size);
220 }
221
222 void MD5_Final(unsigned char *result, MD5_CTX *ctx)
223 {
224 unsigned long used, free;
225
226 used = ctx->lo & 0x3f;
227
228 ctx->buffer[used++] = 0x80;
229
230 free = MD5_BLOCK_SZ - used;
231
232 if (free < 8)
233 {
234 memset(&ctx->buffer[used], 0, free);
235 body(ctx, ctx->buffer, MD5_BLOCK_SZ);
236 used = 0;
237 free = MD5_BLOCK_SZ;
238 }
239
240 memset(&ctx->buffer[used], 0, free - 8);
241
242 ctx->lo <<= 3;
243 ctx->buffer[56] = ctx->lo;
244 ctx->buffer[57] = ctx->lo >> 8;
245 ctx->buffer[58] = ctx->lo >> 16;
246 ctx->buffer[59] = ctx->lo >> 24;
247 ctx->buffer[60] = ctx->hi;
248 ctx->buffer[61] = ctx->hi >> 8;
249 ctx->buffer[62] = ctx->hi >> 16;
250 ctx->buffer[63] = ctx->hi >> 24;
251
252 body(ctx, ctx->buffer, MD5_BLOCK_SZ);
253
254 result[0] = ctx->a;
255 result[1] = ctx->a >> 8;
256 result[2] = ctx->a >> 16;
257 result[3] = ctx->a >> 24;
258 result[4] = ctx->b;
259 result[5] = ctx->b >> 8;
260 result[6] = ctx->b >> 16;
261 result[7] = ctx->b >> 24;
262 result[8] = ctx->c;
263 result[9] = ctx->c >> 8;
264 result[10] = ctx->c >> 16;
265 result[11] = ctx->c >> 24;
266 result[12] = ctx->d;
267 result[13] = ctx->d >> 8;
268 result[14] = ctx->d >> 16;
269 result[15] = ctx->d >> 24;
270
271 memset(ctx, 0, sizeof(*ctx));
272 }