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