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