tests/crypttest.c

   1 #if defined(HAVE_UNISTD_H)
   2 #include <unistd.h>
   3 #endif
   4
   5 #include <sys/types.h>
   6
   7 #ifdef HAVE_STRING_H
   8 #include <string.h>
   9 #endif
  10
  11 #ifdef HAVE_STRINGS_H
  12 #include <strings.h>
  13 #endif
  14
  15 #if !defined(HAVE_CRYPT)
  16
  17 /*
  18    This bit of code was derived from the UFC-crypt package which
  19    carries the following copyright
  20
  21    Modified for use by Samba by Andrew Tridgell, October 1994
  22
  23    Note that this routine is only faster on some machines. Under Linux 1.1.51
  24    libc 4.5.26 I actually found this routine to be slightly slower.
  25
  26    Under SunOS I found a huge speedup by using these routines
  27    (a factor of 20 or so)
  28
  29    Warning: I've had a report from Steve Kennedy <steve@gbnet.org>
  30    that this crypt routine may sometimes get the wrong answer. Only
  31    use UFC_CRYT if you really need it.
  32
  33 */
  34
  35 /*
  36  * UFC-crypt: ultra fast crypt(3) implementation
  37  *
  38  * Copyright (C) 1991-1998, Free Software Foundation, Inc.
  39  *
  40  * This library is free software; you can redistribute it and/or
  41  * modify it under the terms of the GNU Lesser General Public
  42  * License as published by the Free Software Foundation; either
  43  * version 3 of the License, or (at your option) any later version.
  44  *
  45  * This library is distributed in the hope that it will be useful,
  46  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  47  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  48  * Library General Public License for more details.
  49  *
  50  * You should have received a copy of the GNU Lesser General Public
  51  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  52  *
  53  * @(#)crypt_util.c     2.31 02/08/92
  54  *
  55  * Support routines
  56  *
  57  */
  58
  59
  60 #ifndef long32
  61 #if (SIZEOF_INT == 4)
  62 #define long32 int
  63 #elif (SIZEOF_LONG == 4)
  64 #define long32 long
  65 #elif (SIZEOF_SHORT == 4)
  66 #define long32 short
  67 #else
  68 /* uggh - no 32 bit type?? probably a CRAY. just hope this works ... */
  69 #define long32 int
  70 #endif
  71 #endif
  72
  73 #ifndef long64
  74 #ifdef HAVE_LONGLONG
  75 #define long64 long long long
  76 #endif
  77 #endif
  78
  79 #ifndef ufc_long
  80 #define ufc_long unsigned
  81 #endif
  82
  83 #ifndef _UFC_64_
  84 #define _UFC_32_
  85 #endif
  86
  87 /*
  88  * Permutation done once on the 56 bit
  89  *  key derived from the original 8 byte ASCII key.
  90  */
  91 static int pc1[56] = {
  92   57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
  93   10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
  94   63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
  95   14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
  96 };
  97
  98 /*
  99  * How much to rotate each 28 bit half of the pc1 permutated
 100  *  56 bit key before using pc2 to give the i' key
 101  */
 102 static int rots[16] = {
 103   1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
 104 };
 105
 106 /*
 107  * Permutation giving the key
 108  * of the i' DES round
 109  */
 110 static int pc2[48] = {
 111   14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
 112   23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
 113   41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
 114   44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
 115 };
 116
 117 /*
 118  * The E expansion table which selects
 119  * bits from the 32 bit intermediate result.
 120  */
 121 static int esel[48] = {
 122   32,  1,  2,  3,  4,  5,  4,  5,  6,  7,  8,  9,
 123    8,  9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
 124   16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
 125   24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32,  1
 126 };
 127 static int e_inverse[64];
 128
 129 /*
 130  * Permutation done on the
 131  * result of sbox lookups
 132  */
 133 static int perm32[32] = {
 134   16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
 135   2,   8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
 136 };
 137
 138 /*
 139  * The sboxes
 140  */
 141 static int sbox[8][4][16]= {
 142         { { 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7 },
 143           {  0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8 },
 144           {  4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0 },
 145           { 15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13 }
 146         },
 147
 148         { { 15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10 },
 149           {  3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5 },
 150           {  0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15 },
 151           { 13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9 }
 152         },
 153
 154         { { 10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8 },
 155           { 13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1 },
 156           { 13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7 },
 157           {  1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12 }
 158         },
 159
 160         { {  7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15 },
 161           { 13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9 },
 162           { 10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4 },
 163           {  3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14 }
 164         },
 165
 166         { {  2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9 },
 167           { 14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6 },
 168           {  4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14 },
 169           { 11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3 }
 170         },
 171
 172         { { 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11 },
 173           { 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8 },
 174           {  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6 },
 175           {  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13 }
 176         },
 177
 178         { {  4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1 },
 179           { 13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6 },
 180           {  1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2 },
 181           {  6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12 }
 182         },
 183
 184         { { 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7 },
 185           {  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2 },
 186           {  7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8 },
 187           {  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11 }
 188         }
 189 };
 190
 191 /*
 192  * This is the final
 193  * permutation matrix
 194  */
 195 static int final_perm[64] = {
 196   40,  8, 48, 16, 56, 24, 64, 32, 39,  7, 47, 15, 55, 23, 63, 31,
 197   38,  6, 46, 14, 54, 22, 62, 30, 37,  5, 45, 13, 53, 21, 61, 29,
 198   36,  4, 44, 12, 52, 20, 60, 28, 35,  3, 43, 11, 51, 19, 59, 27,
 199   34,  2, 42, 10, 50, 18, 58, 26, 33,  1, 41,  9, 49, 17, 57, 25
 200 };
 201
 202 /*
 203  * The 16 DES keys in BITMASK format
 204  */
 205 #ifdef _UFC_32_
 206 long32 _ufc_keytab[16][2];
 207 #endif
 208
 209 #ifdef _UFC_64_
 210 long64 _ufc_keytab[16];
 211 #endif
 212
 213
 214 #define ascii_to_bin(c) ((c)>='a'?(c-59):(c)>='A'?((c)-53):(c)-'.')
 215 #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
 216
 217 /* Macro to set a bit (0..23) */
 218 #define BITMASK(i) ( (1<<(11-(i)%12+3)) << ((i)<12?16:0) )
 219
 220 /*
 221  * sb arrays:
 222  *
 223  * Workhorses of the inner loop of the DES implementation.
 224  * They do sbox lookup, shifting of this  value, 32 bit
 225  * permutation and E permutation for the next round.
 226  *
 227  * Kept in 'BITMASK' format.
 228  */
 229
 230 #ifdef _UFC_32_
 231 long32 _ufc_sb0[8192], _ufc_sb1[8192], _ufc_sb2[8192], _ufc_sb3[8192];
 232 static long32 *sb[4] = {_ufc_sb0, _ufc_sb1, _ufc_sb2, _ufc_sb3};
 233 #endif
 234
 235 #ifdef _UFC_64_
 236 long64 _ufc_sb0[4096], _ufc_sb1[4096], _ufc_sb2[4096], _ufc_sb3[4096];
 237 static long64 *sb[4] = {_ufc_sb0, _ufc_sb1, _ufc_sb2, _ufc_sb3};
 238 #endif
 239
 240 /*
 241  * eperm32tab: do 32 bit permutation and E selection
 242  *
 243  * The first index is the byte number in the 32 bit value to be permuted
 244  *  -  second  -   is the value of this byte
 245  *  -  third   -   selects the two 32 bit values
 246  *
 247  * The table is used and generated internally in init_des to speed it up
 248  */
 249 static ufc_long eperm32tab[4][256][2];
 250
 251 /*
 252  * do_pc1: permform pc1 permutation in the key schedule generation.
 253  *
 254  * The first   index is the byte number in the 8 byte ASCII key
 255  *  -  second    -      -    the two 28 bits halfs of the result
 256  *  -  third     -   selects the 7 bits actually used of each byte
 257  *
 258  * The result is kept with 28 bit per 32 bit with the 4 most significant
 259  * bits zero.
 260  */
 261 static ufc_long do_pc1[8][2][128];
 262
 263 /*
 264  * do_pc2: permform pc2 permutation in the key schedule generation.
 265  *
 266  * The first   index is the septet number in the two 28 bit intermediate values
 267  *  -  second    -    -  -  septet values
 268  *
 269  * Knowledge of the structure of the pc2 permutation is used.
 270  *
 271  * The result is kept with 28 bit per 32 bit with the 4 most significant
 272  * bits zero.
 273  */
 274 static ufc_long do_pc2[8][128];
 275
 276 /*
 277  * efp: undo an extra e selection and do final
 278  *      permutation giving the DES result.
 279  *
 280  *      Invoked 6 bit a time on two 48 bit values
 281  *      giving two 32 bit longs.
 282  */
 283 static ufc_long efp[16][64][2];
 284
 285 static unsigned char bytemask[8]  = {
 286   0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
 287 };
 288
 289 static ufc_long longmask[32] = {
 290   0x80000000, 0x40000000, 0x20000000, 0x10000000,
 291   0x08000000, 0x04000000, 0x02000000, 0x01000000,
 292   0x00800000, 0x00400000, 0x00200000, 0x00100000,
 293   0x00080000, 0x00040000, 0x00020000, 0x00010000,
 294   0x00008000, 0x00004000, 0x00002000, 0x00001000,
 295   0x00000800, 0x00000400, 0x00000200, 0x00000100,
 296   0x00000080, 0x00000040, 0x00000020, 0x00000010,
 297   0x00000008, 0x00000004, 0x00000002, 0x00000001
 298 };
 299
 300
 301 /*
 302  * Silly rewrite of 'bzero'. I do so
 303  * because some machines don't have
 304  * bzero and some don't have memset.
 305  */
 306
 307 static void clearmem(char *start, int cnt)
 308   { while(cnt--)
 309       *start++ = '\0';
 310   }
 311
 312 static int initialized = 0;
 313
 314 /* lookup a 6 bit value in sbox */
 315
 316 #define s_lookup(i,s) sbox[(i)][(((s)>>4) & 0x2)|((s) & 0x1)][((s)>>1) & 0xf];
 317
 318 /*
 319  * Initialize unit - may be invoked directly
 320  * by fcrypt users.
 321  */
 322
 323 static void ufc_init_des(void)
 324   { int comes_from_bit;
 325     int bit, sg;
 326     ufc_long j;
 327     ufc_long mask1, mask2;
 328
 329     /*
 330      * Create the do_pc1 table used
 331      * to affect pc1 permutation
 332      * when generating keys
 333      */
 334     for(bit = 0; bit < 56; bit++) {
 335       comes_from_bit  = pc1[bit] - 1;
 336       mask1 = bytemask[comes_from_bit % 8 + 1];
 337       mask2 = longmask[bit % 28 + 4];
 338       for(j = 0; j < 128; j++) {
 339         if(j & mask1)
 340           do_pc1[comes_from_bit / 8][bit / 28][j] |= mask2;
 341       }
 342     }
 343
 344     /*
 345      * Create the do_pc2 table used
 346      * to affect pc2 permutation when
 347      * generating keys
 348      */
 349     for(bit = 0; bit < 48; bit++) {
 350       comes_from_bit  = pc2[bit] - 1;
 351       mask1 = bytemask[comes_from_bit % 7 + 1];
 352       mask2 = BITMASK(bit % 24);
 353       for(j = 0; j < 128; j++) {
 354         if(j & mask1)
 355           do_pc2[comes_from_bit / 7][j] |= mask2;
 356       }
 357     }
 358
 359     /*
 360      * Now generate the table used to do combined
 361      * 32 bit permutation and e expansion
 362      *
 363      * We use it because we have to permute 16384 32 bit
 364      * longs into 48 bit in order to initialize sb.
 365      *
 366      * Looping 48 rounds per permutation becomes
 367      * just too slow...
 368      *
 369      */
 370
 371     clearmem((char*)eperm32tab, sizeof(eperm32tab));
 372
 373     for(bit = 0; bit < 48; bit++) {
 374       ufc_long inner_mask1,comes_from;
 375
 376       comes_from = perm32[esel[bit]-1]-1;
 377       inner_mask1      = bytemask[comes_from % 8];
 378
 379       for(j = 256; j--;) {
 380         if(j & inner_mask1)
 381           eperm32tab[comes_from / 8][j][bit / 24] |= BITMASK(bit % 24);
 382       }
 383     }
 384
 385     /*
 386      * Create the sb tables:
 387      *
 388      * For each 12 bit segment of an 48 bit intermediate
 389      * result, the sb table precomputes the two 4 bit
 390      * values of the sbox lookups done with the two 6
 391      * bit halves, shifts them to their proper place,
 392      * sends them through perm32 and finally E expands
 393      * them so that they are ready for the next
 394      * DES round.
 395      *
 396      */
 397     for(sg = 0; sg < 4; sg++) {
 398       int j1, j2;
 399       int s1, s2;
 400
 401       for(j1 = 0; j1 < 64; j1++) {
 402         s1 = s_lookup(2 * sg, j1);
 403         for(j2 = 0; j2 < 64; j2++) {
 404           ufc_long to_permute, inx;
 405
 406           s2         = s_lookup(2 * sg + 1, j2);
 407           to_permute = ((s1 << 4)  | s2) << (24 - 8 * sg);
 408
 409 #ifdef _UFC_32_
 410           inx = ((j1 << 6)  | j2) << 1;
 411           sb[sg][inx  ]  = eperm32tab[0][(to_permute >> 24) & 0xff][0];
 412           sb[sg][inx+1]  = eperm32tab[0][(to_permute >> 24) & 0xff][1];
 413           sb[sg][inx  ] |= eperm32tab[1][(to_permute >> 16) & 0xff][0];
 414           sb[sg][inx+1] |= eperm32tab[1][(to_permute >> 16) & 0xff][1];
 415           sb[sg][inx  ] |= eperm32tab[2][(to_permute >>  8) & 0xff][0];
 416           sb[sg][inx+1] |= eperm32tab[2][(to_permute >>  8) & 0xff][1];
 417           sb[sg][inx  ] |= eperm32tab[3][(to_permute)       & 0xff][0];
 418           sb[sg][inx+1] |= eperm32tab[3][(to_permute)       & 0xff][1];
 419 #endif
 420 #ifdef _UFC_64_
 421           inx = ((j1 << 6)  | j2);
 422           sb[sg][inx]  =
 423             ((long64)eperm32tab[0][(to_permute >> 24) & 0xff][0] << 32) |
 424              (long64)eperm32tab[0][(to_permute >> 24) & 0xff][1];
 425           sb[sg][inx] |=
 426             ((long64)eperm32tab[1][(to_permute >> 16) & 0xff][0] << 32) |
 427              (long64)eperm32tab[1][(to_permute >> 16) & 0xff][1];
 428           sb[sg][inx] |=
 429             ((long64)eperm32tab[2][(to_permute >>  8) & 0xff][0] << 32) |
 430              (long64)eperm32tab[2][(to_permute >>  8) & 0xff][1];
 431           sb[sg][inx] |=
 432             ((long64)eperm32tab[3][(to_permute)       & 0xff][0] << 32) |
 433              (long64)eperm32tab[3][(to_permute)       & 0xff][1];
 434 #endif
 435         }
 436       }
 437     }
 438
 439     /*
 440      * Create an inverse matrix for esel telling
 441      * where to plug out bits if undoing it
 442      */
 443     for(bit=48; bit--;) {
 444       e_inverse[esel[bit] - 1     ] = bit;
 445       e_inverse[esel[bit] - 1 + 32] = bit + 48;
 446     }
 447
 448     /*
 449      * create efp: the matrix used to
 450      * undo the E expansion and effect final permutation
 451      */
 452     clearmem((char*)efp, sizeof efp);
 453     for(bit = 0; bit < 64; bit++) {
 454       int o_bit, o_long;
 455       ufc_long word_value, inner_mask1, inner_mask2;
 456       int comes_from_f_bit, comes_from_e_bit;
 457       int comes_from_word, bit_within_word;
 458
 459       /* See where bit i belongs in the two 32 bit long's */
 460       o_long = bit / 32; /* 0..1  */
 461       o_bit  = bit % 32; /* 0..31 */
 462
 463       /*
 464        * And find a bit in the e permutated value setting this bit.
 465        *
 466        * Note: the e selection may have selected the same bit several
 467        * times. By the initialization of e_inverse, we only look
 468        * for one specific instance.
 469        */
 470       comes_from_f_bit = final_perm[bit] - 1;         /* 0..63 */
 471       comes_from_e_bit = e_inverse[comes_from_f_bit]; /* 0..95 */
 472       comes_from_word  = comes_from_e_bit / 6;        /* 0..15 */
 473       bit_within_word  = comes_from_e_bit % 6;        /* 0..5  */
 474
 475       inner_mask1 = longmask[bit_within_word + 26];
 476       inner_mask2 = longmask[o_bit];
 477
 478       for(word_value = 64; word_value--;) {
 479         if(word_value & inner_mask1)
 480           efp[comes_from_word][word_value][o_long] |= inner_mask2;
 481       }
 482     }
 483     initialized++;
 484   }
 485
 486 /*
 487  * Process the elements of the sb table permuting the
 488  * bits swapped in the expansion by the current salt.
 489  */
 490
 491 #ifdef _UFC_32_
 492 static void shuffle_sb(long32 *k, ufc_long saltbits)
 493   { ufc_long j;
 494     long32 x;
 495     for(j=4096; j--;) {
 496       x = (k[0] ^ k[1]) & (long32)saltbits;
 497       *k++ ^= x;
 498       *k++ ^= x;
 499     }
 500   }
 501 #endif
 502
 503 #ifdef _UFC_64_
 504 static void shuffle_sb(long64 *k, ufc_long saltbits)
 505   { ufc_long j;
 506     long64 x;
 507     for(j=4096; j--;) {
 508       x = ((*k >> 32) ^ *k) & (long64)saltbits;
 509       *k++ ^= (x << 32) | x;
 510     }
 511   }
 512 #endif
 513
 514 /*
 515  * Setup the unit for a new salt
 516  * Hopefully we'll not see a new salt in each crypt call.
 517  */
 518
 519 static unsigned char current_salt[3] = "&&"; /* invalid value */
 520 static ufc_long current_saltbits = 0;
 521 static int direction = 0;
 522
 523 static void setup_salt(const char *s1)
 524   { ufc_long i, j, saltbits;
 525     const unsigned char *s2 = (const unsigned char *)s1;
 526
 527     if(!initialized)
 528       ufc_init_des();
 529
 530     if(s2[0] == current_salt[0] && s2[1] == current_salt[1])
 531       return;
 532     current_salt[0] = s2[0]; current_salt[1] = s2[1];
 533
 534     /*
 535      * This is the only crypt change to DES:
 536      * entries are swapped in the expansion table
 537      * according to the bits set in the salt.
 538      */
 539     saltbits = 0;
 540     for(i = 0; i < 2; i++) {
 541       long c=ascii_to_bin(s2[i]);
 542       if(c < 0 || c > 63)
 543         c = 0;
 544       for(j = 0; j < 6; j++) {
 545         if((c >> j) & 0x1)
 546           saltbits |= BITMASK(6 * i + j);
 547       }
 548     }
 549
 550     /*
 551      * Permute the sb table values
 552      * to reflect the changed e
 553      * selection table
 554      */
 555     shuffle_sb(_ufc_sb0, current_saltbits ^ saltbits);
 556     shuffle_sb(_ufc_sb1, current_saltbits ^ saltbits);
 557     shuffle_sb(_ufc_sb2, current_saltbits ^ saltbits);
 558     shuffle_sb(_ufc_sb3, current_saltbits ^ saltbits);
 559
 560     current_saltbits = saltbits;
 561   }
 562
 563 static void ufc_mk_keytab(char *key)
 564   { ufc_long v1, v2, *k1;
 565     int i;
 566 #ifdef _UFC_32_
 567     long32 v, *k2 = &_ufc_keytab[0][0];
 568 #endif
 569 #ifdef _UFC_64_
 570     long64 v, *k2 = &_ufc_keytab[0];
 571 #endif
 572
 573     v1 = v2 = 0; k1 = &do_pc1[0][0][0];
 574     for(i = 8; i--;) {
 575       v1 |= k1[*key   & 0x7f]; k1 += 128;
 576       v2 |= k1[*key++ & 0x7f]; k1 += 128;
 577     }
 578
 579     for(i = 0; i < 16; i++) {
 580       k1 = &do_pc2[0][0];
 581
 582       v1 = (v1 << rots[i]) | (v1 >> (28 - rots[i]));
 583       v  = k1[(v1 >> 21) & 0x7f]; k1 += 128;
 584       v |= k1[(v1 >> 14) & 0x7f]; k1 += 128;
 585       v |= k1[(v1 >>  7) & 0x7f]; k1 += 128;
 586       v |= k1[(v1      ) & 0x7f]; k1 += 128;
 587
 588 #ifdef _UFC_32_
 589       *k2++ = v;
 590       v = 0;
 591 #endif
 592 #ifdef _UFC_64_
 593       v <<= 32;
 594 #endif
 595
 596       v2 = (v2 << rots[i]) | (v2 >> (28 - rots[i]));
 597       v |= k1[(v2 >> 21) & 0x7f]; k1 += 128;
 598       v |= k1[(v2 >> 14) & 0x7f]; k1 += 128;
 599       v |= k1[(v2 >>  7) & 0x7f]; k1 += 128;
 600       v |= k1[(v2      ) & 0x7f];
 601
 602       *k2++ = v;
 603     }
 604
 605     direction = 0;
 606   }
 607
 608 /*
 609  * Undo an extra E selection and do final permutations
 610  */
 611
 612 ufc_long *_ufc_dofinalperm(ufc_long l1, ufc_long l2, ufc_long r1, ufc_long r2)
 613   { ufc_long v1, v2, x;
 614     static ufc_long ary[2];
 615
 616     x = (l1 ^ l2) & current_saltbits; l1 ^= x; l2 ^= x;
 617     x = (r1 ^ r2) & current_saltbits; r1 ^= x; r2 ^= x;
 618
 619     v1=v2=0; l1 >>= 3; l2 >>= 3; r1 >>= 3; r2 >>= 3;
 620
 621     v1 |= efp[15][ r2         & 0x3f][0]; v2 |= efp[15][ r2 & 0x3f][1];
 622     v1 |= efp[14][(r2 >>= 6)  & 0x3f][0]; v2 |= efp[14][ r2 & 0x3f][1];
 623     v1 |= efp[13][(r2 >>= 10) & 0x3f][0]; v2 |= efp[13][ r2 & 0x3f][1];
 624     v1 |= efp[12][(r2 >>= 6)  & 0x3f][0]; v2 |= efp[12][ r2 & 0x3f][1];
 625
 626     v1 |= efp[11][ r1         & 0x3f][0]; v2 |= efp[11][ r1 & 0x3f][1];
 627     v1 |= efp[10][(r1 >>= 6)  & 0x3f][0]; v2 |= efp[10][ r1 & 0x3f][1];
 628     v1 |= efp[ 9][(r1 >>= 10) & 0x3f][0]; v2 |= efp[ 9][ r1 & 0x3f][1];
 629     v1 |= efp[ 8][(r1 >>= 6)  & 0x3f][0]; v2 |= efp[ 8][ r1 & 0x3f][1];
 630
 631     v1 |= efp[ 7][ l2         & 0x3f][0]; v2 |= efp[ 7][ l2 & 0x3f][1];
 632     v1 |= efp[ 6][(l2 >>= 6)  & 0x3f][0]; v2 |= efp[ 6][ l2 & 0x3f][1];
 633     v1 |= efp[ 5][(l2 >>= 10) & 0x3f][0]; v2 |= efp[ 5][ l2 & 0x3f][1];
 634     v1 |= efp[ 4][(l2 >>= 6)  & 0x3f][0]; v2 |= efp[ 4][ l2 & 0x3f][1];
 635
 636     v1 |= efp[ 3][ l1         & 0x3f][0]; v2 |= efp[ 3][ l1 & 0x3f][1];
 637     v1 |= efp[ 2][(l1 >>= 6)  & 0x3f][0]; v2 |= efp[ 2][ l1 & 0x3f][1];
 638     v1 |= efp[ 1][(l1 >>= 10) & 0x3f][0]; v2 |= efp[ 1][ l1 & 0x3f][1];
 639     v1 |= efp[ 0][(l1 >>= 6)  & 0x3f][0]; v2 |= efp[ 0][ l1 & 0x3f][1];
 640
 641     ary[0] = v1; ary[1] = v2;
 642     return ary;
 643   }
 644
 645 /*
 646  * crypt only: convert from 64 bit to 11 bit ASCII
 647  * prefixing with the salt
 648  */
 649
 650 static char *output_conversion(ufc_long v1, ufc_long v2, const char *salt)
 651   { static char outbuf[14];
 652     int i, s;
 653
 654     outbuf[0] = salt[0];
 655     outbuf[1] = salt[1] ? salt[1] : salt[0];
 656
 657     for(i = 0; i < 5; i++)
 658       outbuf[i + 2] = bin_to_ascii((v1 >> (26 - 6 * i)) & 0x3f);
 659
 660     s  = (v2 & 0xf) << 2;
 661     v2 = (v2 >> 2) | ((v1 & 0x3) << 30);
 662
 663     for(i = 5; i < 10; i++)
 664       outbuf[i + 2] = bin_to_ascii((v2 >> (56 - 6 * i)) & 0x3f);
 665
 666     outbuf[12] = bin_to_ascii(s);
 667     outbuf[13] = 0;
 668
 669     return outbuf;
 670   }
 671
 672 /*
 673  * UNIX crypt function
 674  */
 675
 676 static ufc_long *_ufc_doit(ufc_long , ufc_long, ufc_long, ufc_long, ufc_long);
 677
 678 char *ufc_crypt(const char *key,const char *salt)
 679   { ufc_long *s;
 680     char ktab[9];
 681
 682     /*
 683      * Hack DES tables according to salt
 684      */
 685     setup_salt(salt);
 686
 687     /*
 688      * Setup key schedule
 689      */
 690     clearmem(ktab, sizeof ktab);
 691     strncpy(ktab, key, 8);
 692     ufc_mk_keytab(ktab);
 693
 694     /*
 695      * Go for the 25 DES encryptions
 696      */
 697     s = _ufc_doit((ufc_long)0, (ufc_long)0,
 698                   (ufc_long)0, (ufc_long)0, (ufc_long)25);
 699
 700     /*
 701      * And convert back to 6 bit ASCII
 702      */
 703     return output_conversion(s[0], s[1], salt);
 704   }
 705
 706
 707 #ifdef _UFC_32_
 708
 709 /*
 710  * 32 bit version
 711  */
 712
 713 extern long32 _ufc_keytab[16][2];
 714 extern long32 _ufc_sb0[], _ufc_sb1[], _ufc_sb2[], _ufc_sb3[];
 715
 716 #define SBA(sb, v) (*(long32*)((char*)(sb)+(v)))
 717
 718 static ufc_long *_ufc_doit(ufc_long l1, ufc_long l2, ufc_long r1, ufc_long r2, ufc_long itr)
 719   { int i;
 720     long32 s, *k;
 721
 722     while(itr--) {
 723       k = &_ufc_keytab[0][0];
 724       for(i=8; i--; ) {
 725         s = *k++ ^ r1;
 726         l1 ^= SBA(_ufc_sb1, s & 0xffff); l2 ^= SBA(_ufc_sb1, (s & 0xffff)+4);
 727         l1 ^= SBA(_ufc_sb0, s >>= 16);   l2 ^= SBA(_ufc_sb0, (s)         +4);
 728         s = *k++ ^ r2;
 729         l1 ^= SBA(_ufc_sb3, s & 0xffff); l2 ^= SBA(_ufc_sb3, (s & 0xffff)+4);
 730         l1 ^= SBA(_ufc_sb2, s >>= 16);   l2 ^= SBA(_ufc_sb2, (s)         +4);
 731
 732         s = *k++ ^ l1;
 733         r1 ^= SBA(_ufc_sb1, s & 0xffff); r2 ^= SBA(_ufc_sb1, (s & 0xffff)+4);
 734         r1 ^= SBA(_ufc_sb0, s >>= 16);   r2 ^= SBA(_ufc_sb0, (s)         +4);
 735         s = *k++ ^ l2;
 736         r1 ^= SBA(_ufc_sb3, s & 0xffff); r2 ^= SBA(_ufc_sb3, (s & 0xffff)+4);
 737         r1 ^= SBA(_ufc_sb2, s >>= 16);   r2 ^= SBA(_ufc_sb2, (s)         +4);
 738       }
 739       s=l1; l1=r1; r1=s; s=l2; l2=r2; r2=s;
 740     }
 741     return _ufc_dofinalperm(l1, l2, r1, r2);
 742   }
 743
 744 #endif
 745
 746 #ifdef _UFC_64_
 747
 748 /*
 749  * 64 bit version
 750  */
 751
 752 extern long64 _ufc_keytab[16];
 753 extern long64 _ufc_sb0[], _ufc_sb1[], _ufc_sb2[], _ufc_sb3[];
 754
 755 #define SBA(sb, v) (*(long64*)((char*)(sb)+(v)))
 756
 757 static ufc_long *_ufc_doit(ufc_long l1, ufc_long l2, ufc_long r1, ufc_long r2, ufc_long itr)
 758   { int i;
 759     long64 l, r, s, *k;
 760
 761     l = (((long64)l1) << 32) | ((long64)l2);
 762     r = (((long64)r1) << 32) | ((long64)r2);
 763
 764     while(itr--) {
 765       k = &_ufc_keytab[0];
 766       for(i=8; i--; ) {
 767         s = *k++ ^ r;
 768         l ^= SBA(_ufc_sb3, (s >>  0) & 0xffff);
 769         l ^= SBA(_ufc_sb2, (s >> 16) & 0xffff);
 770         l ^= SBA(_ufc_sb1, (s >> 32) & 0xffff);
 771         l ^= SBA(_ufc_sb0, (s >> 48) & 0xffff);
 772
 773         s = *k++ ^ l;
 774         r ^= SBA(_ufc_sb3, (s >>  0) & 0xffff);
 775         r ^= SBA(_ufc_sb2, (s >> 16) & 0xffff);
 776         r ^= SBA(_ufc_sb1, (s >> 32) & 0xffff);
 777         r ^= SBA(_ufc_sb0, (s >> 48) & 0xffff);
 778       }
 779       s=l; l=r; r=s;
 780     }
 781
 782     l1 = l >> 32; l2 = l & 0xffffffff;
 783     r1 = r >> 32; r2 = r & 0xffffffff;
 784     return _ufc_dofinalperm(l1, l2, r1, r2);
 785   }
 786
 787 #endif
 788
 789 #define crypt ufc_crypt
 790 #endif
 791
 792 main()
 793 {
 794         char passwd[9];
 795         char salt[9];
 796         char c_out1[256];
 797         char c_out2[256];
 798
 799         char expected_out[14];
 800
 801         strcpy(expected_out, "12yJ.Of/NQ.Pk");
 802         strcpy(passwd, "12345678");
 803         strcpy(salt, "12345678");
 804
 805         strcpy(c_out1, crypt(passwd, salt));
 806         salt[2] = '\0';
 807         strcpy(c_out2, crypt(passwd, salt));
 808
 809         /*
 810          * If the non-trucated salt fails but the
 811          * truncated salt succeeds then exit 1.
 812          */
 813
 814         if((strcmp(c_out1, expected_out) != 0) &&
 815                 (strcmp(c_out2, expected_out) == 0))
 816                 exit(1);
 817
 818 #ifdef HAVE_BIGCRYPT
 819         /*
 820          * Try the same with bigcrypt...
 821          */
 822
 823         {
 824                 char big_passwd[17];
 825                 char big_salt[17];
 826                 char big_c_out1[256];
 827                 char big_c_out2[256];
 828                 char big_expected_out[27];
 829
 830                 strcpy(big_passwd, "1234567812345678");
 831                 strcpy(big_salt, "1234567812345678");
 832                 strcpy(big_expected_out, "12yJ.Of/NQ.PklfyCuHi/rwM");
 833
 834                 strcpy(big_c_out1, bigcrypt(big_passwd, big_salt));
 835                 big_salt[2] = '\0';
 836                 strcpy(big_c_out2, bigcrypt(big_passwd, big_salt));
 837
 838                 /*
 839                  * If the non-trucated salt fails but the
 840                  * truncated salt succeeds then exit 1.
 841                  */
 842
 843                 if((strcmp(big_c_out1, big_expected_out) != 0) &&
 844                         (strcmp(big_c_out2, big_expected_out) == 0))
 845                         exit(1);
 846
 847         }
 848 #endif
 849
 850         exit(0);
 851 }