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

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

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


Revision 1.2 - (hide annotations) (download) (as text)
Tue Oct 19 12:13:33 2010 UTC (8 years, 8 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 simple 1.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 pseudo 1.2 #ifndef HAVE_OPENSSL_MD5
24 simple 1.1 /*
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 pseudo 1.2 #endif /* HAVE_OPENSSL_MD5 */

webmaster@eggheads.org
ViewVC Help
Powered by ViewVC 1.1.23