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 inline int
 183 ascii_to_bin(char ch)
 184 {
 185         if (ch > 'z')
 186                 return(0);
 187         if (ch >= 'a')
 188                 return(ch - 'a' + 38);
 189         if (ch > 'Z')
 190                 return(0);
 191         if (ch >= 'A')
 192                 return(ch - 'A' + 12);
 193         if (ch > '9')
 194                 return(0);
 195         if (ch >= '.')
 196                 return(ch - '.');
 197         return(0);
 198 }
 199
 200 \f
 201 static void
 202 des_init(void)
 203 {
 204         int     i, j, b, k, inbit, obit;
 205         u_long  *p, *il, *ir, *fl, *fr;
 206
 207         old_rawkey0 = old_rawkey1 = 0L;
 208         saltbits = 0L;
 209         old_salt = 0L;
 210         bits24 = (bits28 = bits32 + 4) + 4;
 211
 212         /*
 213          * Invert the S-boxes, reordering the input bits.
 214          */
 215         for (i = 0; i < 8; i++)
 216                 for (j = 0; j < 64; j++) {
 217                         b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
 218                         u_sbox[i][j] = sbox[i][b];
 219                 }
 220
 221         /*
 222          * Convert the inverted S-boxes into 4 arrays of 8 bits.
 223          * Each will handle 12 bits of the S-box input.
 224          */
 225         for (b = 0; b < 4; b++)
 226                 for (i = 0; i < 64; i++)
 227                         for (j = 0; j < 64; j++)
 228                                 m_sbox[b][(i << 6) | j] =
 229                                         (u_sbox[(b << 1)][i] << 4) |
 230                                         u_sbox[(b << 1) + 1][j];
 231
 232         /*
 233          * Set up the initial & final permutations into a useful form, and
 234          * initialise the inverted key permutation.
 235          */
 236         for (i = 0; i < 64; i++) {
 237                 init_perm[final_perm[i] = IP[i] - 1] = i;
 238                 inv_key_perm[i] = 255;
 239         }
 240
 241         /*
 242          * Invert the key permutation and initialise the inverted key
 243          * compression permutation.
 244          */
 245         for (i = 0; i < 56; i++) {
 246                 u_key_perm[i] = key_perm[i] - 1;
 247                 inv_key_perm[key_perm[i] - 1] = i;
 248                 inv_comp_perm[i] = 255;
 249         }
 250
 251         /*
 252          * Invert the key compression permutation.
 253          */
 254         for (i = 0; i < 48; i++) {
 255                 inv_comp_perm[comp_perm[i] - 1] = i;
 256         }
 257
 258         /*
 259          * Set up the OR-mask arrays for the initial and final permutations,
 260          * and for the key initial and compression permutations.
 261          */
 262         for (k = 0; k < 8; k++) {
 263                 for (i = 0; i < 256; i++) {
 264                         *(il = &ip_maskl[k][i]) = 0L;
 265                         *(ir = &ip_maskr[k][i]) = 0L;
 266                         *(fl = &fp_maskl[k][i]) = 0L;
 267                         *(fr = &fp_maskr[k][i]) = 0L;
 268                         for (j = 0; j < 8; j++) {
 269                                 inbit = 8 * k + j;
 270                                 if (i & bits8[j]) {
 271                                         if ((obit = init_perm[inbit]) < 32)
 272                                                 *il |= bits32[obit];
 273                                         else
 274                                                 *ir |= bits32[obit-32];
 275                                         if ((obit = final_perm[inbit]) < 32)
 276                                                 *fl |= bits32[obit];
 277                                         else
 278                                                 *fr |= bits32[obit - 32];
 279                                 }
 280                         }
 281                 }
 282                 for (i = 0; i < 128; i++) {
 283                         *(il = &key_perm_maskl[k][i]) = 0L;
 284                         *(ir = &key_perm_maskr[k][i]) = 0L;
 285                         for (j = 0; j < 7; j++) {
 286                                 inbit = 8 * k + j;
 287                                 if (i & bits8[j + 1]) {
 288                                         if ((obit = inv_key_perm[inbit]) == 255)
 289                                                 continue;
 290                                         if (obit < 28)
 291                                                 *il |= bits28[obit];
 292                                         else
 293                                                 *ir |= bits28[obit - 28];
 294                                 }
 295                         }
 296                         *(il = &comp_maskl[k][i]) = 0L;
 297                         *(ir = &comp_maskr[k][i]) = 0L;
 298                         for (j = 0; j < 7; j++) {
 299                                 inbit = 7 * k + j;
 300                                 if (i & bits8[j + 1]) {
 301                                         if ((obit=inv_comp_perm[inbit]) == 255)
 302                                                 continue;
 303                                         if (obit < 24)
 304                                                 *il |= bits24[obit];
 305                                         else
 306                                                 *ir |= bits24[obit - 24];
 307                                 }
 308                         }
 309                 }
 310         }
 311
 312         /*
 313          * Invert the P-box permutation, and convert into OR-masks for
 314          * handling the output of the S-box arrays setup above.
 315          */
 316         for (i = 0; i < 32; i++)
 317                 un_pbox[pbox[i] - 1] = i;
 318
 319         for (b = 0; b < 4; b++)
 320                 for (i = 0; i < 256; i++) {
 321                         *(p = &psbox[b][i]) = 0L;
 322                         for (j = 0; j < 8; j++) {
 323                                 if (i & bits8[j])
 324                                         *p |= bits32[un_pbox[8 * b + j]];
 325                         }
 326                 }
 327
 328         des_initialised = 1;
 329 }
 330
 331 \f
 332 static void
 333 setup_salt(long salt)
 334 {
 335         u_long  obit, saltbit;
 336         int     i;
 337
 338         if (salt == old_salt)
 339                 return;
 340         old_salt = salt;
 341
 342         saltbits = 0L;
 343         saltbit = 1;
 344         obit = 0x800000;
 345         for (i = 0; i < 24; i++) {
 346                 if (salt & saltbit)
 347                         saltbits |= obit;
 348                 saltbit <<= 1;
 349                 obit >>= 1;
 350         }
 351 }
 352
 353 \f
 354 int
 355 des_setkey(const char *key)
 356 {
 357         u_long  k0, k1, rawkey0, rawkey1;
 358         int     shifts, round;
 359
 360         if (!des_initialised)
 361                 des_init();
 362
 363         rawkey0 = ntohl(*(u_long *) key);
 364         rawkey1 = ntohl(*(u_long *) (key + 4));
 365
 366         if ((rawkey0 | rawkey1)
 367             && rawkey0 == old_rawkey0
 368             && rawkey1 == old_rawkey1) {
 369                 /*
 370                  * Already setup for this key.
 371                  * This optimisation fails on a zero key (which is weak and
 372                  * has bad parity anyway) in order to simplify the starting
 373                  * conditions.
 374                  */
 375                 return(0);
 376         }
 377         old_rawkey0 = rawkey0;
 378         old_rawkey1 = rawkey1;
 379
 380         /*
 381          *      Do key permutation and split into two 28-bit subkeys.
 382          */
 383         k0 = key_perm_maskl[0][rawkey0 >> 25]
 384            | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
 385            | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
 386            | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
 387            | key_perm_maskl[4][rawkey1 >> 25]
 388            | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
 389            | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
 390            | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
 391         k1 = key_perm_maskr[0][rawkey0 >> 25]
 392            | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
 393            | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
 394            | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
 395            | key_perm_maskr[4][rawkey1 >> 25]
 396            | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
 397            | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
 398            | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
 399         /*
 400          *      Rotate subkeys and do compression permutation.
 401          */
 402         shifts = 0;
 403         for (round = 0; round < 16; round++) {
 404                 u_long  t0, t1;
 405
 406                 shifts += key_shifts[round];
 407
 408                 t0 = (k0 << shifts) | (k0 >> (28 - shifts));
 409                 t1 = (k1 << shifts) | (k1 >> (28 - shifts));
 410
 411                 de_keysl[15 - round] =
 412                 en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
 413                                 | comp_maskl[1][(t0 >> 14) & 0x7f]
 414                                 | comp_maskl[2][(t0 >> 7) & 0x7f]
 415                                 | comp_maskl[3][t0 & 0x7f]
 416                                 | comp_maskl[4][(t1 >> 21) & 0x7f]
 417                                 | comp_maskl[5][(t1 >> 14) & 0x7f]
 418                                 | comp_maskl[6][(t1 >> 7) & 0x7f]
 419                                 | comp_maskl[7][t1 & 0x7f];
 420
 421                 de_keysr[15 - round] =
 422                 en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
 423                                 | comp_maskr[1][(t0 >> 14) & 0x7f]
 424                                 | comp_maskr[2][(t0 >> 7) & 0x7f]
 425                                 | comp_maskr[3][t0 & 0x7f]
 426                                 | comp_maskr[4][(t1 >> 21) & 0x7f]
 427                                 | comp_maskr[5][(t1 >> 14) & 0x7f]
 428                                 | comp_maskr[6][(t1 >> 7) & 0x7f]
 429                                 | comp_maskr[7][t1 & 0x7f];
 430         }
 431         return(0);
 432 }
 433
 434 \f
 435 static int
 436 do_des( u_long l_in, u_long r_in, u_long *l_out, u_long *r_out, int count)
 437 {
 438         /*
 439          *      l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
 440          */
 441         u_long  l, r, *kl, *kr, *kl1, *kr1;
 442         u_long  f, r48l, r48r;
 443         int     round;
 444
 445         if (count == 0) {
 446                 return(1);
 447         } else if (count > 0) {
 448                 /*
 449                  * Encrypting
 450                  */
 451                 kl1 = en_keysl;
 452                 kr1 = en_keysr;
 453         } else {
 454                 /*
 455                  * Decrypting
 456                  */
 457                 count = -count;
 458                 kl1 = de_keysl;
 459                 kr1 = de_keysr;
 460         }
 461
 462         /*
 463          *      Do initial permutation (IP).
 464          */
 465         l = ip_maskl[0][l_in >> 24]
 466           | ip_maskl[1][(l_in >> 16) & 0xff]
 467           | ip_maskl[2][(l_in >> 8) & 0xff]
 468           | ip_maskl[3][l_in & 0xff]
 469           | ip_maskl[4][r_in >> 24]
 470           | ip_maskl[5][(r_in >> 16) & 0xff]
 471           | ip_maskl[6][(r_in >> 8) & 0xff]
 472           | ip_maskl[7][r_in & 0xff];
 473         r = ip_maskr[0][l_in >> 24]
 474           | ip_maskr[1][(l_in >> 16) & 0xff]
 475           | ip_maskr[2][(l_in >> 8) & 0xff]
 476           | ip_maskr[3][l_in & 0xff]
 477           | ip_maskr[4][r_in >> 24]
 478           | ip_maskr[5][(r_in >> 16) & 0xff]
 479           | ip_maskr[6][(r_in >> 8) & 0xff]
 480           | ip_maskr[7][r_in & 0xff];
 481
 482         while (count--) {
 483                 /*
 484                  * Do each round.
 485                  */
 486                 kl = kl1;
 487                 kr = kr1;
 488                 round = 16;
 489                 while (round--) {
 490                         /*
 491                          * Expand R to 48 bits (simulate the E-box).
 492                          */
 493                         r48l    = ((r & 0x00000001) << 23)
 494                                 | ((r & 0xf8000000) >> 9)
 495                                 | ((r & 0x1f800000) >> 11)
 496                                 | ((r & 0x01f80000) >> 13)
 497                                 | ((r & 0x001f8000) >> 15);
 498
 499                         r48r    = ((r & 0x0001f800) << 7)
 500                                 | ((r & 0x00001f80) << 5)
 501                                 | ((r & 0x000001f8) << 3)
 502                                 | ((r & 0x0000001f) << 1)
 503                                 | ((r & 0x80000000) >> 31);
 504                         /*
 505                          * Do salting for crypt() and friends, and
 506                          * XOR with the permuted key.
 507                          */
 508                         f = (r48l ^ r48r) & saltbits;
 509                         r48l ^= f ^ *kl++;
 510                         r48r ^= f ^ *kr++;
 511                         /*
 512                          * Do sbox lookups (which shrink it back to 32 bits)
 513                          * and do the pbox permutation at the same time.
 514                          */
 515                         f = psbox[0][m_sbox[0][r48l >> 12]]
 516                           | psbox[1][m_sbox[1][r48l & 0xfff]]
 517                           | psbox[2][m_sbox[2][r48r >> 12]]
 518                           | psbox[3][m_sbox[3][r48r & 0xfff]];
 519                         /*
 520                          * Now that we've permuted things, complete f().
 521                          */
 522                         f ^= l;
 523                         l = r;
 524                         r = f;
 525                 }
 526                 r = l;
 527                 l = f;
 528         }
 529         /*
 530          * Do final permutation (inverse of IP).
 531          */
 532         *l_out  = fp_maskl[0][l >> 24]
 533                 | fp_maskl[1][(l >> 16) & 0xff]
 534                 | fp_maskl[2][(l >> 8) & 0xff]
 535                 | fp_maskl[3][l & 0xff]
 536                 | fp_maskl[4][r >> 24]
 537                 | fp_maskl[5][(r >> 16) & 0xff]
 538                 | fp_maskl[6][(r >> 8) & 0xff]
 539                 | fp_maskl[7][r & 0xff];
 540         *r_out  = fp_maskr[0][l >> 24]
 541                 | fp_maskr[1][(l >> 16) & 0xff]
 542                 | fp_maskr[2][(l >> 8) & 0xff]
 543                 | fp_maskr[3][l & 0xff]
 544                 | fp_maskr[4][r >> 24]
 545                 | fp_maskr[5][(r >> 16) & 0xff]
 546                 | fp_maskr[6][(r >> 8) & 0xff]
 547                 | fp_maskr[7][r & 0xff];
 548         return(0);
 549 }
 550
 551 \f
 552 int
 553 des_cipher(const char *in, char *out, long salt, int count)
 554 {
 555         u_long  l_out, r_out, rawl, rawr;
 556         int     retval;
 557
 558         if (!des_initialised)
 559                 des_init();
 560
 561         setup_salt(salt);
 562
 563         rawl = ntohl(*((u_long *) in));
 564         rawr = ntohl(*(((u_long *) in) + 1));
 565
 566         retval = do_des(rawl, rawr, &l_out, &r_out, count);
 567
 568         *((u_long *) out) = htonl(l_out);
 569         *(((u_long *) out) + 1) = htonl(r_out);
 570         return(retval);
 571 }
 572
 573 \f
 574 int
 575 setkey(char *key)
 576 {
 577         int     i, j;
 578         u_long  packed_keys[2];
 579         u_char  *p;
 580
 581         p = (u_char *) packed_keys;
 582
 583         for (i = 0; i < 8; i++) {
 584                 p[i] = 0;
 585                 for (j = 0; j < 8; j++)
 586                         if (*key++ & 1)
 587                                 p[i] |= bits8[j];
 588         }
 589         return(des_setkey(p));
 590 }
 591
 592
 593 int
 594 encrypt(char *block, int flag)
 595 {
 596         u_long  io[2];
 597         u_char  *p;
 598         int     i, j, retval;
 599
 600         if (!des_initialised)
 601                 des_init();
 602
 603         setup_salt(0L);
 604         p = block;
 605         for (i = 0; i < 2; i++) {
 606                 io[i] = 0L;
 607                 for (j = 0; j < 32; j++)
 608                         if (*p++ & 1)
 609                                 io[i] |= bits32[j];
 610         }
 611         retval = do_des(io[0], io[1], io, io + 1, flag ? -1 : 1);
 612         for (i = 0; i < 2; i++)
 613                 for (j = 0; j < 32; j++)
 614                         block[(i << 5) | j] = (io[i] & bits32[j]) ? 1 : 0;
 615         return(retval);
 616 }
 617