/[cvs]/eggdrop1.9/src/md5.c
ViewVC logotype

Contents of /eggdrop1.9/src/md5.c

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph


Revision 1.2 - (show annotations) (download) (as text)
Sun Nov 3 23:16:09 2002 UTC (16 years, 7 months ago) by stdarg
Branch: MAIN
CVS Tags: HEAD
Changes since 1.1: +0 -0 lines
File MIME type: text/x-chdr
FILE REMOVED
* Moved md5 code to lib/eggdrop so I can use it for password hashing
* Passwords are stored as standard hex encoding of md5(salt + password)
* Started moving script interface functions to modules/script

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

webmaster@eggheads.org
ViewVC Help
Powered by ViewVC 1.1.23