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(ctxt)
 412         md5_ctxt *ctxt;
 413 {
 414         ctxt->md5_n = 0;
 415         ctxt->md5_i = 0;
 416         ctxt->md5_sta = MD5_A0;
 417         ctxt->md5_stb = MD5_B0;
 418         ctxt->md5_stc = MD5_C0;
 419         ctxt->md5_std = MD5_D0;
 420         bzero(ctxt->md5_buf, sizeof(ctxt->md5_buf));
 421 }
 422
 423 static void md5_loop(ctxt, input, len)
 424         md5_ctxt *ctxt;
 425         const u_int8_t *input;
 426         u_int len; /* number of bytes */
 427 {
 428         u_int gap, i;
 429
 430         ctxt->md5_n += len * 8; /* byte to bit */
 431         gap = MD5_BUFLEN - ctxt->md5_i;
 432
 433         if (len >= gap) {
 434                 bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i),
 435                         gap);
 436                 md5_calc(ctxt->md5_buf, ctxt);
 437
 438                 for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
 439                         md5_calc((u_int8_t *)(input + i), ctxt);
 440                 }
 441
 442                 ctxt->md5_i = len - i;
 443                 bcopy((void *)(input + i), (void *)ctxt->md5_buf, ctxt->md5_i);
 444         } else {
 445                 bcopy((void *)input, (void *)(ctxt->md5_buf + ctxt->md5_i),
 446                         len);
 447                 ctxt->md5_i += len;
 448         }
 449 }
 450
 451 static void md5_pad(ctxt)
 452         md5_ctxt *ctxt;
 453 {
 454         u_int gap;
 455
 456         /* Don't count up padding. Keep md5_n. */
 457         gap = MD5_BUFLEN - ctxt->md5_i;
 458         if (gap > 8) {
 459                 bcopy(md5_paddat,
 460                       (void *)(ctxt->md5_buf + ctxt->md5_i),
 461                       gap - sizeof(ctxt->md5_n));
 462         } else {
 463                 /* including gap == 8 */
 464                 bcopy(md5_paddat, (void *)(ctxt->md5_buf + ctxt->md5_i),
 465                         gap);
 466                 md5_calc(ctxt->md5_buf, ctxt);
 467                 bcopy((md5_paddat + gap),
 468                       (void *)ctxt->md5_buf,
 469                       MD5_BUFLEN - sizeof(ctxt->md5_n));
 470         }
 471
 472         /* 8 byte word */
 473 #if BYTE_ORDER == LITTLE_ENDIAN
 474         bcopy(&ctxt->md5_n8[0], &ctxt->md5_buf[56], 8);
 475 #endif
 476 #if BYTE_ORDER == BIG_ENDIAN
 477         ctxt->md5_buf[56] = ctxt->md5_n8[7];
 478         ctxt->md5_buf[57] = ctxt->md5_n8[6];
 479         ctxt->md5_buf[58] = ctxt->md5_n8[5];
 480         ctxt->md5_buf[59] = ctxt->md5_n8[4];
 481         ctxt->md5_buf[60] = ctxt->md5_n8[3];
 482         ctxt->md5_buf[61] = ctxt->md5_n8[2];
 483         ctxt->md5_buf[62] = ctxt->md5_n8[1];
 484         ctxt->md5_buf[63] = ctxt->md5_n8[0];
 485 #endif
 486
 487         md5_calc(ctxt->md5_buf, ctxt);
 488 }
 489
 490 static void md5_result(digest, ctxt)
 491         u_int8_t *digest;
 492         md5_ctxt *ctxt;
 493 {
 494         /* 4 byte words */
 495 #if BYTE_ORDER == LITTLE_ENDIAN
 496         bcopy(&ctxt->md5_st8[0], digest, 16);
 497 #endif
 498 #if BYTE_ORDER == BIG_ENDIAN
 499         digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
 500         digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
 501         digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
 502         digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
 503         digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
 504         digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
 505         digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
 506         digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
 507 #endif
 508 }
 509
 510 static void md5_calc(b64, ctxt)
 511         u_int8_t *b64;
 512         md5_ctxt *ctxt;
 513 {
 514         u_int32_t A = ctxt->md5_sta;
 515         u_int32_t B = ctxt->md5_stb;
 516         u_int32_t C = ctxt->md5_stc;
 517         u_int32_t D = ctxt->md5_std;
 518 #if BYTE_ORDER == LITTLE_ENDIAN
 519         u_int32_t *X = (u_int32_t *)b64;
 520 #endif
 521 #if BYTE_ORDER == BIG_ENDIAN
 522         u_int32_t X[16];
 523         /* 4 byte words */
 524         /* what a brute force but fast! */
 525         u_int8_t *y = (u_int8_t *)X;
 526         y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
 527         y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
 528         y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
 529         y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
 530         y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
 531         y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
 532         y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
 533         y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
 534         y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
 535         y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
 536         y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
 537         y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
 538         y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
 539         y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
 540         y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
 541         y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
 542 #endif
 543
 544         ROUND1(A, B, C, D,  0, Sa,  1); ROUND1(D, A, B, C,  1, Sb,  2);
 545         ROUND1(C, D, A, B,  2, Sc,  3); ROUND1(B, C, D, A,  3, Sd,  4);
 546         ROUND1(A, B, C, D,  4, Sa,  5); ROUND1(D, A, B, C,  5, Sb,  6);
 547         ROUND1(C, D, A, B,  6, Sc,  7); ROUND1(B, C, D, A,  7, Sd,  8);
 548         ROUND1(A, B, C, D,  8, Sa,  9); ROUND1(D, A, B, C,  9, Sb, 10);
 549         ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
 550         ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
 551         ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
 552
 553         ROUND2(A, B, C, D,  1, Se, 17); ROUND2(D, A, B, C,  6, Sf, 18);
 554         ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A,  0, Sh, 20);
 555         ROUND2(A, B, C, D,  5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
 556         ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A,  4, Sh, 24);
 557         ROUND2(A, B, C, D,  9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
 558         ROUND2(C, D, A, B,  3, Sg, 27); ROUND2(B, C, D, A,  8, Sh, 28);
 559         ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C,  2, Sf, 30);
 560         ROUND2(C, D, A, B,  7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);
 561
 562         ROUND3(A, B, C, D,  5, Si, 33); ROUND3(D, A, B, C,  8, Sj, 34);
 563         ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
 564         ROUND3(A, B, C, D,  1, Si, 37); ROUND3(D, A, B, C,  4, Sj, 38);
 565         ROUND3(C, D, A, B,  7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
 566         ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C,  0, Sj, 42);
 567         ROUND3(C, D, A, B,  3, Sk, 43); ROUND3(B, C, D, A,  6, Sl, 44);
 568         ROUND3(A, B, C, D,  9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
 569         ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A,  2, Sl, 48);
 570
 571         ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50);
 572         ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52);
 573         ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54);
 574         ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56);
 575         ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58);
 576         ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60);
 577         ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62);
 578         ROUND4(C, D, A, B,  2, So, 63); ROUND4(B, C, D, A,  9, Sp, 64);
 579
 580         ctxt->md5_sta += A;
 581         ctxt->md5_stb += B;
 582         ctxt->md5_stc += C;
 583         ctxt->md5_std += D;
 584 }
 585