renamed dict_append_if_new2 to dict_append_if_new
[swftools.git] / lib / MD5.c
1 /*      $FreeBSD: src/sys/crypto/md5.h,v 1.4 2002/03/20 05:13:50 alfred Exp $   */
2 /*      $KAME: md5.h,v 1.4 2000/03/27 04:36:22 sumikawa Exp $   */
3
4 /*
5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the project nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32
33 #include "../config.h"
34
35 #include <string.h>
36
37 #ifndef _NETINET6_MD5_H_
38 #define _NETINET6_MD5_H_
39
40 #define MD5_BUFLEN      64
41
42 #ifndef LITTLE_ENDIAN
43 #define LITTLE_ENDIAN 1
44 #endif
45 #ifndef BIG_ENDIAN
46 #define BIG_ENDIAN 2
47 #endif
48 #ifndef BYTE_ORDER
49 #ifdef WORDS_BIGENDIAN
50 #define BYTE_ORDER BIG_ENDIAN
51 #else
52 #define BYTE_ORDER LITTLE_ENDIAN
53 #endif
54 #endif
55
56 typedef long unsigned int u_int32_t;
57 typedef long long unsigned int u_int64_t;
58 typedef unsigned char u_int8_t;
59 typedef unsigned int u_int;
60 typedef unsigned long u_long;
61 typedef unsigned char u_char;
62
63 typedef struct {
64         union {
65                 u_int32_t       md5_state32[4];
66                 u_int8_t        md5_state8[16];
67         } md5_st;
68
69 #define md5_sta         md5_st.md5_state32[0]
70 #define md5_stb         md5_st.md5_state32[1]
71 #define md5_stc         md5_st.md5_state32[2]
72 #define md5_std         md5_st.md5_state32[3]
73 #define md5_st8         md5_st.md5_state8
74
75         union {
76                 u_int64_t       md5_count64;
77                 u_int8_t        md5_count8[8];
78         } md5_count;
79 #define md5_n   md5_count.md5_count64
80 #define md5_n8  md5_count.md5_count8
81
82         u_int   md5_i;
83         u_int8_t        md5_buf[MD5_BUFLEN];
84 } md5_ctxt;
85
86 static void md5_init(md5_ctxt *);
87 static void md5_loop(md5_ctxt *, const u_int8_t *, u_int);
88 static void md5_pad(md5_ctxt *);
89 static void md5_result(u_int8_t *, md5_ctxt *);
90
91 /* compatibility */
92 #define MD5_CTX         md5_ctxt
93 #define MD5Init(x)      md5_init((x))
94 #define MD5Update(x, y, z)      md5_loop((x), (y), (z))
95 #define MD5Final(x, y) \
96 do {                            \
97         md5_pad((y));           \
98         md5_result((x), (y));   \
99 } while (0)
100
101 #endif /* ! _NETINET6_MD5_H_*/
102
103 /*-
104  * Copyright (c) 2003 Poul-Henning Kamp
105  * Copyright (c) 1999
106  *      University of California.  All rights reserved.
107  * All rights reserved.
108  *
109  * Redistribution and use in source and binary forms, with or without
110  * modification, are permitted provided that the following conditions
111  * are met:
112  * 1. Redistributions of source code must retain the above copyright
113  *    notice, this list of conditions and the following disclaimer.
114  * 2. Redistributions in binary form must reproduce the above copyright
115  *    notice, this list of conditions and the following disclaimer in the
116  *    documentation and/or other materials provided with the distribution.
117  * 3. Neither the name of the author nor the names of any co-contributors
118  *    may be used to endorse or promote products derived from this software
119  *    without specific prior written permission.
120  *
121  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
122  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
123  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
124  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
125  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
126  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
127  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
128  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
129  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
130  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
131  * SUCH DAMAGE.
132  */
133
134
135 /*
136  * UNIX password
137  */
138
139 #ifndef HAVE_BCOPY
140 void bcopy(const void*src, void*dest, int len) 
141 {
142     memcpy(dest, src, len);
143 }
144 #endif
145
146 #ifndef HAVE_BZERO
147 void bzero(void*mem, int len) 
148 {
149     memset(mem, 0, len);
150 }
151 #endif
152
153 #define MD4_SIZE 16
154 #define MD5_SIZE 16
155
156 static char itoa64[] =          /* 0 ... 63 => ascii - 64 */
157         "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
158
159 static void
160 _crypt_to64(char *s, u_long v, int n)
161 {
162         while (--n >= 0) {
163                 *s++ = itoa64[v&0x3f];
164                 v >>= 6;
165         }
166 }
167
168 void hash_md5(const unsigned char*buf, int len, unsigned char*dest)
169 {
170     u_char final[MD5_SIZE];
171
172     MD5_CTX ctx;
173     MD5Init(&ctx);
174     MD5Update(&ctx, buf, len);
175     MD5Final(dest, &ctx);
176 }
177
178 char * crypt_md5(const char *pw, const char *salt)
179 {
180         MD5_CTX ctx,ctx1;
181         unsigned long l;
182         int sl, pl;
183         u_int i;
184         u_char final[MD5_SIZE];
185         static const char *sp, *ep;
186         static char passwd[120], *p;
187         static const char *magic = "$1$";
188
189         /* Refine the Salt first */
190         sp = salt;
191
192         /* If it starts with the magic string, then skip that */
193         if(!strncmp(sp, magic, strlen(magic)))
194                 sp += strlen(magic);
195
196         /* It stops at the first '$', max 8 chars */
197         for(ep = sp; *ep && *ep != '$' && ep < (sp + 8); ep++)
198                 continue;
199
200         /* get the length of the true salt */
201         sl = ep - sp;
202
203         MD5Init(&ctx);
204
205         /* The password first, since that is what is most unknown */
206         MD5Update(&ctx, (const u_char *)pw, strlen(pw));
207
208         /* Then our magic string */
209         MD5Update(&ctx, (const u_char *)magic, strlen(magic));
210
211         /* Then the raw salt */
212         MD5Update(&ctx, (const u_char *)sp, (u_int)sl);
213
214         /* Then just as many characters of the MD5(pw,salt,pw) */
215         MD5Init(&ctx1);
216         MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
217         MD5Update(&ctx1, (const u_char *)sp, (u_int)sl);
218         MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
219         MD5Final(final, &ctx1);
220         for(pl = (int)strlen(pw); pl > 0; pl -= MD5_SIZE)
221                 MD5Update(&ctx, (const u_char *)final,
222                     (u_int)(pl > MD5_SIZE ? MD5_SIZE : pl));
223
224         /* Don't leave anything around in vm they could use. */
225         memset(final, 0, sizeof(final));
226
227         /* Then something really weird... */
228         for (i = strlen(pw); i; i >>= 1)
229                 if(i & 1)
230                     MD5Update(&ctx, (const u_char *)final, 1);
231                 else
232                     MD5Update(&ctx, (const u_char *)pw, 1);
233
234         /* Now make the output string */
235         strcpy(passwd, magic);
236         strncat(passwd, sp, (u_int)sl);
237         strcat(passwd, "$");
238
239         MD5Final(final, &ctx);
240
241         /*
242          * and now, just to make sure things don't run too fast
243          * On a 60 Mhz Pentium this takes 34 msec, so you would
244          * need 30 seconds to build a 1000 entry dictionary...
245          */
246         for(i = 0; i < 1000; i++) {
247                 MD5Init(&ctx1);
248                 if(i & 1)
249                         MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
250                 else
251                         MD5Update(&ctx1, (const u_char *)final, MD5_SIZE);
252
253                 if(i % 3)
254                         MD5Update(&ctx1, (const u_char *)sp, (u_int)sl);
255
256                 if(i % 7)
257                         MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
258
259                 if(i & 1)
260                         MD5Update(&ctx1, (const u_char *)final, MD5_SIZE);
261                 else
262                         MD5Update(&ctx1, (const u_char *)pw, strlen(pw));
263                 MD5Final(final, &ctx1);
264         }
265
266         p = passwd + strlen(passwd);
267
268         l = (final[ 0]<<16) | (final[ 6]<<8) | final[12];
269         _crypt_to64(p, l, 4); p += 4;
270         l = (final[ 1]<<16) | (final[ 7]<<8) | final[13];
271         _crypt_to64(p, l, 4); p += 4;
272         l = (final[ 2]<<16) | (final[ 8]<<8) | final[14];
273         _crypt_to64(p, l, 4); p += 4;
274         l = (final[ 3]<<16) | (final[ 9]<<8) | final[15];
275         _crypt_to64(p, l, 4); p += 4;
276         l = (final[ 4]<<16) | (final[10]<<8) | final[ 5];
277         _crypt_to64(p, l, 4); p += 4;
278         l = final[11];
279         _crypt_to64(p, l, 2); p += 2;
280         *p = '\0';
281
282         /* Don't leave anything around in vm they could use. */
283         memset(final, 0, sizeof(final));
284
285         return (passwd);
286 }
287
288 /*      $KAME: md5.c,v 1.5 2000/11/08 06:13:08 itojun Exp $     */
289 /*
290  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
291  * All rights reserved.
292  *
293  * Redistribution and use in source and binary forms, with or without
294  * modification, are permitted provided that the following conditions
295  * are met:
296  * 1. Redistributions of source code must retain the above copyright
297  *    notice, this list of conditions and the following disclaimer.
298  * 2. Redistributions in binary form must reproduce the above copyright
299  *    notice, this list of conditions and the following disclaimer in the
300  *    documentation and/or other materials provided with the distribution.
301  * 3. Neither the name of the project nor the names of its contributors
302  *    may be used to endorse or promote products derived from this software
303  *    without specific prior written permission.
304  *
305  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
306  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
307  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
308  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
309  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
310  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
311  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
312  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
313  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
314  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
315  * SUCH DAMAGE.
316  */
317
318 #define SHIFT(X, s) (((X) << (s)) | ((X) >> (32 - (s))))
319
320 #define F(X, Y, Z) (((X) & (Y)) | ((~X) & (Z)))
321 #define G(X, Y, Z) (((X) & (Z)) | ((Y) & (~Z)))
322 #define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
323 #define I(X, Y, Z) ((Y) ^ ((X) | (~Z)))
324
325 #define ROUND1(a, b, c, d, k, s, i) { \
326         (a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
327         (a) = SHIFT((a), (s)); \
328         (a) = (b) + (a); \
329 }
330
331 #define ROUND2(a, b, c, d, k, s, i) { \
332         (a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
333         (a) = SHIFT((a), (s)); \
334         (a) = (b) + (a); \
335 }
336
337 #define ROUND3(a, b, c, d, k, s, i) { \
338         (a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
339         (a) = SHIFT((a), (s)); \
340         (a) = (b) + (a); \
341 }
342
343 #define ROUND4(a, b, c, d, k, s, i) { \
344         (a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
345         (a) = SHIFT((a), (s)); \
346         (a) = (b) + (a); \
347 }
348
349 #define Sa       7
350 #define Sb      12
351 #define Sc      17
352 #define Sd      22
353
354 #define Se       5
355 #define Sf       9
356 #define Sg      14
357 #define Sh      20
358
359 #define Si       4
360 #define Sj      11
361 #define Sk      16
362 #define Sl      23
363
364 #define Sm       6
365 #define Sn      10
366 #define So      15
367 #define Sp      21
368
369 #define MD5_A0  0x67452301
370 #define MD5_B0  0xefcdab89
371 #define MD5_C0  0x98badcfe
372 #define MD5_D0  0x10325476
373
374 /* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */
375 static const u_int32_t T[65] = {
376         0,
377         0xd76aa478,     0xe8c7b756,     0x242070db,     0xc1bdceee,
378         0xf57c0faf,     0x4787c62a,     0xa8304613,     0xfd469501,
379         0x698098d8,     0x8b44f7af,     0xffff5bb1,     0x895cd7be,
380         0x6b901122,     0xfd987193,     0xa679438e,     0x49b40821,
381
382         0xf61e2562,     0xc040b340,     0x265e5a51,     0xe9b6c7aa,
383         0xd62f105d,     0x2441453,      0xd8a1e681,     0xe7d3fbc8,
384         0x21e1cde6,     0xc33707d6,     0xf4d50d87,     0x455a14ed,
385         0xa9e3e905,     0xfcefa3f8,     0x676f02d9,     0x8d2a4c8a,
386
387         0xfffa3942,     0x8771f681,     0x6d9d6122,     0xfde5380c,
388         0xa4beea44,     0x4bdecfa9,     0xf6bb4b60,     0xbebfbc70,
389         0x289b7ec6,     0xeaa127fa,     0xd4ef3085,     0x4881d05,
390         0xd9d4d039,     0xe6db99e5,     0x1fa27cf8,     0xc4ac5665,
391
392         0xf4292244,     0x432aff97,     0xab9423a7,     0xfc93a039,
393         0x655b59c3,     0x8f0ccc92,     0xffeff47d,     0x85845dd1,
394         0x6fa87e4f,     0xfe2ce6e0,     0xa3014314,     0x4e0811a1,
395         0xf7537e82,     0xbd3af235,     0x2ad7d2bb,     0xeb86d391,
396 };
397
398 static const u_int8_t md5_paddat[MD5_BUFLEN] = {
399         0x80,   0,      0,      0,      0,      0,      0,      0,
400         0,      0,      0,      0,      0,      0,      0,      0,
401         0,      0,      0,      0,      0,      0,      0,      0,
402         0,      0,      0,      0,      0,      0,      0,      0,
403         0,      0,      0,      0,      0,      0,      0,      0,
404         0,      0,      0,      0,      0,      0,      0,      0,
405         0,      0,      0,      0,      0,      0,      0,      0,
406         0,      0,      0,      0,      0,      0,      0,      0,      
407 };
408
409 static void md5_calc(u_int8_t *, md5_ctxt *);
410
411 static void md5_init(md5_ctxt *ctxt)
412 {
413         ctxt->md5_n = 0;
414         ctxt->md5_i = 0;
415         ctxt->md5_sta = MD5_A0;
416         ctxt->md5_stb = MD5_B0;
417         ctxt->md5_stc = MD5_C0;
418         ctxt->md5_std = MD5_D0;
419         bzero(ctxt->md5_buf, sizeof(ctxt->md5_buf));
420 }
421
422 static void md5_loop(md5_ctxt *ctxt, const u_int8_t *input, u_int len)
423 {
424         u_int gap, i;
425
426         ctxt->md5_n += len * 8; /* byte to bit */
427         gap = MD5_BUFLEN - ctxt->md5_i;
428
429         if (len >= gap) {
430                 bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i),
431                         gap);
432                 md5_calc(ctxt->md5_buf, ctxt);
433
434                 for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
435                         md5_calc((u_int8_t *)(input + i), ctxt);
436                 }
437                 
438                 ctxt->md5_i = len - i;
439                 bcopy((void *)(input + i), (void *)ctxt->md5_buf, ctxt->md5_i);
440         } else {
441                 bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i),
442                         len);
443                 ctxt->md5_i += len;
444         }
445 }
446
447 static void md5_pad(md5_ctxt *ctxt)
448 {
449         u_int gap;
450
451         /* Don't count up padding. Keep md5_n. */       
452         gap = MD5_BUFLEN - ctxt->md5_i;
453         if (gap > 8) {
454                 bcopy(md5_paddat,
455                       (void *)(ctxt->md5_buf + ctxt->md5_i),
456                       gap - sizeof(ctxt->md5_n));
457         } else {
458                 /* including gap == 8 */
459                 bcopy(md5_paddat, (void *)(ctxt->md5_buf + ctxt->md5_i),
460                         gap);
461                 md5_calc(ctxt->md5_buf, ctxt);
462                 bcopy((md5_paddat + gap),
463                       (void *)ctxt->md5_buf,
464                       MD5_BUFLEN - sizeof(ctxt->md5_n));
465         }
466
467         /* 8 byte word */       
468 #if BYTE_ORDER == LITTLE_ENDIAN
469         bcopy(&ctxt->md5_n8[0], &ctxt->md5_buf[56], 8);
470 #endif
471 #if BYTE_ORDER == BIG_ENDIAN
472         ctxt->md5_buf[56] = ctxt->md5_n8[7];
473         ctxt->md5_buf[57] = ctxt->md5_n8[6];
474         ctxt->md5_buf[58] = ctxt->md5_n8[5];
475         ctxt->md5_buf[59] = ctxt->md5_n8[4];
476         ctxt->md5_buf[60] = ctxt->md5_n8[3];
477         ctxt->md5_buf[61] = ctxt->md5_n8[2];
478         ctxt->md5_buf[62] = ctxt->md5_n8[1];
479         ctxt->md5_buf[63] = ctxt->md5_n8[0];
480 #endif
481
482         md5_calc(ctxt->md5_buf, ctxt);
483 }
484
485 static void md5_result(u_int8_t *digest, md5_ctxt *ctxt)
486 {
487         /* 4 byte words */
488 #if BYTE_ORDER == LITTLE_ENDIAN
489         bcopy(&ctxt->md5_st8[0], digest, 16);
490 #endif
491 #if BYTE_ORDER == BIG_ENDIAN
492         digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
493         digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
494         digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
495         digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
496         digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
497         digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
498         digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
499         digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
500 #endif
501 }
502
503 static void md5_calc(u_int8_t *b64, md5_ctxt *ctxt)
504 {
505         u_int32_t A = ctxt->md5_sta;
506         u_int32_t B = ctxt->md5_stb;
507         u_int32_t C = ctxt->md5_stc;
508         u_int32_t D = ctxt->md5_std;
509 #if BYTE_ORDER == LITTLE_ENDIAN
510         u_int32_t *X = (u_int32_t *)b64;
511 #endif  
512 #if BYTE_ORDER == BIG_ENDIAN
513         u_int32_t X[16];
514         /* 4 byte words */
515         /* what a brute force but fast! */
516         u_int8_t *y = (u_int8_t *)X;
517         y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
518         y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
519         y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
520         y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
521         y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
522         y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
523         y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
524         y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
525         y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
526         y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
527         y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
528         y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
529         y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
530         y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
531         y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
532         y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
533 #endif
534
535         ROUND1(A, B, C, D,  0, Sa,  1); ROUND1(D, A, B, C,  1, Sb,  2);
536         ROUND1(C, D, A, B,  2, Sc,  3); ROUND1(B, C, D, A,  3, Sd,  4);
537         ROUND1(A, B, C, D,  4, Sa,  5); ROUND1(D, A, B, C,  5, Sb,  6);
538         ROUND1(C, D, A, B,  6, Sc,  7); ROUND1(B, C, D, A,  7, Sd,  8);
539         ROUND1(A, B, C, D,  8, Sa,  9); ROUND1(D, A, B, C,  9, Sb, 10);
540         ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
541         ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
542         ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
543         
544         ROUND2(A, B, C, D,  1, Se, 17); ROUND2(D, A, B, C,  6, Sf, 18);
545         ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A,  0, Sh, 20);
546         ROUND2(A, B, C, D,  5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
547         ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A,  4, Sh, 24);
548         ROUND2(A, B, C, D,  9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
549         ROUND2(C, D, A, B,  3, Sg, 27); ROUND2(B, C, D, A,  8, Sh, 28);
550         ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C,  2, Sf, 30);
551         ROUND2(C, D, A, B,  7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);
552
553         ROUND3(A, B, C, D,  5, Si, 33); ROUND3(D, A, B, C,  8, Sj, 34);
554         ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
555         ROUND3(A, B, C, D,  1, Si, 37); ROUND3(D, A, B, C,  4, Sj, 38);
556         ROUND3(C, D, A, B,  7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
557         ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C,  0, Sj, 42);
558         ROUND3(C, D, A, B,  3, Sk, 43); ROUND3(B, C, D, A,  6, Sl, 44);
559         ROUND3(A, B, C, D,  9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
560         ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A,  2, Sl, 48);
561         
562         ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50); 
563         ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52); 
564         ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54); 
565         ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56); 
566         ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58); 
567         ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60); 
568         ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62); 
569         ROUND4(C, D, A, B,  2, So, 63); ROUND4(B, C, D, A,  9, Sp, 64);
570
571         ctxt->md5_sta += A;
572         ctxt->md5_stb += B;
573         ctxt->md5_stc += C;
574         ctxt->md5_std += D;
575 }
576