secure/lib/libcrypt/crypt-des.c

   1 /*
   2  * FreeSec: libcrypt for NetBSD
   3  *
   4  * Copyright (c) 1994 David Burren
   5  * All rights reserved.
   6  *
   7  * Adapted for FreeBSD-2.0 by Geoffrey M. Rehmet
   8  *      this file should now *only* export crypt(), in order to make
   9  *      binaries of libcrypt exportable from the USA
  10  *
  11  * Adapted for FreeBSD-4.0 by Mark R V Murray
  12  *      this file should now *only* export crypt_des(), in order to make
  13  *      a module that can be optionally included in libcrypt.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  * 3. Neither the name of the author nor the names of other contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  * $FreeBSD: src/secure/lib/libcrypt/crypt-des.c,v 1.12 1999/09/20 12:39:20 markm Exp $
  40  * $DragonFly: src/secure/lib/libcrypt/crypt-des.c,v 1.4 2005/02/28 16:18:22 joerg Exp $
  41  *
  42  * This is an original implementation of the DES and the crypt(3) interfaces
  43  * by David Burren <davidb@werj.com.au>.
  44  *
  45  * An excellent reference on the underlying algorithm (and related
  46  * algorithms) is:
  47  *
  48  *      B. Schneier, Applied Cryptography: protocols, algorithms,
  49  *      and source code in C, John Wiley & Sons, 1994.
  50  *
  51  * Note that in that book's description of DES the lookups for the initial,
  52  * pbox, and final permutations are inverted (this has been brought to the
  53  * attention of the author).  A list of errata for this book has been
  54  * posted to the sci.crypt newsgroup by the author and is available for FTP.
  55  *
  56  * ARCHITECTURE ASSUMPTIONS:
  57  *      It is assumed that the 8-byte arrays passed by reference can be
  58  *      addressed as arrays of u_int32_t's (ie. the CPU is not picky about
  59  *      alignment).
  60  */
  61 #include <sys/types.h>
  62 #include <sys/param.h>
  63 #include <pwd.h>
  64 #include <string.h>
  65 #include "crypt.h"
  66
  67 /* We can't always assume gcc */
  68 #ifdef __GNUC__
  69 #define INLINE inline
  70 #endif
  71
  72
  73 static u_char   IP[64] = {
  74         58, 50, 42, 34, 26, 18, 10,  2, 60, 52, 44, 36, 28, 20, 12,  4,
  75         62, 54, 46, 38, 30, 22, 14,  6, 64, 56, 48, 40, 32, 24, 16,  8,
  76         57, 49, 41, 33, 25, 17,  9,  1, 59, 51, 43, 35, 27, 19, 11,  3,
  77         61, 53, 45, 37, 29, 21, 13,  5, 63, 55, 47, 39, 31, 23, 15,  7
  78 };
  79
  80 static u_char   inv_key_perm[64];
  81 static u_char   u_key_perm[56];
  82 static u_char   key_perm[56] = {
  83         57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
  84         10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
  85         63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
  86         14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
  87 };
  88
  89 static u_char   key_shifts[16] = {
  90         1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
  91 };
  92
  93 static u_char   inv_comp_perm[56];
  94 static u_char   comp_perm[48] = {
  95         14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
  96         23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
  97         41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
  98         44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
  99 };
 100
 101 /*
 102  *      No E box is used, as it's replaced by some ANDs, shifts, and ORs.
 103  */
 104
 105 static u_char   u_sbox[8][64];
 106 static u_char   sbox[8][64] = {
 107         {
 108                 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
 109                  0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
 110                  4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
 111                 15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13
 112         },
 113         {
 114                 15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
 115                  3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
 116                  0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
 117                 13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9
 118         },
 119         {
 120                 10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
 121                 13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
 122                 13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
 123                  1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12
 124         },
 125         {
 126                  7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
 127                 13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
 128                 10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
 129                  3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14
 130         },
 131         {
 132                  2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
 133                 14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
 134                  4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
 135                 11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3
 136         },
 137         {
 138                 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
 139                 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
 140                  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
 141                  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13
 142         },
 143         {
 144                  4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
 145                 13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
 146                  1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
 147                  6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12
 148         },
 149         {
 150                 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
 151                  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
 152                  7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
 153                  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
 154         }
 155 };
 156
 157 static u_char   un_pbox[32];
 158 static u_char   pbox[32] = {
 159         16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
 160          2,  8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
 161 };
 162
 163 static u_int32_t        bits32[32] =
 164 {
 165         0x80000000, 0x40000000, 0x20000000, 0x10000000,
 166         0x08000000, 0x04000000, 0x02000000, 0x01000000,
 167         0x00800000, 0x00400000, 0x00200000, 0x00100000,
 168         0x00080000, 0x00040000, 0x00020000, 0x00010000,
 169         0x00008000, 0x00004000, 0x00002000, 0x00001000,
 170         0x00000800, 0x00000400, 0x00000200, 0x00000100,
 171         0x00000080, 0x00000040, 0x00000020, 0x00000010,
 172         0x00000008, 0x00000004, 0x00000002, 0x00000001
 173 };
 174
 175 static u_char   bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
 176
 177 static u_int32_t        saltbits;
 178 static long             old_salt;
 179 static u_int32_t        *bits28, *bits24;
 180 static u_char           init_perm[64], final_perm[64];
 181 static u_int32_t        en_keysl[16], en_keysr[16];
 182 static u_int32_t        de_keysl[16], de_keysr[16];
 183 static int              des_initialised = 0;
 184 static u_char           m_sbox[4][4096];
 185 static u_int32_t        psbox[4][256];
 186 static u_int32_t        ip_maskl[8][256], ip_maskr[8][256];
 187 static u_int32_t        fp_maskl[8][256], fp_maskr[8][256];
 188 static u_int32_t        key_perm_maskl[8][128], key_perm_maskr[8][128];
 189 static u_int32_t        comp_maskl[8][128], comp_maskr[8][128];
 190 static u_int32_t        old_rawkey0, old_rawkey1;
 191
 192 static u_char   ascii64[] =
 193          "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 194 /*        0000000000111111111122222222223333333333444444444455555555556666 */
 195 /*        0123456789012345678901234567890123456789012345678901234567890123 */
 196
 197 static INLINE int
 198 ascii_to_bin(char ch)
 199 {
 200         if (ch > 'z')
 201                 return(0);
 202         if (ch >= 'a')
 203                 return(ch - 'a' + 38);
 204         if (ch > 'Z')
 205                 return(0);
 206         if (ch >= 'A')
 207                 return(ch - 'A' + 12);
 208         if (ch > '9')
 209                 return(0);
 210         if (ch >= '.')
 211                 return(ch - '.');
 212         return(0);
 213 }
 214
 215 static void
 216 des_init()
 217 {
 218         int     i, j, b, k, inbit, obit;
 219         u_int32_t       *p, *il, *ir, *fl, *fr;
 220
 221         old_rawkey0 = old_rawkey1 = 0L;
 222         saltbits = 0L;
 223         old_salt = 0L;
 224         bits24 = (bits28 = bits32 + 4) + 4;
 225
 226         /*
 227          * Invert the S-boxes, reordering the input bits.
 228          */
 229         for (i = 0; i < 8; i++)
 230                 for (j = 0; j < 64; j++) {
 231                         b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
 232                         u_sbox[i][j] = sbox[i][b];
 233                 }
 234
 235         /*
 236          * Convert the inverted S-boxes into 4 arrays of 8 bits.
 237          * Each will handle 12 bits of the S-box input.
 238          */
 239         for (b = 0; b < 4; b++)
 240                 for (i = 0; i < 64; i++)
 241                         for (j = 0; j < 64; j++)
 242                                 m_sbox[b][(i << 6) | j] =
 243                                         (u_sbox[(b << 1)][i] << 4) |
 244                                         u_sbox[(b << 1) + 1][j];
 245
 246         /*
 247          * Set up the initial & final permutations into a useful form, and
 248          * initialise the inverted key permutation.
 249          */
 250         for (i = 0; i < 64; i++) {
 251                 init_perm[final_perm[i] = IP[i] - 1] = i;
 252                 inv_key_perm[i] = 255;
 253         }
 254
 255         /*
 256          * Invert the key permutation and initialise the inverted key
 257          * compression permutation.
 258          */
 259         for (i = 0; i < 56; i++) {
 260                 u_key_perm[i] = key_perm[i] - 1;
 261                 inv_key_perm[key_perm[i] - 1] = i;
 262                 inv_comp_perm[i] = 255;
 263         }
 264
 265         /*
 266          * Invert the key compression permutation.
 267          */
 268         for (i = 0; i < 48; i++) {
 269                 inv_comp_perm[comp_perm[i] - 1] = i;
 270         }
 271
 272         /*
 273          * Set up the OR-mask arrays for the initial and final permutations,
 274          * and for the key initial and compression permutations.
 275          */
 276         for (k = 0; k < 8; k++) {
 277                 for (i = 0; i < 256; i++) {
 278                         *(il = &ip_maskl[k][i]) = 0L;
 279                         *(ir = &ip_maskr[k][i]) = 0L;
 280                         *(fl = &fp_maskl[k][i]) = 0L;
 281                         *(fr = &fp_maskr[k][i]) = 0L;
 282                         for (j = 0; j < 8; j++) {
 283                                 inbit = 8 * k + j;
 284                                 if (i & bits8[j]) {
 285                                         if ((obit = init_perm[inbit]) < 32)
 286                                                 *il |= bits32[obit];
 287                                         else
 288                                                 *ir |= bits32[obit-32];
 289                                         if ((obit = final_perm[inbit]) < 32)
 290                                                 *fl |= bits32[obit];
 291                                         else
 292                                                 *fr |= bits32[obit - 32];
 293                                 }
 294                         }
 295                 }
 296                 for (i = 0; i < 128; i++) {
 297                         *(il = &key_perm_maskl[k][i]) = 0L;
 298                         *(ir = &key_perm_maskr[k][i]) = 0L;
 299                         for (j = 0; j < 7; j++) {
 300                                 inbit = 8 * k + j;
 301                                 if (i & bits8[j + 1]) {
 302                                         if ((obit = inv_key_perm[inbit]) == 255)
 303                                                 continue;
 304                                         if (obit < 28)
 305                                                 *il |= bits28[obit];
 306                                         else
 307                                                 *ir |= bits28[obit - 28];
 308                                 }
 309                         }
 310                         *(il = &comp_maskl[k][i]) = 0L;
 311                         *(ir = &comp_maskr[k][i]) = 0L;
 312                         for (j = 0; j < 7; j++) {
 313                                 inbit = 7 * k + j;
 314                                 if (i & bits8[j + 1]) {
 315                                         if ((obit=inv_comp_perm[inbit]) == 255)
 316                                                 continue;
 317                                         if (obit < 24)
 318                                                 *il |= bits24[obit];
 319                                         else
 320                                                 *ir |= bits24[obit - 24];
 321                                 }
 322                         }
 323                 }
 324         }
 325
 326         /*
 327          * Invert the P-box permutation, and convert into OR-masks for
 328          * handling the output of the S-box arrays setup above.
 329          */
 330         for (i = 0; i < 32; i++)
 331                 un_pbox[pbox[i] - 1] = i;
 332
 333         for (b = 0; b < 4; b++)
 334                 for (i = 0; i < 256; i++) {
 335                         *(p = &psbox[b][i]) = 0L;
 336                         for (j = 0; j < 8; j++) {
 337                                 if (i & bits8[j])
 338                                         *p |= bits32[un_pbox[8 * b + j]];
 339                         }
 340                 }
 341
 342         des_initialised = 1;
 343 }
 344
 345 static void
 346 setup_salt(long salt)
 347 {
 348         u_int32_t       obit, saltbit;
 349         int             i;
 350
 351         if (salt == old_salt)
 352                 return;
 353         old_salt = salt;
 354
 355         saltbits = 0L;
 356         saltbit = 1;
 357         obit = 0x800000;
 358         for (i = 0; i < 24; i++) {
 359                 if (salt & saltbit)
 360                         saltbits |= obit;
 361                 saltbit <<= 1;
 362                 obit >>= 1;
 363         }
 364 }
 365
 366 static int
 367 des_setkey(const char *key)
 368 {
 369         u_int32_t       k0, k1, rawkey0, rawkey1;
 370         int             shifts, round;
 371
 372         if (!des_initialised)
 373                 des_init();
 374
 375         rawkey0 = ntohl(*(u_int32_t *) key);
 376         rawkey1 = ntohl(*(u_int32_t *) (key + 4));
 377
 378         if ((rawkey0 | rawkey1)
 379             && rawkey0 == old_rawkey0
 380             && rawkey1 == old_rawkey1) {
 381                 /*
 382                  * Already setup for this key.
 383                  * This optimisation fails on a zero key (which is weak and
 384                  * has bad parity anyway) in order to simplify the starting
 385                  * conditions.
 386                  */
 387                 return(0);
 388         }
 389         old_rawkey0 = rawkey0;
 390         old_rawkey1 = rawkey1;
 391
 392         /*
 393          *      Do key permutation and split into two 28-bit subkeys.
 394          */
 395         k0 = key_perm_maskl[0][rawkey0 >> 25]
 396            | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
 397            | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
 398            | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
 399            | key_perm_maskl[4][rawkey1 >> 25]
 400            | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
 401            | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
 402            | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
 403         k1 = key_perm_maskr[0][rawkey0 >> 25]
 404            | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
 405            | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
 406            | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
 407            | key_perm_maskr[4][rawkey1 >> 25]
 408            | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
 409            | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
 410            | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
 411         /*
 412          *      Rotate subkeys and do compression permutation.
 413          */
 414         shifts = 0;
 415         for (round = 0; round < 16; round++) {
 416                 u_int32_t       t0, t1;
 417
 418                 shifts += key_shifts[round];
 419
 420                 t0 = (k0 << shifts) | (k0 >> (28 - shifts));
 421                 t1 = (k1 << shifts) | (k1 >> (28 - shifts));
 422
 423                 de_keysl[15 - round] =
 424                 en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
 425                                 | comp_maskl[1][(t0 >> 14) & 0x7f]
 426                                 | comp_maskl[2][(t0 >> 7) & 0x7f]
 427                                 | comp_maskl[3][t0 & 0x7f]
 428                                 | comp_maskl[4][(t1 >> 21) & 0x7f]
 429                                 | comp_maskl[5][(t1 >> 14) & 0x7f]
 430                                 | comp_maskl[6][(t1 >> 7) & 0x7f]
 431                                 | comp_maskl[7][t1 & 0x7f];
 432
 433                 de_keysr[15 - round] =
 434                 en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
 435                                 | comp_maskr[1][(t0 >> 14) & 0x7f]
 436                                 | comp_maskr[2][(t0 >> 7) & 0x7f]
 437                                 | comp_maskr[3][t0 & 0x7f]
 438                                 | comp_maskr[4][(t1 >> 21) & 0x7f]
 439                                 | comp_maskr[5][(t1 >> 14) & 0x7f]
 440                                 | comp_maskr[6][(t1 >> 7) & 0x7f]
 441                                 | comp_maskr[7][t1 & 0x7f];
 442         }
 443         return(0);
 444 }
 445
 446 static int
 447 do_des( u_int32_t l_in, u_int32_t r_in, u_int32_t *l_out, u_int32_t *r_out, int count)
 448 {
 449         /*
 450          *      l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
 451          */
 452         u_int32_t       l, r, *kl, *kr, *kl1, *kr1;
 453         u_int32_t       f, r48l, r48r;
 454         int             round;
 455
 456         if (count == 0) {
 457                 return(1);
 458         } else if (count > 0) {
 459                 /*
 460                  * Encrypting
 461                  */
 462                 kl1 = en_keysl;
 463                 kr1 = en_keysr;
 464         } else {
 465                 /*
 466                  * Decrypting
 467                  */
 468                 count = -count;
 469                 kl1 = de_keysl;
 470                 kr1 = de_keysr;
 471         }
 472
 473         /*
 474          *      Do initial permutation (IP).
 475          */
 476         l = ip_maskl[0][l_in >> 24]
 477           | ip_maskl[1][(l_in >> 16) & 0xff]
 478           | ip_maskl[2][(l_in >> 8) & 0xff]
 479           | ip_maskl[3][l_in & 0xff]
 480           | ip_maskl[4][r_in >> 24]
 481           | ip_maskl[5][(r_in >> 16) & 0xff]
 482           | ip_maskl[6][(r_in >> 8) & 0xff]
 483           | ip_maskl[7][r_in & 0xff];
 484         r = ip_maskr[0][l_in >> 24]
 485           | ip_maskr[1][(l_in >> 16) & 0xff]
 486           | ip_maskr[2][(l_in >> 8) & 0xff]
 487           | ip_maskr[3][l_in & 0xff]
 488           | ip_maskr[4][r_in >> 24]
 489           | ip_maskr[5][(r_in >> 16) & 0xff]
 490           | ip_maskr[6][(r_in >> 8) & 0xff]
 491           | ip_maskr[7][r_in & 0xff];
 492
 493         while (count--) {
 494                 /*
 495                  * Do each round.
 496                  */
 497                 kl = kl1;
 498                 kr = kr1;
 499                 round = 16;
 500                 while (round--) {
 501                         /*
 502                          * Expand R to 48 bits (simulate the E-box).
 503                          */
 504                         r48l    = ((r & 0x00000001) << 23)
 505                                 | ((r & 0xf8000000) >> 9)
 506                                 | ((r & 0x1f800000) >> 11)
 507                                 | ((r & 0x01f80000) >> 13)
 508                                 | ((r & 0x001f8000) >> 15);
 509
 510                         r48r    = ((r & 0x0001f800) << 7)
 511                                 | ((r & 0x00001f80) << 5)
 512                                 | ((r & 0x000001f8) << 3)
 513                                 | ((r & 0x0000001f) << 1)
 514                                 | ((r & 0x80000000) >> 31);
 515                         /*
 516                          * Do salting for crypt() and friends, and
 517                          * XOR with the permuted key.
 518                          */
 519                         f = (r48l ^ r48r) & saltbits;
 520                         r48l ^= f ^ *kl++;
 521                         r48r ^= f ^ *kr++;
 522                         /*
 523                          * Do sbox lookups (which shrink it back to 32 bits)
 524                          * and do the pbox permutation at the same time.
 525                          */
 526                         f = psbox[0][m_sbox[0][r48l >> 12]]
 527                           | psbox[1][m_sbox[1][r48l & 0xfff]]
 528                           | psbox[2][m_sbox[2][r48r >> 12]]
 529                           | psbox[3][m_sbox[3][r48r & 0xfff]];
 530                         /*
 531                          * Now that we've permuted things, complete f().
 532                          */
 533                         f ^= l;
 534                         l = r;
 535                         r = f;
 536                 }
 537                 r = l;
 538                 l = f;
 539         }
 540         /*
 541          * Do final permutation (inverse of IP).
 542          */
 543         *l_out  = fp_maskl[0][l >> 24]
 544                 | fp_maskl[1][(l >> 16) & 0xff]
 545                 | fp_maskl[2][(l >> 8) & 0xff]
 546                 | fp_maskl[3][l & 0xff]
 547                 | fp_maskl[4][r >> 24]
 548                 | fp_maskl[5][(r >> 16) & 0xff]
 549                 | fp_maskl[6][(r >> 8) & 0xff]
 550                 | fp_maskl[7][r & 0xff];
 551         *r_out  = fp_maskr[0][l >> 24]
 552                 | fp_maskr[1][(l >> 16) & 0xff]
 553                 | fp_maskr[2][(l >> 8) & 0xff]
 554                 | fp_maskr[3][l & 0xff]
 555                 | fp_maskr[4][r >> 24]
 556                 | fp_maskr[5][(r >> 16) & 0xff]
 557                 | fp_maskr[6][(r >> 8) & 0xff]
 558                 | fp_maskr[7][r & 0xff];
 559         return(0);
 560 }
 561
 562 static int
 563 des_cipher(const char *in, char *out, long salt, int count)
 564 {
 565         const uint32_t  *in32;
 566         uint32_t        l_out, r_out, rawl, rawr, *out32;
 567         int             retval;
 568
 569         if (!des_initialised)
 570                 des_init();
 571
 572         setup_salt(salt);
 573
 574         in32 = (const uint32_t *)in;
 575         out32 = (uint32_t *)out;
 576
 577         rawl = ntohl(*in32++);
 578         rawr = ntohl(*in32);
 579
 580         retval = do_des(rawl, rawr, &l_out, &r_out, count);
 581
 582         *out32++ = htonl(l_out);
 583         *out32 = htonl(r_out);
 584         return(retval);
 585 }
 586
 587 char *
 588 crypt_des(const char *key, const char *setting)
 589 {
 590         int             i;
 591         u_int32_t       count, salt, l, r0, r1, keybuf[2];
 592         u_char          *p, *q;
 593         static u_char   output[21];
 594
 595         if (!des_initialised)
 596                 des_init();
 597
 598
 599         /*
 600          * Copy the key, shifting each character up by one bit
 601          * and padding with zeros.
 602          */
 603         q = (u_char *) keybuf;
 604         while (q - (u_char *) keybuf - 8) {
 605                 if ((*q++ = *key << 1))
 606                         key++;
 607         }
 608         if (des_setkey((u_char *) keybuf))
 609                 return(NULL);
 610
 611         if (*setting == _PASSWORD_EFMT1) {
 612                 /*
 613                  * "new"-style:
 614                  *      setting - underscore, 4 bytes of count, 4 bytes of salt
 615                  *      key - unlimited characters
 616                  */
 617                 for (i = 1, count = 0L; i < 5; i++)
 618                         count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
 619
 620                 for (i = 5, salt = 0L; i < 9; i++)
 621                         salt |= ascii_to_bin(setting[i]) << (i - 5) * 6;
 622
 623                 while (*key) {
 624                         /*
 625                          * Encrypt the key with itself.
 626                          */
 627                         if (des_cipher((u_char*)keybuf, (u_char*)keybuf, 0L, 1))
 628                                 return(NULL);
 629                         /*
 630                          * And XOR with the next 8 characters of the key.
 631                          */
 632                         q = (u_char *) keybuf;
 633                         while (q - (u_char *) keybuf - 8 && *key)
 634                                 *q++ ^= *key++ << 1;
 635
 636                         if (des_setkey((u_char *) keybuf))
 637                                 return(NULL);
 638                 }
 639                 strncpy(output, setting, 9);
 640
 641                 /*
 642                  * Double check that we weren't given a short setting.
 643                  * If we were, the above code will probably have created
 644                  * weird values for count and salt, but we don't really care.
 645                  * Just make sure the output string doesn't have an extra
 646                  * NUL in it.
 647                  */
 648                 output[9] = '\0';
 649                 p = output + strlen(output);
 650         } else {
 651                 /*
 652                  * "old"-style:
 653                  *      setting - 2 bytes of salt
 654                  *      key - up to 8 characters
 655                  */
 656                 count = 25;
 657
 658                 salt = (ascii_to_bin(setting[1]) << 6)
 659                      |  ascii_to_bin(setting[0]);
 660
 661                 output[0] = setting[0];
 662                 /*
 663                  * If the encrypted password that the salt was extracted from
 664                  * is only 1 character long, the salt will be corrupted.  We
 665                  * need to ensure that the output string doesn't have an extra
 666                  * NUL in it!
 667                  */
 668                 output[1] = setting[1] ? setting[1] : output[0];
 669
 670                 p = output + 2;
 671         }
 672         setup_salt(salt);
 673         /*
 674          * Do it.
 675          */
 676         if (do_des(0L, 0L, &r0, &r1, count))
 677                 return(NULL);
 678         /*
 679          * Now encode the result...
 680          */
 681         l = (r0 >> 8);
 682         *p++ = ascii64[(l >> 18) & 0x3f];
 683         *p++ = ascii64[(l >> 12) & 0x3f];
 684         *p++ = ascii64[(l >> 6) & 0x3f];
 685         *p++ = ascii64[l & 0x3f];
 686
 687         l = (r0 << 16) | ((r1 >> 16) & 0xffff);
 688         *p++ = ascii64[(l >> 18) & 0x3f];
 689         *p++ = ascii64[(l >> 12) & 0x3f];
 690         *p++ = ascii64[(l >> 6) & 0x3f];
 691         *p++ = ascii64[l & 0x3f];
 692
 693         l = r1 << 2;
 694         *p++ = ascii64[(l >> 12) & 0x3f];
 695         *p++ = ascii64[(l >> 6) & 0x3f];
 696         *p++ = ascii64[l & 0x3f];
 697         *p = 0;
 698
 699         return(output);
 700 }