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