workbench/network/smbfs/source_code/crypt.c

   1 /*
   2  * $Id$
   3  *
   4  * :ts=8
   5  *
   6  * Password encryption routines, lifted from the Samba source code,
   7  * "libsmb/smbencrypt.c", "libsmb/smbdes.c" and "lib/md4.c":
   8  *
   9  * Unix SMB/Netbios implementation.
  10  * Version 1.9.
  11  *
  12  * SMB parameters and setup
  13  *
  14  * A partial implementation of DES designed for use in the
  15  * SMB authentication protocol
  16  *
  17  * An implementation of MD4 designed for use in the SMB authentication protocol
  18  *
  19  * Copyright (C) Andrew Tridgell 1992-1998
  20  * Modified by Jeremy Allison 1995.
  21  *
  22  * This program is free software; you can redistribute it and/or modify
  23  * it under the terms of the GNU General Public License as published by
  24  * the Free Software Foundation; either version 2 of the License, or
  25  * (at your option) any later version.
  26  *
  27  * This program is distributed in the hope that it will be useful,
  28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  * GNU General Public License for more details.
  31  *
  32  * You should have received a copy of the GNU General Public License
  33  * along with this program; if not, write to the Free Software
  34  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  35  */
  36
  37 #include "smbfs.h"
  38
  39 /****************************************************************************/
  40
  41 #include <smb/smb.h>
  42
  43 /****************************************************************************/
  44
  45 static void permute (char *out, char *in, const unsigned char * const p, int n);
  46 static void left_shift (char *d, int count, int n);
  47 static void concat (char *out, char *in1, char *in2, int l1, int l2);
  48 static void xor (char *out, char *in1, char *in2, int n);
  49 static void dohash (char *out, char *in, char *key, int forw);
  50 static void str_to_key (unsigned char *str, unsigned char *key);
  51 static void smbhash (unsigned char *out, unsigned char *in, unsigned char *key, int forw);
  52 static void E_P16 (unsigned char *p14, unsigned char *p16);
  53 static void E_P24 (unsigned char *p21, unsigned char *c8, unsigned char *p24);
  54 static int local_wcslen (short *str);
  55 static int local_mbstowcs (short *dst, unsigned char *src, int len);
  56 static void E_md4hash (unsigned char *passwd, unsigned char *p16);
  57 static void smb_owf_encrypt (unsigned char *passwd, unsigned char *c8, unsigned char *p24);
  58 static unsigned long F (unsigned long X, unsigned long Y, unsigned long Z);
  59 static unsigned long G (unsigned long X, unsigned long Y, unsigned long Z);
  60 static unsigned long H (unsigned long X, unsigned long Y, unsigned long Z);
  61 static unsigned long lshift (unsigned long x, int s);
  62 static void mdfour64 (unsigned long *M);
  63 static void copy64 (unsigned long *M, unsigned char *in);
  64 static void copy4 (unsigned char *out, unsigned long x);
  65 static void mdfour (unsigned char *out, unsigned char *in, int n);
  66
  67 /****************************************************************************/
  68
  69 /* NOTES:
  70
  71    This code makes no attempt to be fast! In fact, it is a very
  72    slow implementation
  73
  74    This code is NOT a complete DES implementation. It implements only
  75    the minimum necessary for SMB authentication, as used by all SMB
  76    products (including every copy of Microsoft Windows95 ever sold)
  77
  78    In particular, it can only do a unchained forward DES pass. This
  79    means it is not possible to use this code for encryption/decryption
  80    of data, instead it is only useful as a "hash" algorithm.
  81
  82    There is no entry point into this code that allows normal DES operation.
  83
  84    I believe this means that this code does not come under ITAR
  85    regulations but this is NOT a legal opinion. If you are concerned
  86    about the applicability of ITAR regulations to this code then you
  87    should confirm it for yourself (and maybe let me know if you come
  88    up with a different answer to the one above) */
  89
  90 static const unsigned char perm1[56] =
  91 {
  92  57, 49, 41, 33, 25, 17, 9,
  93  1, 58, 50, 42, 34, 26, 18,
  94  10, 2, 59, 51, 43, 35, 27,
  95  19, 11, 3, 60, 52, 44, 36,
  96  63, 55, 47, 39, 31, 23, 15,
  97  7, 62, 54, 46, 38, 30, 22,
  98  14, 6, 61, 53, 45, 37, 29,
  99  21, 13, 5, 28, 20, 12, 4
 100 };
 101
 102 static const unsigned char perm2[48] =
 103 {
 104  14, 17, 11, 24, 1, 5,
 105  3, 28, 15, 6, 21, 10,
 106  23, 19, 12, 4, 26, 8,
 107  16, 7, 27, 20, 13, 2,
 108  41, 52, 31, 37, 47, 55,
 109  30, 40, 51, 45, 33, 48,
 110  44, 49, 39, 56, 34, 53,
 111  46, 42, 50, 36, 29, 32
 112 };
 113
 114 static const unsigned char perm3[64] =
 115 {
 116  58, 50, 42, 34, 26, 18, 10, 2,
 117  60, 52, 44, 36, 28, 20, 12, 4,
 118  62, 54, 46, 38, 30, 22, 14, 6,
 119  64, 56, 48, 40, 32, 24, 16, 8,
 120  57, 49, 41, 33, 25, 17, 9, 1,
 121  59, 51, 43, 35, 27, 19, 11, 3,
 122  61, 53, 45, 37, 29, 21, 13, 5,
 123  63, 55, 47, 39, 31, 23, 15, 7
 124 };
 125
 126 static const unsigned char perm4[48] =
 127 {
 128  32, 1, 2, 3, 4, 5,
 129  4, 5, 6, 7, 8, 9,
 130  8, 9, 10, 11, 12, 13,
 131  12, 13, 14, 15, 16, 17,
 132  16, 17, 18, 19, 20, 21,
 133  20, 21, 22, 23, 24, 25,
 134  24, 25, 26, 27, 28, 29,
 135  28, 29, 30, 31, 32, 1
 136 };
 137
 138 static const unsigned char perm5[32] =
 139 {
 140  16, 7, 20, 21,
 141  29, 12, 28, 17,
 142  1, 15, 23, 26,
 143  5, 18, 31, 10,
 144  2, 8, 24, 14,
 145  32, 27, 3, 9,
 146  19, 13, 30, 6,
 147  22, 11, 4, 25
 148 };
 149
 150 static const unsigned char perm6[64] =
 151 {
 152  40, 8, 48, 16, 56, 24, 64, 32,
 153  39, 7, 47, 15, 55, 23, 63, 31,
 154  38, 6, 46, 14, 54, 22, 62, 30,
 155  37, 5, 45, 13, 53, 21, 61, 29,
 156  36, 4, 44, 12, 52, 20, 60, 28,
 157  35, 3, 43, 11, 51, 19, 59, 27,
 158  34, 2, 42, 10, 50, 18, 58, 26,
 159  33, 1, 41, 9, 49, 17, 57, 25
 160 };
 161
 162 static const unsigned char sc[16] =
 163 {
 164  1, 1, 2, 2,
 165  2, 2, 2, 2,
 166  1, 2, 2, 2,
 167  2, 2, 2, 1
 168 };
 169
 170 static const unsigned char sbox[8][4][16] =
 171 {
 172   {
 173     {14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
 174     {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
 175     {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
 176     {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}
 177   },
 178
 179   {
 180     {15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
 181     {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
 182     {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
 183     {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}
 184   },
 185
 186   {
 187     {10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
 188     {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
 189     {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
 190     {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}
 191   },
 192
 193   {
 194     {7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
 195     {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
 196     {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
 197     {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}
 198   },
 199
 200   {
 201     {2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
 202     {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
 203     {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
 204     {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}
 205   },
 206
 207   {
 208     {12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
 209     {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
 210     {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
 211     {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}
 212   },
 213
 214   {
 215     {4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
 216     {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
 217     {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
 218     {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}
 219   },
 220
 221   {
 222     {13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
 223     {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
 224     {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
 225     {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}
 226   }
 227 };
 228
 229 static void
 230 permute (char *out, char *in, const unsigned char * const p, int n)
 231 {
 232   int i;
 233
 234   for (i = 0; i < n; i++)
 235     out[i] = in[p[i] - 1];
 236 }
 237
 238 static void
 239 left_shift (char *d, int count, int n)
 240 {
 241   char out[64];
 242   int i;
 243
 244   for (i = 0; i < n; i++)
 245     out[i] = d[(i + count) % n];
 246
 247   for (i = 0; i < n; i++)
 248     d[i] = out[i];
 249 }
 250
 251 static void
 252 concat (char *out, char *in1, char *in2, int l1, int l2)
 253 {
 254   while (l1--)
 255     (*out++) = (*in1++);
 256
 257   while (l2--)
 258     (*out++) = (*in2++);
 259 }
 260
 261 static void
 262 xor (char *out, char *in1, char *in2, int n)
 263 {
 264   int i;
 265
 266   for (i = 0; i < n; i++)
 267     out[i] = in1[i] ^ in2[i];
 268 }
 269
 270 static void
 271 dohash (char *out, char *in, char *key, int forw)
 272 {
 273   int i, j, k;
 274   char pk1[56];
 275   char c[28];
 276   char d[28];
 277   char cd[56];
 278   char ki[16][48];
 279   char pd1[64];
 280   char l[32], r[32];
 281   char rl[64];
 282
 283   permute (pk1, key, perm1, 56);
 284
 285   for (i = 0; i < 28; i++)
 286     c[i] = pk1[i];
 287
 288   for (i = 0; i < 28; i++)
 289     d[i] = pk1[i + 28];
 290
 291   for (i = 0; i < 16; i++)
 292   {
 293     left_shift (c, sc[i], 28);
 294     left_shift (d, sc[i], 28);
 295
 296     concat (cd, c, d, 28, 28);
 297     permute (ki[i], cd, perm2, 48);
 298   }
 299
 300   permute (pd1, in, perm3, 64);
 301
 302   for (j = 0; j < 32; j++)
 303   {
 304     l[j] = pd1[j];
 305     r[j] = pd1[j + 32];
 306   }
 307
 308   for (i = 0; i < 16; i++)
 309   {
 310     char er[48];
 311     char erk[48];
 312     char b[8][6];
 313     char cb[32];
 314     char pcb[32];
 315     char r2[32];
 316
 317     permute (er, r, perm4, 48);
 318
 319     xor (erk, er, ki[forw ? i : 15 - i], 48);
 320
 321     for (j = 0; j < 8; j++)
 322     {
 323       for (k = 0; k < 6; k++)
 324         b[j][k] = erk[j * 6 + k];
 325     }
 326
 327     for (j = 0; j < 8; j++)
 328     {
 329       int m, n;
 330
 331       m = (b[j][0] << 1) | b[j][5];
 332
 333       n = (b[j][1] << 3) | (b[j][2] << 2) | (b[j][3] << 1) | b[j][4];
 334
 335       for (k = 0; k < 4; k++)
 336         b[j][k] = (sbox[j][m][n] & (1 << (3 - k))) ? 1 : 0;
 337     }
 338
 339     for (j = 0; j < 8; j++)
 340     {
 341       for (k = 0; k < 4; k++)
 342         cb[j * 4 + k] = b[j][k];
 343     }
 344
 345     permute (pcb, cb, perm5, 32);
 346
 347     xor (r2, l, pcb, 32);
 348
 349     for (j = 0; j < 32; j++)
 350       l[j] = r[j];
 351
 352     for (j = 0; j < 32; j++)
 353       r[j] = r2[j];
 354   }
 355
 356   concat (rl, r, l, 32, 32);
 357
 358   permute (out, rl, perm6, 64);
 359 }
 360
 361 static void
 362 str_to_key (unsigned char *str, unsigned char *key)
 363 {
 364   int i;
 365
 366   key[0] = str[0] >> 1;
 367   key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2);
 368   key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3);
 369   key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4);
 370   key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5);
 371   key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
 372   key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
 373   key[7] = str[6] & 0x7F;
 374
 375   for (i = 0; i < 8; i++)
 376     key[i] = (key[i] << 1);
 377 }
 378
 379 static void
 380 smbhash (unsigned char *out, unsigned char *in, unsigned char *key, int forw)
 381 {
 382   int i;
 383   char outb[64];
 384   char inb[64];
 385   char keyb[64];
 386   unsigned char key2[8];
 387
 388   str_to_key (key, key2);
 389
 390   for (i = 0; i < 64; i++)
 391   {
 392     inb[i] = (in[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
 393     keyb[i] = (key2[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
 394     outb[i] = 0;
 395   }
 396
 397   dohash (outb, inb, keyb, forw);
 398
 399   for (i = 0; i < 8; i++)
 400     out[i] = 0;
 401
 402   for (i = 0; i < 64; i++)
 403   {
 404     if (outb[i])
 405       out[i / 8] |= (1 << (7 - (i % 8)));
 406   }
 407 }
 408
 409 static void
 410 E_P16 (unsigned char *p14, unsigned char *p16)
 411 {
 412   unsigned char sp8[8] =
 413   {
 414    0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25
 415   };
 416
 417   smbhash (p16, sp8, p14, 1);
 418   smbhash (p16 + 8, sp8, p14 + 7, 1);
 419 }
 420
 421 static void
 422 E_P24 (unsigned char *p21, unsigned char *c8, unsigned char *p24)
 423 {
 424   smbhash (p24, c8, p21, 1);
 425   smbhash (p24 + 8, c8, p21 + 7, 1);
 426   smbhash (p24 + 16, c8, p21 + 14, 1);
 427 }
 428
 429 /****************************************************************************/
 430
 431 /* This implements the X/Open SMB password encryption
 432    It takes a password, a 8 byte "crypt key" and puts 24 bytes of
 433    encrypted password into p24 */
 434 void
 435 smb_encrypt (unsigned char *passwd, unsigned char *c8, unsigned char *p24)
 436 {
 437   unsigned char p14[15], p21[21];
 438   int len;
 439
 440   memset (p21, '\0', sizeof(p21));
 441   memset (p14, '\0', sizeof(p14));
 442
 443   len = strlen((const char *)passwd);
 444   if(len > (int)sizeof(p14)-1)
 445     len = sizeof(p14)-1;
 446
 447   memcpy (p14, passwd, len);
 448
 449   StringToUpper ((char *) p14);
 450   E_P16 (p14, p21);
 451
 452   smb_owf_encrypt (p21, c8, p24);
 453 }
 454
 455 /****************************************************************************/
 456
 457 /* Routines for Windows NT MD4 Hash functions. */
 458 static int
 459 local_wcslen (short *str)
 460 {
 461   int len = 0;
 462
 463   while ((*str++) != 0)
 464     len++;
 465
 466   return len;
 467 }
 468
 469 /* Convert a string into an NT UNICODE string.
 470    Note that regardless of processor type
 471    this must be in intel (little-endian)
 472    format. */
 473 static int
 474 local_mbstowcs (short *dst, unsigned char *src, int len)
 475 {
 476   int i;
 477   short val;
 478
 479   for (i = 0; i < len; i++)
 480   {
 481     val = (*src++);
 482     WSET(dst,0,val);
 483     dst++;
 484
 485     if (val == 0)
 486       break;
 487   }
 488
 489   return i;
 490 }
 491
 492 /* Creates the MD4 Hash of the users password in NT UNICODE. */
 493 static void
 494 E_md4hash (unsigned char *passwd, unsigned char *p16)
 495 {
 496   short wpwd[129];
 497   int len;
 498
 499   /* Password cannot be longer than 128 characters */
 500   len = strlen ((char *) passwd);
 501   if (len > 128)
 502     len = 128;
 503
 504   /* Password must be converted to NT unicode */
 505   local_mbstowcs (wpwd, passwd, len);
 506   wpwd[len] = 0; /* Ensure string is null terminated */
 507
 508   /* Calculate length in bytes */
 509   len = local_wcslen (wpwd) * sizeof (short);
 510
 511   mdfour (p16, (unsigned char *) wpwd, len);
 512 }
 513
 514 /* Does the des encryption from the NT or LM MD4 hash. */
 515 static void
 516 smb_owf_encrypt (unsigned char *passwd, unsigned char *c8, unsigned char *p24)
 517 {
 518   unsigned char p21[21];
 519
 520   memset (p21, '\0', sizeof(p21));
 521
 522   memcpy (p21, passwd, 16);
 523   E_P24 (p21, c8, p24);
 524 }
 525
 526 /****************************************************************************/
 527
 528 /* Does the NT MD4 hash then des encryption. */
 529 void
 530 smb_nt_encrypt (unsigned char *passwd, unsigned char *c8, unsigned char *p24)
 531 {
 532   unsigned char p21[21];
 533
 534   memset (p21, '\0', sizeof(p21));
 535
 536   E_md4hash (passwd, p21);
 537   smb_owf_encrypt (p21, c8, p24);
 538 }
 539
 540 /****************************************************************************/
 541
 542 static unsigned long A, B, C, D;
 543
 544 static unsigned long
 545 F(unsigned long X, unsigned long Y, unsigned long Z)
 546 {
 547   return (X & Y) | ((~X) & Z);
 548 }
 549
 550 static unsigned long
 551 G(unsigned long X, unsigned long Y, unsigned long Z)
 552 {
 553   return (X & Y) | (X & Z) | (Y & Z);
 554 }
 555
 556 static unsigned long
 557 H(unsigned long X, unsigned long Y, unsigned long Z)
 558 {
 559   return X ^ Y ^ Z;
 560 }
 561
 562 static unsigned long
 563 lshift (unsigned long x, int s)
 564 {
 565   return (x << s) | (x >> (32 - s));
 566 }
 567
 568 #define ROUND1(a,b,c,d,k,s) a = lshift(a + F(b,c,d) + X[k], s)
 569 #define ROUND2(a,b,c,d,k,s) a = lshift(a + G(b,c,d) + X[k] + 0x5A827999UL,s)
 570 #define ROUND3(a,b,c,d,k,s) a = lshift(a + H(b,c,d) + X[k] + 0x6ED9EBA1UL,s)
 571
 572 /* this applies md4 to 64 byte chunks */
 573 static void
 574 mdfour64 (unsigned long *M)
 575 {
 576   unsigned long AA, BB, CC, DD;
 577   unsigned long X[16];
 578
 579   memcpy(X,M,sizeof(X));
 580
 581   AA = A;
 582   BB = B;
 583   CC = C;
 584   DD = D;
 585
 586   ROUND1 (A, B, C, D, 0, 3);
 587   ROUND1 (D, A, B, C, 1, 7);
 588   ROUND1 (C, D, A, B, 2, 11);
 589   ROUND1 (B, C, D, A, 3, 19);
 590   ROUND1 (A, B, C, D, 4, 3);
 591   ROUND1 (D, A, B, C, 5, 7);
 592   ROUND1 (C, D, A, B, 6, 11);
 593   ROUND1 (B, C, D, A, 7, 19);
 594   ROUND1 (A, B, C, D, 8, 3);
 595   ROUND1 (D, A, B, C, 9, 7);
 596   ROUND1 (C, D, A, B, 10, 11);
 597   ROUND1 (B, C, D, A, 11, 19);
 598   ROUND1 (A, B, C, D, 12, 3);
 599   ROUND1 (D, A, B, C, 13, 7);
 600   ROUND1 (C, D, A, B, 14, 11);
 601   ROUND1 (B, C, D, A, 15, 19);
 602
 603   ROUND2 (A, B, C, D, 0, 3);
 604   ROUND2 (D, A, B, C, 4, 5);
 605   ROUND2 (C, D, A, B, 8, 9);
 606   ROUND2 (B, C, D, A, 12, 13);
 607   ROUND2 (A, B, C, D, 1, 3);
 608   ROUND2 (D, A, B, C, 5, 5);
 609   ROUND2 (C, D, A, B, 9, 9);
 610   ROUND2 (B, C, D, A, 13, 13);
 611   ROUND2 (A, B, C, D, 2, 3);
 612   ROUND2 (D, A, B, C, 6, 5);
 613   ROUND2 (C, D, A, B, 10, 9);
 614   ROUND2 (B, C, D, A, 14, 13);
 615   ROUND2 (A, B, C, D, 3, 3);
 616   ROUND2 (D, A, B, C, 7, 5);
 617   ROUND2 (C, D, A, B, 11, 9);
 618   ROUND2 (B, C, D, A, 15, 13);
 619
 620   ROUND3 (A, B, C, D, 0, 3);
 621   ROUND3 (D, A, B, C, 8, 9);
 622   ROUND3 (C, D, A, B, 4, 11);
 623   ROUND3 (B, C, D, A, 12, 15);
 624   ROUND3 (A, B, C, D, 2, 3);
 625   ROUND3 (D, A, B, C, 10, 9);
 626   ROUND3 (C, D, A, B, 6, 11);
 627   ROUND3 (B, C, D, A, 14, 15);
 628   ROUND3 (A, B, C, D, 1, 3);
 629   ROUND3 (D, A, B, C, 9, 9);
 630   ROUND3 (C, D, A, B, 5, 11);
 631   ROUND3 (B, C, D, A, 13, 15);
 632   ROUND3 (A, B, C, D, 3, 3);
 633   ROUND3 (D, A, B, C, 11, 9);
 634   ROUND3 (C, D, A, B, 7, 11);
 635   ROUND3 (B, C, D, A, 15, 15);
 636
 637   A += AA;
 638   B += BB;
 639   C += CC;
 640   D += DD;
 641 }
 642
 643 static void
 644 copy64 (unsigned long *M, unsigned char *in)
 645 {
 646   int i;
 647
 648   for (i = 0; i < 16; i++)
 649   {
 650     M[i] = (in[i * 4 + 3] << 24) | (in[i * 4 + 2] << 16) |
 651       (in[i * 4 + 1] << 8) | (in[i * 4 + 0] << 0);
 652   }
 653 }
 654
 655 static void
 656 copy4 (unsigned char *out, unsigned long x)
 657 {
 658   out[0] = x & 0xFF;
 659   out[1] = (x >> 8) & 0xFF;
 660   out[2] = (x >> 16) & 0xFF;
 661   out[3] = (x >> 24) & 0xFF;
 662 }
 663
 664 /* produce a md4 message digest from data of length n bytes */
 665 static void
 666 mdfour (unsigned char *out, unsigned char *in, int n)
 667 {
 668   unsigned char buf[128];
 669   unsigned long M[16];
 670   unsigned long b = n * 8;
 671
 672   A = 0x67452301;
 673   B = 0xefcdab89;
 674   C = 0x98badcfe;
 675   D = 0x10325476;
 676
 677   while (n > 64)
 678   {
 679     copy64 (M, in);
 680     mdfour64 (M);
 681
 682     in += 64;
 683     n -= 64;
 684   }
 685
 686   memset (buf, 0, sizeof(buf));
 687   memcpy (buf, in, n);
 688   buf[n] = 0x80;
 689
 690   if (n <= 55)
 691   {
 692     copy4 (buf + 56, b);
 693     copy64 (M, buf);
 694     mdfour64 (M);
 695   }
 696   else
 697   {
 698     copy4 (buf + 120, b);
 699     copy64 (M, buf);
 700     mdfour64 (M);
 701     copy64 (M, buf + 64);
 702     mdfour64 (M);
 703   }
 704
 705   memset (buf, 0, sizeof(buf));
 706   copy64 (M, buf);
 707
 708   copy4 (out, A);
 709   copy4 (out + 4, B);
 710   copy4 (out + 8, C);
 711   copy4 (out + 12, D);
 712 }