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