/[cvs]/eggdrop1.8/src/md5/md5c.c
ViewVC logotype

Contents of /eggdrop1.8/src/md5/md5c.c

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


Revision 1.2 - (show annotations) (download) (as text)
Tue Oct 19 12:13:33 2010 UTC (8 years, 7 months ago) by pseudo
Branch: MAIN
CVS Tags: HEAD
Branch point for: gettext
Changes since 1.1: +2 -0 lines
File MIME type: text/x-chdr
Added full SSL support including Tcl commands.
Added support for certificate authentication.
Added support for botnet and partyline encryption using ssl.
Documented the new features and commands.
Fixed add_server() problems with IPv6 addresses in the server list.

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

webmaster@eggheads.org
ViewVC Help
Powered by ViewVC 1.1.23