masqmail
view src/md5/md5.c @ 305:794071925a22
refactored complex conditions
| author | meillo@marmaro.de |
|---|---|
| date | Sun, 24 Apr 2011 15:10:11 +0200 |
| parents | |
| children |
line source
1 /*
2 * This is an OpenSSL-compatible implementation of the RSA Data Security,
3 * Inc. MD5 Message-Digest Algorithm (RFC 1321).
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 */
18 #ifndef HAVE_OPENSSL
20 #include <string.h>
22 #include "md5.h"
24 /*
25 * The basic MD5 functions.
26 *
27 * F and G are optimized compared to their RFC 1321 definitions for
28 * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
29 * implementation.
30 */
31 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
32 #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
33 #define H(x, y, z) ((x) ^ (y) ^ (z))
34 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
36 /*
37 * The MD5 transformation for all four rounds.
38 */
39 #define STEP(f, a, b, c, d, x, t, s) \
40 (a) += f((b), (c), (d)) + (x) + (t); \
41 (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
42 (a) += (b);
44 /*
45 * SET reads 4 input bytes in little-endian byte order and stores them
46 * in a properly aligned word in host byte order.
47 *
48 * The check for little-endian architectures that tolerate unaligned
49 * memory accesses is just an optimization. Nothing will break if it
50 * doesn't work.
51 */
52 #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
53 #define SET(n) \
54 (*(MD5_u32plus *)&ptr[(n) * 4])
55 #define GET(n) \
56 SET(n)
57 #else
58 #define SET(n) \
59 (ctx->block[(n)] = \
60 (MD5_u32plus)ptr[(n) * 4] | \
61 ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
62 ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
63 ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
64 #define GET(n) \
65 (ctx->block[(n)])
66 #endif
68 /*
69 * This processes one or more 64-byte data blocks, but does NOT update
70 * the bit counters. There are no alignment requirements.
71 */
72 static void *body(MD5_CTX *ctx, void *data, unsigned long size)
73 {
74 unsigned char *ptr;
75 MD5_u32plus a, b, c, d;
76 MD5_u32plus saved_a, saved_b, saved_c, saved_d;
78 ptr = data;
80 a = ctx->a;
81 b = ctx->b;
82 c = ctx->c;
83 d = ctx->d;
85 do {
86 saved_a = a;
87 saved_b = b;
88 saved_c = c;
89 saved_d = d;
91 /* Round 1 */
92 STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
93 STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
94 STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
95 STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
96 STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
97 STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
98 STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
99 STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
100 STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
101 STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
102 STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
103 STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
104 STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
105 STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
106 STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
107 STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
109 /* Round 2 */
110 STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
111 STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
112 STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
113 STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
114 STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
115 STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
116 STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
117 STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
118 STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
119 STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
120 STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
121 STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
122 STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
123 STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
124 STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
125 STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
127 /* Round 3 */
128 STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
129 STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
130 STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
131 STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
132 STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
133 STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
134 STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
135 STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
136 STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
137 STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
138 STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
139 STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
140 STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
141 STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
142 STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
143 STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
145 /* Round 4 */
146 STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
147 STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
148 STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
149 STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
150 STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
151 STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
152 STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
153 STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
154 STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
155 STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
156 STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
157 STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
158 STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
159 STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
160 STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
161 STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
163 a += saved_a;
164 b += saved_b;
165 c += saved_c;
166 d += saved_d;
168 ptr += 64;
169 } while (size -= 64);
171 ctx->a = a;
172 ctx->b = b;
173 ctx->c = c;
174 ctx->d = d;
176 return ptr;
177 }
179 void MD5_Init(MD5_CTX *ctx)
180 {
181 ctx->a = 0x67452301;
182 ctx->b = 0xefcdab89;
183 ctx->c = 0x98badcfe;
184 ctx->d = 0x10325476;
186 ctx->lo = 0;
187 ctx->hi = 0;
188 }
190 void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)
191 {
192 MD5_u32plus saved_lo;
193 unsigned long used, free;
195 saved_lo = ctx->lo;
196 if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
197 ctx->hi++;
198 ctx->hi += size >> 29;
200 used = saved_lo & 0x3f;
202 if (used) {
203 free = 64 - used;
205 if (size < free) {
206 memcpy(&ctx->buffer[used], data, size);
207 return;
208 }
210 memcpy(&ctx->buffer[used], data, free);
211 data = (unsigned char *)data + free;
212 size -= free;
213 body(ctx, ctx->buffer, 64);
214 }
216 if (size >= 64) {
217 data = body(ctx, data, size & ~(unsigned long)0x3f);
218 size &= 0x3f;
219 }
221 memcpy(ctx->buffer, data, size);
222 }
224 void MD5_Final(unsigned char *result, MD5_CTX *ctx)
225 {
226 unsigned long used, free;
228 used = ctx->lo & 0x3f;
230 ctx->buffer[used++] = 0x80;
232 free = 64 - used;
234 if (free < 8) {
235 memset(&ctx->buffer[used], 0, free);
236 body(ctx, ctx->buffer, 64);
237 used = 0;
238 free = 64;
239 }
241 memset(&ctx->buffer[used], 0, free - 8);
243 ctx->lo <<= 3;
244 ctx->buffer[56] = ctx->lo;
245 ctx->buffer[57] = ctx->lo >> 8;
246 ctx->buffer[58] = ctx->lo >> 16;
247 ctx->buffer[59] = ctx->lo >> 24;
248 ctx->buffer[60] = ctx->hi;
249 ctx->buffer[61] = ctx->hi >> 8;
250 ctx->buffer[62] = ctx->hi >> 16;
251 ctx->buffer[63] = ctx->hi >> 24;
253 body(ctx, ctx->buffer, 64);
255 result[0] = ctx->a;
256 result[1] = ctx->a >> 8;
257 result[2] = ctx->a >> 16;
258 result[3] = ctx->a >> 24;
259 result[4] = ctx->b;
260 result[5] = ctx->b >> 8;
261 result[6] = ctx->b >> 16;
262 result[7] = ctx->b >> 24;
263 result[8] = ctx->c;
264 result[9] = ctx->c >> 8;
265 result[10] = ctx->c >> 16;
266 result[11] = ctx->c >> 24;
267 result[12] = ctx->d;
268 result[13] = ctx->d >> 8;
269 result[14] = ctx->d >> 16;
270 result[15] = ctx->d >> 24;
272 memset(ctx, 0, sizeof(*ctx));
273 }
275 #endif