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