crypt/crypt_util.c

   1 /*
   2  * UFC-crypt: ultra fast crypt(3) implementation
   3  *
   4  * Copyright (C) 1991, 92, 93, 96, 97, 98, 2000 Free Software Foundation, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; see the file COPYING.LIB.  If not,
  18  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * @(#)crypt_util.c     2.56 12/20/96
  22  *
  23  * Support routines
  24  *
  25  */
  26
  27 #ifdef DEBUG
  28 #include <stdio.h>
  29 #endif
  30 #include <string.h>
  31
  32 #ifndef STATIC
  33 #define STATIC static
  34 #endif
  35
  36 #ifndef DOS
  37 #include "ufc-crypt.h"
  38 #else
  39 /*
  40  * Thanks to greg%wind@plains.NoDak.edu (Greg W. Wettstein)
  41  * for DOS patches
  42  */
  43 #include "pl.h"
  44 #include "ufc.h"
  45 #endif
  46 #include "crypt.h"
  47 #include "crypt-private.h"
  48
  49 /* Prototypes for local functions.  */
  50 #if __STDC__ - 0
  51 #ifndef __GNU_LIBRARY__
  52 void _ufc_clearmem (char *start, int cnt);
  53 void _ufc_copymem (char *from, char *to, int cnt);
  54 #endif
  55 #ifdef _UFC_32_
  56 STATIC void shuffle_sb (long32 *k, ufc_long saltbits);
  57 #else
  58 STATIC void shuffle_sb (long64 *k, ufc_long saltbits);
  59 #endif
  60 #endif
  61
  62
  63 /*
  64  * Permutation done once on the 56 bit
  65  *  key derived from the original 8 byte ASCII key.
  66  */
  67 static const int pc1[56] = {
  68   57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
  69   10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
  70   63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
  71   14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
  72 };
  73
  74 /*
  75  * How much to rotate each 28 bit half of the pc1 permutated
  76  *  56 bit key before using pc2 to give the i' key
  77  */
  78 static const int rots[16] = {
  79   1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
  80 };
  81
  82 /*
  83  * Permutation giving the key
  84  * of the i' DES round
  85  */
  86 static const int pc2[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  * The E expansion table which selects
  95  * bits from the 32 bit intermediate result.
  96  */
  97 static const int esel[48] = {
  98   32,  1,  2,  3,  4,  5,  4,  5,  6,  7,  8,  9,
  99    8,  9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
 100   16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
 101   24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32,  1
 102 };
 103
 104 /*
 105  * Permutation done on the
 106  * result of sbox lookups
 107  */
 108 static const int perm32[32] = {
 109   16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
 110   2,   8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
 111 };
 112
 113 /*
 114  * The sboxes
 115  */
 116 static const int sbox[8][4][16]= {
 117         { { 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7 },
 118           {  0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8 },
 119           {  4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0 },
 120           { 15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13 }
 121         },
 122
 123         { { 15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10 },
 124           {  3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5 },
 125           {  0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15 },
 126           { 13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9 }
 127         },
 128
 129         { { 10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8 },
 130           { 13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1 },
 131           { 13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7 },
 132           {  1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12 }
 133         },
 134
 135         { {  7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15 },
 136           { 13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9 },
 137           { 10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4 },
 138           {  3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14 }
 139         },
 140
 141         { {  2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9 },
 142           { 14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6 },
 143           {  4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14 },
 144           { 11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3 }
 145         },
 146
 147         { { 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11 },
 148           { 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8 },
 149           {  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6 },
 150           {  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13 }
 151         },
 152
 153         { {  4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1 },
 154           { 13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6 },
 155           {  1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2 },
 156           {  6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12 }
 157         },
 158
 159         { { 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7 },
 160           {  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2 },
 161           {  7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8 },
 162           {  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11 }
 163         }
 164 };
 165
 166 /*
 167  * This is the initial
 168  * permutation matrix
 169  */
 170 static const int initial_perm[64] = {
 171   58, 50, 42, 34, 26, 18, 10,  2, 60, 52, 44, 36, 28, 20, 12, 4,
 172   62, 54, 46, 38, 30, 22, 14,  6, 64, 56, 48, 40, 32, 24, 16, 8,
 173   57, 49, 41, 33, 25, 17,  9,  1, 59, 51, 43, 35, 27, 19, 11, 3,
 174   61, 53, 45, 37, 29, 21, 13,  5, 63, 55, 47, 39, 31, 23, 15, 7
 175 };
 176
 177 /*
 178  * This is the final
 179  * permutation matrix
 180  */
 181 static const int final_perm[64] = {
 182   40,  8, 48, 16, 56, 24, 64, 32, 39,  7, 47, 15, 55, 23, 63, 31,
 183   38,  6, 46, 14, 54, 22, 62, 30, 37,  5, 45, 13, 53, 21, 61, 29,
 184   36,  4, 44, 12, 52, 20, 60, 28, 35,  3, 43, 11, 51, 19, 59, 27,
 185   34,  2, 42, 10, 50, 18, 58, 26, 33,  1, 41,  9, 49, 17, 57, 25
 186 };
 187
 188 #define ascii_to_bin(c) ((c)>='a'?(c-59):(c)>='A'?((c)-53):(c)-'.')
 189 #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
 190
 191 static const ufc_long BITMASK[24] = {
 192   0x40000000, 0x20000000, 0x10000000, 0x08000000, 0x04000000, 0x02000000,
 193   0x01000000, 0x00800000, 0x00400000, 0x00200000, 0x00100000, 0x00080000,
 194   0x00004000, 0x00002000, 0x00001000, 0x00000800, 0x00000400, 0x00000200,
 195   0x00000100, 0x00000080, 0x00000040, 0x00000020, 0x00000010, 0x00000008
 196 };
 197
 198 static const unsigned char bytemask[8]  = {
 199   0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
 200 };
 201
 202 static const ufc_long longmask[32] = {
 203   0x80000000, 0x40000000, 0x20000000, 0x10000000,
 204   0x08000000, 0x04000000, 0x02000000, 0x01000000,
 205   0x00800000, 0x00400000, 0x00200000, 0x00100000,
 206   0x00080000, 0x00040000, 0x00020000, 0x00010000,
 207   0x00008000, 0x00004000, 0x00002000, 0x00001000,
 208   0x00000800, 0x00000400, 0x00000200, 0x00000100,
 209   0x00000080, 0x00000040, 0x00000020, 0x00000010,
 210   0x00000008, 0x00000004, 0x00000002, 0x00000001
 211 };
 212
 213 /*
 214  * do_pc1: permform pc1 permutation in the key schedule generation.
 215  *
 216  * The first   index is the byte number in the 8 byte ASCII key
 217  *  -  second    -      -    the two 28 bits halfs of the result
 218  *  -  third     -   selects the 7 bits actually used of each byte
 219  *
 220  * The result is kept with 28 bit per 32 bit with the 4 most significant
 221  * bits zero.
 222  */
 223 static ufc_long do_pc1[8][2][128];
 224
 225 /*
 226  * do_pc2: permform pc2 permutation in the key schedule generation.
 227  *
 228  * The first   index is the septet number in the two 28 bit intermediate values
 229  *  -  second    -    -  -  septet values
 230  *
 231  * Knowledge of the structure of the pc2 permutation is used.
 232  *
 233  * The result is kept with 28 bit per 32 bit with the 4 most significant
 234  * bits zero.
 235  */
 236 static ufc_long do_pc2[8][128];
 237
 238 /*
 239  * eperm32tab: do 32 bit permutation and E selection
 240  *
 241  * The first index is the byte number in the 32 bit value to be permuted
 242  *  -  second  -   is the value of this byte
 243  *  -  third   -   selects the two 32 bit values
 244  *
 245  * The table is used and generated internally in init_des to speed it up
 246  */
 247 static ufc_long eperm32tab[4][256][2];
 248
 249 /*
 250  * efp: undo an extra e selection and do final
 251  *      permutation giving the DES result.
 252  *
 253  *      Invoked 6 bit a time on two 48 bit values
 254  *      giving two 32 bit longs.
 255  */
 256 static ufc_long efp[16][64][2];
 257
 258 /*
 259  * For use by the old, non-reentrant routines
 260  * (crypt/encrypt/setkey)
 261  */
 262 struct crypt_data _ufc_foobar;
 263
 264 #ifdef __GNU_LIBRARY__
 265 #include <bits/libc-lock.h>
 266
 267 __libc_lock_define_initialized (static, _ufc_tables_lock)
 268 #endif
 269
 270 #ifdef DEBUG
 271
 272 void
 273 _ufc_prbits(a, n)
 274      ufc_long *a;
 275      int n;
 276 {
 277   ufc_long i, j, t, tmp;
 278   n /= 8;
 279   for(i = 0; i < n; i++) {
 280     tmp=0;
 281     for(j = 0; j < 8; j++) {
 282       t=8*i+j;
 283       tmp|=(a[t/24] & BITMASK[t % 24])?bytemask[j]:0;
 284     }
 285     (void)printf("%02x ",tmp);
 286   }
 287   printf(" ");
 288 }
 289
 290 static void
 291 _ufc_set_bits(v, b)
 292      ufc_long v;
 293      ufc_long *b;
 294 {
 295   ufc_long i;
 296   *b = 0;
 297   for(i = 0; i < 24; i++) {
 298     if(v & longmask[8 + i])
 299       *b |= BITMASK[i];
 300   }
 301 }
 302
 303 #endif
 304
 305 #ifndef __GNU_LIBRARY__
 306 /*
 307  * Silly rewrites of 'bzero'/'memset'. I do so
 308  * because some machines don't have
 309  * bzero and some don't have memset.
 310  */
 311
 312 void
 313 _ufc_clearmem(start, cnt)
 314      char *start;
 315      int cnt;
 316 {
 317   while(cnt--)
 318     *start++ = '\0';
 319 }
 320
 321 void
 322 _ufc_copymem(from, to, cnt)
 323      char *from, *to;
 324      int cnt;
 325 {
 326   while(cnt--)
 327     *to++ = *from++;
 328 }
 329 #else
 330 #define _ufc_clearmem(start, cnt)   memset(start, 0, cnt)
 331 #define _ufc_copymem(from, to, cnt) memcpy(to, from, cnt)
 332 #endif
 333
 334 /* lookup a 6 bit value in sbox */
 335
 336 #define s_lookup(i,s) sbox[(i)][(((s)>>4) & 0x2)|((s) & 0x1)][((s)>>1) & 0xf];
 337
 338 /*
 339  * Initialize unit - may be invoked directly
 340  * by fcrypt users.
 341  */
 342
 343 void
 344 __init_des_r(__data)
 345      struct crypt_data * __restrict __data;
 346 {
 347   int comes_from_bit;
 348   int bit, sg;
 349   ufc_long j;
 350   ufc_long mask1, mask2;
 351   int e_inverse[64];
 352   static volatile int small_tables_initialized = 0;
 353
 354 #ifdef _UFC_32_
 355   long32 *sb[4];
 356   sb[0] = (long32*)__data->sb0; sb[1] = (long32*)__data->sb1;
 357   sb[2] = (long32*)__data->sb2; sb[3] = (long32*)__data->sb3;
 358 #endif
 359 #ifdef _UFC_64_
 360   long64 *sb[4];
 361   sb[0] = (long64*)__data->sb0; sb[1] = (long64*)__data->sb1;
 362   sb[2] = (long64*)__data->sb2; sb[3] = (long64*)__data->sb3;
 363 #endif
 364
 365   if(small_tables_initialized == 0) {
 366 #ifdef __GNU_LIBRARY__
 367     __libc_lock_lock (_ufc_tables_lock);
 368     if(small_tables_initialized)
 369       goto small_tables_done;
 370 #endif
 371
 372     /*
 373      * Create the do_pc1 table used
 374      * to affect pc1 permutation
 375      * when generating keys
 376      */
 377     _ufc_clearmem((char*)do_pc1, (int)sizeof(do_pc1));
 378     for(bit = 0; bit < 56; bit++) {
 379       comes_from_bit  = pc1[bit] - 1;
 380       mask1 = bytemask[comes_from_bit % 8 + 1];
 381       mask2 = longmask[bit % 28 + 4];
 382       for(j = 0; j < 128; j++) {
 383         if(j & mask1)
 384           do_pc1[comes_from_bit / 8][bit / 28][j] |= mask2;
 385       }
 386     }
 387
 388     /*
 389      * Create the do_pc2 table used
 390      * to affect pc2 permutation when
 391      * generating keys
 392      */
 393     _ufc_clearmem((char*)do_pc2, (int)sizeof(do_pc2));
 394     for(bit = 0; bit < 48; bit++) {
 395       comes_from_bit  = pc2[bit] - 1;
 396       mask1 = bytemask[comes_from_bit % 7 + 1];
 397       mask2 = BITMASK[bit % 24];
 398       for(j = 0; j < 128; j++) {
 399         if(j & mask1)
 400           do_pc2[comes_from_bit / 7][j] |= mask2;
 401       }
 402     }
 403
 404     /*
 405      * Now generate the table used to do combined
 406      * 32 bit permutation and e expansion
 407      *
 408      * We use it because we have to permute 16384 32 bit
 409      * longs into 48 bit in order to initialize sb.
 410      *
 411      * Looping 48 rounds per permutation becomes
 412      * just too slow...
 413      *
 414      */
 415
 416     _ufc_clearmem((char*)eperm32tab, (int)sizeof(eperm32tab));
 417     for(bit = 0; bit < 48; bit++) {
 418       ufc_long mask1,comes_from;
 419       comes_from = perm32[esel[bit]-1]-1;
 420       mask1      = bytemask[comes_from % 8];
 421       for(j = 256; j--;) {
 422         if(j & mask1)
 423           eperm32tab[comes_from / 8][j][bit / 24] |= BITMASK[bit % 24];
 424       }
 425     }
 426
 427     /*
 428      * Create an inverse matrix for esel telling
 429      * where to plug out bits if undoing it
 430      */
 431     for(bit=48; bit--;) {
 432       e_inverse[esel[bit] - 1     ] = bit;
 433       e_inverse[esel[bit] - 1 + 32] = bit + 48;
 434     }
 435
 436     /*
 437      * create efp: the matrix used to
 438      * undo the E expansion and effect final permutation
 439      */
 440     _ufc_clearmem((char*)efp, (int)sizeof efp);
 441     for(bit = 0; bit < 64; bit++) {
 442       int o_bit, o_long;
 443       ufc_long word_value, mask1, mask2;
 444       int comes_from_f_bit, comes_from_e_bit;
 445       int comes_from_word, bit_within_word;
 446
 447       /* See where bit i belongs in the two 32 bit long's */
 448       o_long = bit / 32; /* 0..1  */
 449       o_bit  = bit % 32; /* 0..31 */
 450
 451       /*
 452        * And find a bit in the e permutated value setting this bit.
 453        *
 454        * Note: the e selection may have selected the same bit several
 455        * times. By the initialization of e_inverse, we only look
 456        * for one specific instance.
 457        */
 458       comes_from_f_bit = final_perm[bit] - 1;         /* 0..63 */
 459       comes_from_e_bit = e_inverse[comes_from_f_bit]; /* 0..95 */
 460       comes_from_word  = comes_from_e_bit / 6;        /* 0..15 */
 461       bit_within_word  = comes_from_e_bit % 6;        /* 0..5  */
 462
 463       mask1 = longmask[bit_within_word + 26];
 464       mask2 = longmask[o_bit];
 465
 466       for(word_value = 64; word_value--;) {
 467         if(word_value & mask1)
 468           efp[comes_from_word][word_value][o_long] |= mask2;
 469       }
 470     }
 471     small_tables_initialized = 1;
 472 #ifdef __GNU_LIBRARY__
 473 small_tables_done:
 474     __libc_lock_unlock(_ufc_tables_lock);
 475 #endif
 476   }
 477
 478   /*
 479    * Create the sb tables:
 480    *
 481    * For each 12 bit segment of an 48 bit intermediate
 482    * result, the sb table precomputes the two 4 bit
 483    * values of the sbox lookups done with the two 6
 484    * bit halves, shifts them to their proper place,
 485    * sends them through perm32 and finally E expands
 486    * them so that they are ready for the next
 487    * DES round.
 488    *
 489    */
 490
 491   _ufc_clearmem((char*)__data->sb0, (int)sizeof(__data->sb0));
 492   _ufc_clearmem((char*)__data->sb1, (int)sizeof(__data->sb1));
 493   _ufc_clearmem((char*)__data->sb2, (int)sizeof(__data->sb2));
 494   _ufc_clearmem((char*)__data->sb3, (int)sizeof(__data->sb3));
 495
 496   for(sg = 0; sg < 4; sg++) {
 497     int j1, j2;
 498     int s1, s2;
 499
 500     for(j1 = 0; j1 < 64; j1++) {
 501       s1 = s_lookup(2 * sg, j1);
 502       for(j2 = 0; j2 < 64; j2++) {
 503         ufc_long to_permute, inx;
 504
 505         s2         = s_lookup(2 * sg + 1, j2);
 506         to_permute = (((ufc_long)s1 << 4)  |
 507                       (ufc_long)s2) << (24 - 8 * (ufc_long)sg);
 508
 509 #ifdef _UFC_32_
 510         inx = ((j1 << 6)  | j2) << 1;
 511         sb[sg][inx  ]  = eperm32tab[0][(to_permute >> 24) & 0xff][0];
 512         sb[sg][inx+1]  = eperm32tab[0][(to_permute >> 24) & 0xff][1];
 513         sb[sg][inx  ] |= eperm32tab[1][(to_permute >> 16) & 0xff][0];
 514         sb[sg][inx+1] |= eperm32tab[1][(to_permute >> 16) & 0xff][1];
 515         sb[sg][inx  ] |= eperm32tab[2][(to_permute >>  8) & 0xff][0];
 516         sb[sg][inx+1] |= eperm32tab[2][(to_permute >>  8) & 0xff][1];
 517         sb[sg][inx  ] |= eperm32tab[3][(to_permute)       & 0xff][0];
 518         sb[sg][inx+1] |= eperm32tab[3][(to_permute)       & 0xff][1];
 519 #endif
 520 #ifdef _UFC_64_
 521         inx = ((j1 << 6)  | j2);
 522         sb[sg][inx]  =
 523           ((long64)eperm32tab[0][(to_permute >> 24) & 0xff][0] << 32) |
 524            (long64)eperm32tab[0][(to_permute >> 24) & 0xff][1];
 525         sb[sg][inx] |=
 526           ((long64)eperm32tab[1][(to_permute >> 16) & 0xff][0] << 32) |
 527            (long64)eperm32tab[1][(to_permute >> 16) & 0xff][1];
 528         sb[sg][inx] |=
 529           ((long64)eperm32tab[2][(to_permute >>  8) & 0xff][0] << 32) |
 530            (long64)eperm32tab[2][(to_permute >>  8) & 0xff][1];
 531         sb[sg][inx] |=
 532           ((long64)eperm32tab[3][(to_permute)       & 0xff][0] << 32) |
 533            (long64)eperm32tab[3][(to_permute)       & 0xff][1];
 534 #endif
 535       }
 536     }
 537   }
 538
 539   __data->initialized++;
 540 }
 541
 542 void
 543 __init_des()
 544 {
 545   __init_des_r(&_ufc_foobar);
 546 }
 547
 548 /*
 549  * Process the elements of the sb table permuting the
 550  * bits swapped in the expansion by the current salt.
 551  */
 552
 553 #ifdef _UFC_32_
 554 STATIC void
 555 shuffle_sb(k, saltbits)
 556      long32 *k;
 557      ufc_long saltbits;
 558 {
 559   ufc_long j;
 560   long32 x;
 561   for(j=4096; j--;) {
 562     x = (k[0] ^ k[1]) & (long32)saltbits;
 563     *k++ ^= x;
 564     *k++ ^= x;
 565   }
 566 }
 567 #endif
 568
 569 #ifdef _UFC_64_
 570 STATIC void
 571 shuffle_sb(k, saltbits)
 572      long64 *k;
 573      ufc_long saltbits;
 574 {
 575   ufc_long j;
 576   long64 x;
 577   for(j=4096; j--;) {
 578     x = ((*k >> 32) ^ *k) & (long64)saltbits;
 579     *k++ ^= (x << 32) | x;
 580   }
 581 }
 582 #endif
 583
 584 /*
 585  * Setup the unit for a new salt
 586  * Hopefully we'll not see a new salt in each crypt call.
 587  */
 588
 589 void
 590 _ufc_setup_salt_r(s, __data)
 591      __const char *s;
 592      struct crypt_data * __restrict __data;
 593 {
 594   ufc_long i, j, saltbits;
 595
 596   if(__data->initialized == 0)
 597     __init_des_r(__data);
 598
 599   if(s[0] == __data->current_salt[0] && s[1] == __data->current_salt[1])
 600     return;
 601   __data->current_salt[0] = s[0]; __data->current_salt[1] = s[1];
 602
 603   /*
 604    * This is the only crypt change to DES:
 605    * entries are swapped in the expansion table
 606    * according to the bits set in the salt.
 607    */
 608   saltbits = 0;
 609   for(i = 0; i < 2; i++) {
 610     long c=ascii_to_bin(s[i]);
 611     for(j = 0; j < 6; j++) {
 612       if((c >> j) & 0x1)
 613         saltbits |= BITMASK[6 * i + j];
 614     }
 615   }
 616
 617   /*
 618    * Permute the sb table values
 619    * to reflect the changed e
 620    * selection table
 621    */
 622 #ifdef _UFC_32_
 623 #define LONGG long32*
 624 #endif
 625 #ifdef _UFC_64_
 626 #define LONGG long64*
 627 #endif
 628
 629   shuffle_sb((LONGG)__data->sb0, __data->current_saltbits ^ saltbits);
 630   shuffle_sb((LONGG)__data->sb1, __data->current_saltbits ^ saltbits);
 631   shuffle_sb((LONGG)__data->sb2, __data->current_saltbits ^ saltbits);
 632   shuffle_sb((LONGG)__data->sb3, __data->current_saltbits ^ saltbits);
 633
 634   __data->current_saltbits = saltbits;
 635 }
 636
 637 void
 638 _ufc_mk_keytab_r(key, __data)
 639      const char *key;
 640      struct crypt_data * __restrict __data;
 641 {
 642   ufc_long v1, v2, *k1;
 643   int i;
 644 #ifdef _UFC_32_
 645   long32 v, *k2;
 646   k2 = (long32*)__data->keysched;
 647 #endif
 648 #ifdef _UFC_64_
 649   long64 v, *k2;
 650   k2 = (long64*)__data->keysched;
 651 #endif
 652
 653   v1 = v2 = 0; k1 = &do_pc1[0][0][0];
 654   for(i = 8; i--;) {
 655     v1 |= k1[*key   & 0x7f]; k1 += 128;
 656     v2 |= k1[*key++ & 0x7f]; k1 += 128;
 657   }
 658
 659   for(i = 0; i < 16; i++) {
 660     k1 = &do_pc2[0][0];
 661
 662     v1 = (v1 << rots[i]) | (v1 >> (28 - rots[i]));
 663     v  = k1[(v1 >> 21) & 0x7f]; k1 += 128;
 664     v |= k1[(v1 >> 14) & 0x7f]; k1 += 128;
 665     v |= k1[(v1 >>  7) & 0x7f]; k1 += 128;
 666     v |= k1[(v1      ) & 0x7f]; k1 += 128;
 667
 668 #ifdef _UFC_32_
 669     *k2++ = (v | 0x00008000);
 670     v = 0;
 671 #endif
 672 #ifdef _UFC_64_
 673     v = (v << 32);
 674 #endif
 675
 676     v2 = (v2 << rots[i]) | (v2 >> (28 - rots[i]));
 677     v |= k1[(v2 >> 21) & 0x7f]; k1 += 128;
 678     v |= k1[(v2 >> 14) & 0x7f]; k1 += 128;
 679     v |= k1[(v2 >>  7) & 0x7f]; k1 += 128;
 680     v |= k1[(v2      ) & 0x7f];
 681
 682 #ifdef _UFC_32_
 683     *k2++ = (v | 0x00008000);
 684 #endif
 685 #ifdef _UFC_64_
 686     *k2++ = v | 0x0000800000008000l;
 687 #endif
 688   }
 689
 690   __data->direction = 0;
 691 }
 692
 693 /*
 694  * Undo an extra E selection and do final permutations
 695  */
 696
 697 void
 698 _ufc_dofinalperm_r(res, __data)
 699      ufc_long *res;
 700      struct crypt_data * __restrict __data;
 701 {
 702   ufc_long v1, v2, x;
 703   ufc_long l1,l2,r1,r2;
 704
 705   l1 = res[0]; l2 = res[1];
 706   r1 = res[2]; r2 = res[3];
 707
 708   x = (l1 ^ l2) & __data->current_saltbits; l1 ^= x; l2 ^= x;
 709   x = (r1 ^ r2) & __data->current_saltbits; r1 ^= x; r2 ^= x;
 710
 711   v1=v2=0; l1 >>= 3; l2 >>= 3; r1 >>= 3; r2 >>= 3;
 712
 713   v1 |= efp[15][ r2         & 0x3f][0]; v2 |= efp[15][ r2 & 0x3f][1];
 714   v1 |= efp[14][(r2 >>= 6)  & 0x3f][0]; v2 |= efp[14][ r2 & 0x3f][1];
 715   v1 |= efp[13][(r2 >>= 10) & 0x3f][0]; v2 |= efp[13][ r2 & 0x3f][1];
 716   v1 |= efp[12][(r2 >>= 6)  & 0x3f][0]; v2 |= efp[12][ r2 & 0x3f][1];
 717
 718   v1 |= efp[11][ r1         & 0x3f][0]; v2 |= efp[11][ r1 & 0x3f][1];
 719   v1 |= efp[10][(r1 >>= 6)  & 0x3f][0]; v2 |= efp[10][ r1 & 0x3f][1];
 720   v1 |= efp[ 9][(r1 >>= 10) & 0x3f][0]; v2 |= efp[ 9][ r1 & 0x3f][1];
 721   v1 |= efp[ 8][(r1 >>= 6)  & 0x3f][0]; v2 |= efp[ 8][ r1 & 0x3f][1];
 722
 723   v1 |= efp[ 7][ l2         & 0x3f][0]; v2 |= efp[ 7][ l2 & 0x3f][1];
 724   v1 |= efp[ 6][(l2 >>= 6)  & 0x3f][0]; v2 |= efp[ 6][ l2 & 0x3f][1];
 725   v1 |= efp[ 5][(l2 >>= 10) & 0x3f][0]; v2 |= efp[ 5][ l2 & 0x3f][1];
 726   v1 |= efp[ 4][(l2 >>= 6)  & 0x3f][0]; v2 |= efp[ 4][ l2 & 0x3f][1];
 727
 728   v1 |= efp[ 3][ l1         & 0x3f][0]; v2 |= efp[ 3][ l1 & 0x3f][1];
 729   v1 |= efp[ 2][(l1 >>= 6)  & 0x3f][0]; v2 |= efp[ 2][ l1 & 0x3f][1];
 730   v1 |= efp[ 1][(l1 >>= 10) & 0x3f][0]; v2 |= efp[ 1][ l1 & 0x3f][1];
 731   v1 |= efp[ 0][(l1 >>= 6)  & 0x3f][0]; v2 |= efp[ 0][ l1 & 0x3f][1];
 732
 733   res[0] = v1; res[1] = v2;
 734 }
 735
 736 /*
 737  * crypt only: convert from 64 bit to 11 bit ASCII
 738  * prefixing with the salt
 739  */
 740
 741 void
 742 _ufc_output_conversion_r(v1, v2, salt, __data)
 743      ufc_long v1, v2;
 744      __const char *salt;
 745      struct crypt_data * __restrict __data;
 746 {
 747   int i, s, shf;
 748
 749   __data->crypt_3_buf[0] = salt[0];
 750   __data->crypt_3_buf[1] = salt[1] ? salt[1] : salt[0];
 751
 752   for(i = 0; i < 5; i++) {
 753     shf = (26 - 6 * i); /* to cope with MSC compiler bug */
 754     __data->crypt_3_buf[i + 2] = bin_to_ascii((v1 >> shf) & 0x3f);
 755   }
 756
 757   s  = (v2 & 0xf) << 2;
 758   v2 = (v2 >> 2) | ((v1 & 0x3) << 30);
 759
 760   for(i = 5; i < 10; i++) {
 761     shf = (56 - 6 * i);
 762     __data->crypt_3_buf[i + 2] = bin_to_ascii((v2 >> shf) & 0x3f);
 763   }
 764
 765   __data->crypt_3_buf[12] = bin_to_ascii(s);
 766   __data->crypt_3_buf[13] = 0;
 767 }
 768
 769
 770 /*
 771  * UNIX encrypt function. Takes a bitvector
 772  * represented by one byte per bit and
 773  * encrypt/decrypt according to edflag
 774  */
 775
 776 void
 777 __encrypt_r(__block, __edflag, __data)
 778      char *__block;
 779      int __edflag;
 780      struct crypt_data * __restrict __data;
 781 {
 782   ufc_long l1, l2, r1, r2, res[4];
 783   int i;
 784 #ifdef _UFC_32_
 785   long32 *kt;
 786   kt = (long32*)__data->keysched;
 787 #endif
 788 #ifdef _UFC_64_
 789   long64 *kt;
 790   kt = (long64*)__data->keysched;
 791 #endif
 792
 793   /*
 794    * Undo any salt changes to E expansion
 795    */
 796   _ufc_setup_salt_r("..", __data);
 797
 798   /*
 799    * Reverse key table if
 800    * changing operation (encrypt/decrypt)
 801    */
 802   if((__edflag == 0) != (__data->direction == 0)) {
 803     for(i = 0; i < 8; i++) {
 804 #ifdef _UFC_32_
 805       long32 x;
 806       x = kt[2 * (15-i)];
 807       kt[2 * (15-i)] = kt[2 * i];
 808       kt[2 * i] = x;
 809
 810       x = kt[2 * (15-i) + 1];
 811       kt[2 * (15-i) + 1] = kt[2 * i + 1];
 812       kt[2 * i + 1] = x;
 813 #endif
 814 #ifdef _UFC_64_
 815       long64 x;
 816       x = kt[15-i];
 817       kt[15-i] = kt[i];
 818       kt[i] = x;
 819 #endif
 820       }
 821     __data->direction = __edflag;
 822   }
 823
 824   /*
 825    * Do initial permutation + E expansion
 826    */
 827   i = 0;
 828   for(l1 = 0; i < 24; i++) {
 829     if(__block[initial_perm[esel[i]-1]-1])
 830       l1 |= BITMASK[i];
 831   }
 832   for(l2 = 0; i < 48; i++) {
 833     if(__block[initial_perm[esel[i]-1]-1])
 834       l2 |= BITMASK[i-24];
 835   }
 836
 837   i = 0;
 838   for(r1 = 0; i < 24; i++) {
 839     if(__block[initial_perm[esel[i]-1+32]-1])
 840       r1 |= BITMASK[i];
 841   }
 842   for(r2 = 0; i < 48; i++) {
 843     if(__block[initial_perm[esel[i]-1+32]-1])
 844       r2 |= BITMASK[i-24];
 845   }
 846
 847   /*
 848    * Do DES inner loops + final conversion
 849    */
 850   res[0] = l1; res[1] = l2;
 851   res[2] = r1; res[3] = r2;
 852   _ufc_doit_r((ufc_long)1, __data, &res[0]);
 853
 854   /*
 855    * Do final permutations
 856    */
 857   _ufc_dofinalperm_r(res, __data);
 858
 859   /*
 860    * And convert to bit array
 861    */
 862   l1 = res[0]; r1 = res[1];
 863   for(i = 0; i < 32; i++) {
 864     *__block++ = (l1 & longmask[i]) != 0;
 865   }
 866   for(i = 0; i < 32; i++) {
 867     *__block++ = (r1 & longmask[i]) != 0;
 868   }
 869 }
 870 weak_alias (__encrypt_r, encrypt_r)
 871
 872 void
 873 encrypt(__block, __edflag)
 874      char *__block;
 875      int __edflag;
 876 {
 877   __encrypt_r(__block, __edflag, &_ufc_foobar);
 878 }
 879
 880
 881 /*
 882  * UNIX setkey function. Take a 64 bit DES
 883  * key and setup the machinery.
 884  */
 885
 886 void
 887 __setkey_r(__key, __data)
 888      __const char *__key;
 889      struct crypt_data * __restrict __data;
 890 {
 891   int i,j;
 892   unsigned char c;
 893   unsigned char ktab[8];
 894
 895   _ufc_setup_salt_r("..", __data); /* be sure we're initialized */
 896
 897   for(i = 0; i < 8; i++) {
 898     for(j = 0, c = 0; j < 8; j++)
 899       c = c << 1 | *__key++;
 900     ktab[i] = c >> 1;
 901   }
 902   _ufc_mk_keytab_r(ktab, __data);
 903 }
 904 weak_alias (__setkey_r, setkey_r)
 905
 906 void
 907 setkey(__key)
 908      __const char *__key;
 909 {
 910   __setkey_r(__key, &_ufc_foobar);
 911 }