libcrypt/des.c

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