secure/lib/libcipher/crypt.c

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