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