home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume23 / ufc-crypt / part01 / crypt_util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-21  |  17.9 KB  |  566 lines
  1. /*
  2.  * UFC-crypt: ultra fast crypt(3) implementation
  3.  *
  4.  * Copyright (C) 1991, Michael Glad, email: glad@daimi.aau.dk
  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; if not, write to the Free
  18.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * @(#)crypt_util.c    2.2 10/04/91
  21.  *
  22.  * Support routines
  23.  *
  24.  */
  25.  
  26. #ifdef DEBUG
  27. #include <stdio.h>
  28. #endif
  29.  
  30. #include "patchlevel.h"
  31.  
  32. #ifdef SYSV
  33. #define bzero(addr, cnt)     memset(addr, 0, cnt)
  34. #define bcopy(from, to, len) memcpy(to, from, len)
  35. #endif
  36.  
  37. /* Permutation done once on the 56 bit 
  38.    key derived from the original 8 byte ASCII key.
  39. */
  40. static unsigned long pc1[56] =
  41.   { 57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
  42.     10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
  43.     63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
  44.     14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
  45.   };
  46.  
  47. /* How much to rotate each 28 bit half of the pc1 permutated
  48.    56 bit key before using pc2 to give the i' key
  49. */
  50. static unsigned long totrot[16] =
  51.   { 1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28 };
  52.  
  53. /* Permutation giving the key of the i' DES round */
  54. static unsigned long pc2[48] =
  55.   { 14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
  56.     23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
  57.     41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
  58.     44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
  59.   };
  60.  
  61. /* Reference copy of the expansion table which selects
  62.    bits from the 32 bit intermediate result.
  63. */
  64. static unsigned long eref[48] =
  65.   { 32,  1,  2,  3,  4,  5,  4,  5,  6,  7,  8,  9,
  66.      8,  9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
  67.     16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
  68.     24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32,  1
  69.   };
  70. static unsigned long disturbed_e[48];
  71. static unsigned long e_inverse[64];
  72.  
  73. /* Permutation done on the result of sbox lookups */
  74. static unsigned long perm32[32] = 
  75.   { 16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
  76.      2,  8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
  77.   };
  78.  
  79. /* The sboxes */
  80. static unsigned long sbox[8][4][16]=
  81.       { { { 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7 },
  82.           {  0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8 },
  83.           {  4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0 },
  84.           { 15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13 }
  85.         },
  86.  
  87.         { { 15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10 },
  88.           {  3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5 },
  89.           {  0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15 },
  90.           { 13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9 }
  91.         },
  92.  
  93.         { { 10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8 },
  94.           { 13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1 },
  95.           { 13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7 },
  96.           {  1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12 }
  97.         },
  98.  
  99.         { {  7,  13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15 },
  100.           { 13,  8,  11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9 },
  101.           { 10,  6,   9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4 },
  102.           {  3, 15,   0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14 }
  103.         },
  104.  
  105.         { {  2, 12,   4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9 },
  106.           { 14, 11,   2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6 },
  107.           {  4,  2,   1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14 },
  108.           { 11,  8,  12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3 }
  109.         },
  110.  
  111.         { { 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11 },
  112.           { 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8 },
  113.           {  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6 },
  114.           {  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13 }
  115.         },
  116.  
  117.         { {  4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1 },
  118.           { 13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6 },
  119.           {  1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2 },
  120.           {  6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12 }
  121.         },
  122.  
  123.         { { 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7 },
  124.           {  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2 },
  125.           {  7, 11, 4,   1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8 },
  126.           {  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11 }
  127.         }
  128.       };
  129.  
  130. #ifdef notdef
  131.  
  132. /* This is the initial permutation matrix -- we have no
  133.    use for it, but it is needed if you will develop
  134.    this module into a general DES package.
  135. */
  136. static unsigned char inital_perm[64] = 
  137.   { 58, 50, 42, 34, 26, 18, 10,  2, 60, 52, 44, 36, 28, 20, 12, 4,
  138.     62, 54, 46, 38, 30, 22, 14,  6, 64, 56, 48, 40, 32, 24, 16, 8,
  139.     57, 49, 41, 33, 25, 17,  9,  1, 59, 51, 43, 35, 27, 19, 11, 3,
  140.     61, 53, 45, 37, 29, 21, 13,  5, 63, 55, 47, 39, 31, 23, 15, 7
  141.   };
  142.  
  143. #endif
  144.  
  145. /* Final permutation matrix -- not used directly */
  146. static unsigned char final_perm[64] =
  147.   { 40,  8, 48, 16, 56, 24, 64, 32, 39,  7, 47, 15, 55, 23, 63, 31,
  148.     38,  6, 46, 14, 54, 22, 62, 30, 37,  5, 45, 13, 53, 21, 61, 29,
  149.     36,  4, 44, 12, 52, 20, 60, 28, 35,  3, 43, 11, 51, 19, 59, 27,
  150.     34,  2, 42, 10, 50, 18, 58, 26, 33,  1, 41,  9, 49, 17, 57, 25
  151.   };
  152.  
  153. /* The 16 DES keys in BITMASK format */
  154. unsigned long keytab[16][2];
  155.  
  156. #define ascii_to_bin(c) ((c)>='a'?(c-59):(c)>='A'?((c)-53):(c)-'.')
  157. #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
  158.  
  159. /* Macro to set a bit (0..23) */
  160. #define BITMASK(i) ( (1<<(11-(i)%12+3)) << ((i)<12?16:0) )
  161.  
  162. /* sb arrays:
  163.  
  164.    Workhorses of the inner loop of the DES implementation.
  165.    They do sbox lookup, shifting of this  value, 32 bit
  166.    permutation and E permutation for the next round.
  167.  
  168.    Kept in 'BITMASK' format.
  169.  
  170. */
  171.  
  172. unsigned long sb0[8192],sb1[8192],sb2[8192],sb3[8192];
  173. static unsigned long *sb[4] = {sb0,sb1,sb2,sb3}; 
  174.  
  175. /* eperm32tab: do 32 bit permutation and E selection
  176.  
  177.    The first index is the byte number in the 32 bit value to be permuted
  178.     -  second  -   is the value of this byte
  179.     -  third   -   selects the two 32 bit values
  180.  
  181.     The table is used and generated internally in init_des to speed it up
  182.  
  183. */
  184. static unsigned long eperm32tab[4][256][2];
  185.  
  186. /* mk_keytab_table: fast way of generating keytab from ASCII key
  187.  
  188.    The first  index is the byte number in the 8 byte ASCII key
  189.     -  second   -    -  -  current DES round i.e. the key number
  190.     -  third    -   distinguishes between the two 24 bit halfs of
  191.                     the selected key
  192.     -  fourth   -   selects the 7 bits actually used of each byte
  193.  
  194.    The table is kept in the format generated by the BITMASK macro
  195.  
  196. */
  197. static unsigned long mk_keytab_table[8][16][2][128];
  198.  
  199.  
  200. /* efp: undo an extra e selection and do final
  201.         permutation giving the DES result.
  202.   
  203.         Invoked 6 bit a time on two 48 bit values
  204.         giving two 32 bit longs.
  205. */
  206. static unsigned long efp[16][64][2];
  207.  
  208.  
  209. static unsigned char bytemask[8]  =
  210.   { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
  211.  
  212.  
  213. static unsigned long longmask[32] = 
  214.   { 0x80000000, 0x40000000, 0x20000000, 0x10000000,
  215.     0x08000000, 0x04000000, 0x02000000, 0x01000000,
  216.     0x00800000, 0x00400000, 0x00200000, 0x00100000,
  217.     0x00080000, 0x00040000, 0x00020000, 0x00010000,
  218.     0x00008000, 0x00004000, 0x00002000, 0x00001000,
  219.     0x00000800, 0x00000400, 0x00000200, 0x00000100,
  220.     0x00000080, 0x00000040, 0x00000020, 0x00000010,
  221.     0x00000008, 0x00000004, 0x00000002, 0x00000001
  222.   };
  223.  
  224. #ifdef DEBUG
  225.  
  226. /* For debugging */
  227.  
  228. pr_bits(a,n)
  229.   unsigned long *a;
  230.   unsigned long n;
  231.   { unsigned long i,j,t,tmp;
  232.     n/=8;
  233.     for(i=0; i<n; i++)
  234.       { tmp=0;
  235.     for(j=0; j<8; j++)
  236.       { t=8*i+j;
  237.         tmp|=(a[t/24] & BITMASK(t % 24))?bytemask[j]:0;
  238.       }
  239.     (void)printf("%02x ",tmp);
  240.       }
  241.     printf(" ");
  242.   }
  243.  
  244. static set_bits(v,b)
  245.   unsigned long v;
  246.   unsigned long *b;
  247.   { unsigned long i;
  248.     *b = 0;
  249.     for(i=0; i<24; i++)
  250.       if(v & longmask[8+i])
  251.     *b |= BITMASK(i);
  252.   }
  253.  
  254. #endif
  255.  
  256. static unsigned long initialized = 0;
  257.  
  258. /* lookup a 6 bit value in sbox */
  259.  
  260. #define s_lookup(i,s) sbox[(i)][(((s)>>4) & 0x2)|((s) & 0x1)][((s)>>1) & 0xf];
  261.  
  262. /* Generate the mk_keytab_table once in a program execution */
  263.  
  264. void init_des()
  265.   { unsigned long tbl_long,bit_within_long,comes_from_bit;
  266.     unsigned long bit,sg,j;
  267.     unsigned long bit_within_byte,key_byte,byte_value;
  268.     unsigned long round,mask;
  269.  
  270.     bzero((char*)mk_keytab_table,sizeof mk_keytab_table);
  271.     
  272.     for(round=0; round<16; round++)
  273.       for(bit=0; bit<48; bit++)
  274.         { tbl_long        = bit / 24;
  275.           bit_within_long = bit % 24;
  276.  
  277.           /* from which bit in the key halves does it origin? */
  278.           comes_from_bit = pc2[bit] - 1;
  279.  
  280.           /* undo the rotation done before pc2 */
  281.           if(comes_from_bit>=28)
  282.             comes_from_bit =  28 + (comes_from_bit + totrot[round]) % 28;
  283.           else
  284.             comes_from_bit =       (comes_from_bit + totrot[round]) % 28;
  285.  
  286.           /* undo the initial key half forming permutation */
  287.           comes_from_bit = pc1[comes_from_bit] - 1;
  288.  
  289.           /* Now 'comes_from_bit' is the correct number (0..55) 
  290.              of the keybit from which the bit being traced
  291.              in key 'round' comes from
  292.           */
  293.  
  294.           key_byte        =  comes_from_bit  / 8;
  295.           bit_within_byte = (comes_from_bit % 8)+1;
  296.  
  297.           mask = bytemask[bit_within_byte];
  298.  
  299.           for(byte_value=0; byte_value<128; byte_value++)
  300.             if(byte_value & mask)
  301.               mk_keytab_table[key_byte][round][tbl_long][byte_value] |= 
  302.         BITMASK(bit_within_long);
  303.         }
  304.  
  305.     /* Now generate the table used to do an combined
  306.        32 bit permutation and e expansion
  307.  
  308.        We use it because we have to permute 16384 32 bit
  309.        longs into 48 bit in order to initialize sb.
  310.  
  311.        Looping 48 rounds per permutation becomes 
  312.        just too slow...
  313.  
  314.     */
  315.  
  316.     bzero((char*)eperm32tab,sizeof eperm32tab);
  317.     for(bit=0; bit<48; bit++)
  318.       { unsigned long mask1,comes_from;
  319.     
  320.         comes_from = perm32[eref[bit]-1]-1;
  321.         mask1      = bytemask[comes_from % 8];
  322.     
  323.         for(j=256; j--;)
  324.           if(j & mask1)
  325.             eperm32tab[comes_from/8][j][bit/24] |= BITMASK(bit % 24);
  326.       }
  327.     
  328.     /* Create the sb tables:
  329.  
  330.        For each 12 bit segment of an 48 bit intermediate
  331.        result, the sb table precomputes the two 4 bit
  332.        values of the sbox lookups done with the two 6
  333.        bit halves, shifts them to their proper place,
  334.        sends them through perm32 and finally E expands
  335.        them so that they are ready for the next
  336.        DES round.
  337.  
  338.        The value looked up is to be xored onto the
  339.        two 48 bit right halves.
  340.     */
  341.  
  342.     for(sg=0; sg<4; sg++)
  343.       { unsigned long j1,j2;
  344.         unsigned long s1,s2;
  345.     
  346.         for(j1=0; j1<64; j1++)
  347.           { s1 = s_lookup(2*sg,j1);
  348.             for(j2=0; j2<64; j2++)
  349.               { unsigned long to_permute,inx;
  350.  
  351.                 s2         = s_lookup(2*sg+1,j2);
  352.                 to_permute = ((s1<<4)  | s2) << (24-8*sg);
  353.                 inx        = ((j1<<6)  | j2) << 1;
  354.  
  355.                 sb[sg][inx  ]  = eperm32tab[0][(to_permute >> 24) & 0xff][0];
  356.                 sb[sg][inx+1]  = eperm32tab[0][(to_permute >> 24) & 0xff][1];
  357.   
  358.                 sb[sg][inx  ] |= eperm32tab[1][(to_permute >> 16) & 0xff][0];
  359.                 sb[sg][inx+1] |= eperm32tab[1][(to_permute >> 16) & 0xff][1];
  360.   
  361.                 sb[sg][inx  ] |= eperm32tab[2][(to_permute >>  8) & 0xff][0];
  362.                 sb[sg][inx+1] |= eperm32tab[2][(to_permute >>  8) & 0xff][1];
  363.                 
  364.                 sb[sg][inx  ] |= eperm32tab[3][(to_permute)       & 0xff][0];
  365.                 sb[sg][inx+1] |= eperm32tab[3][(to_permute)       & 0xff][1];
  366.               }
  367.           }
  368.       }  
  369.     initialized++;
  370.   }
  371.  
  372. /* Process the elements of the sb table permuting the
  373.    bits swapped in the expansion by the current salt.
  374. */
  375.  
  376. void shuffle_sb(k, saltbits)
  377.   unsigned long *k, saltbits;
  378.   { int j, x;
  379.     for(j=4096; j--;) {
  380.       x = (k[0] ^ k[1]) & saltbits;
  381.       *k++ ^= x;
  382.       *k++ ^= x;
  383.     }
  384.   }
  385.  
  386. /* Setup the unit for a new salt
  387.    Hopefully we'll not see a new salt in each crypt call.
  388. */
  389.  
  390. static unsigned char current_salt[3]="&&"; /* invalid value */
  391. static unsigned long oldsaltbits = 0;
  392.  
  393. void setup_salt(s)
  394.   char *s;
  395.   { unsigned long i,j,saltbits;
  396.  
  397.     if(!initialized)
  398.       init_des();
  399.  
  400.     if(s[0]==current_salt[0] && s[1]==current_salt[1])
  401.       return;
  402.     current_salt[0]=s[0]; current_salt[1]=s[1];
  403.  
  404.     /* This is the only crypt change to DES:
  405.        entries are swapped in the expansion table
  406.        according to the bits set in the salt.
  407.     */
  408.  
  409.     saltbits=0;
  410.     bcopy((char*)eref,(char*)disturbed_e,sizeof eref);
  411.     for(i=0; i<2; i++)
  412.       { long c=ascii_to_bin(s[i]);
  413.     if(c<0 || c>63)
  414.       c=0;
  415.         for(j=0; j<6; j++)
  416.           if((c>>j) & 0x1)
  417.             { disturbed_e[6*i+j   ]=eref[6*i+j+24];
  418.               disturbed_e[6*i+j+24]=eref[6*i+j   ];
  419.           saltbits |= BITMASK(6*i+j);
  420.             }
  421.       }
  422.  
  423.     /* Permute the sb table values
  424.        to reflect the changed e
  425.        selection table
  426.     */
  427.  
  428.     shuffle_sb(sb0, oldsaltbits ^ saltbits); 
  429.     shuffle_sb(sb1, oldsaltbits ^ saltbits);
  430.     shuffle_sb(sb2, oldsaltbits ^ saltbits);
  431.     shuffle_sb(sb3, oldsaltbits ^ saltbits);
  432.  
  433.     oldsaltbits = saltbits;
  434.  
  435.     /* Create an inverse matrix for disturbed_e telling
  436.        where to plug out bits if undoing disturbed_e
  437.     */
  438.  
  439.     for(i=48; i--;)
  440.       { e_inverse[disturbed_e[i]-1   ] = i;
  441.     e_inverse[disturbed_e[i]-1+32] = i+48;
  442.       }
  443.  
  444.     /* create efp: the matrix used to
  445.        undo the E expansion and effect final permutation
  446.     */
  447.  
  448.     bzero((char*)efp,sizeof efp);
  449.     for(i=0; i<64; i++)
  450.       { unsigned long o_bit,o_long;
  451.         unsigned long word_value,mask1,mask2,comes_from_f_bit,comes_from_e_bit;
  452.         unsigned long comes_from_word,bit_within_word;
  453.  
  454.     /* See where bit i belongs in the two 32 bit long's */
  455.     o_long = i / 32; /* 0..1  */
  456.     o_bit  = i % 32; /* 0..31 */
  457.  
  458.     /* And find a bit in the e permutated value setting this bit.
  459.  
  460.        Note: the e selection may have selected the same bit several
  461.        times. By the initialization of e_inverse, we only look
  462.        for one specific instance.
  463.     */
  464.         comes_from_f_bit = final_perm[i]-1;             /* 0..63 */
  465.     comes_from_e_bit = e_inverse[comes_from_f_bit]; /* 0..95 */
  466.         comes_from_word  = comes_from_e_bit / 6;        /* 0..15 */
  467.         bit_within_word  = comes_from_e_bit % 6;        /* 0..5  */
  468.  
  469.     mask1 = longmask[bit_within_word+26];
  470.     mask2 = longmask[o_bit];
  471.  
  472.         for(word_value=64; word_value--;)
  473.           if(word_value & mask1)
  474.             efp[comes_from_word][word_value][o_long] |= mask2;
  475.  
  476.       }
  477.  
  478.   }
  479.  
  480. /* Generate the key table before running the 25 DES rounds */
  481.  
  482. void mk_keytab(key)
  483.   char *key;
  484.   { unsigned long i,j;
  485.     unsigned long *k,*mkt;
  486.     char t;
  487.  
  488.     bzero((char*)keytab, sizeof keytab);
  489.     mkt = &mk_keytab_table[0][0][0][0];
  490.  
  491.     for(i=0; (t=(*key++) & 0x7f) && i<8; i++)
  492.       for(j=0,k = &keytab[0][0]; j<16; j++)
  493.         { *k++ |= mkt[t]; mkt += 128;
  494.           *k++ |= mkt[t]; mkt += 128;
  495.         }
  496.     for(; i<8; i++)
  497.       for(j=0,k = &keytab[0][0]; j<16; j++)
  498.         { *k++ |= mkt[0]; mkt += 128;
  499.           *k++ |= mkt[0]; mkt += 128;
  500.         }
  501.   }
  502.  
  503. /* Do final permutations and convert to ASCII */
  504.  
  505. char *output_conversion(l1,l2,r1,r2,salt)
  506.   unsigned long l1,l2,r1,r2;
  507.   char *salt;
  508.   { static char outbuf[14];
  509.     unsigned long i;
  510.     unsigned long s,v1,v2;
  511.  
  512.     /* Unfortunately we've done an extra E
  513.        expansion -- undo it at the same time.
  514.     */
  515.  
  516.     v1=v2=0; l1 >>= 3; l2 >>= 3; r1 >>= 3; r2 >>= 3;
  517.  
  518.     v1 |= efp[ 3][ l1       & 0x3f][0]; v2 |= efp[ 3][ l1 & 0x3f][1];
  519.     v1 |= efp[ 2][(l1>>=6)  & 0x3f][0]; v2 |= efp[ 2][ l1 & 0x3f][1];
  520.     v1 |= efp[ 1][(l1>>=10) & 0x3f][0]; v2 |= efp[ 1][ l1 & 0x3f][1];
  521.     v1 |= efp[ 0][(l1>>=6)  & 0x3f][0]; v2 |= efp[ 0][ l1 & 0x3f][1];
  522.  
  523.     v1 |= efp[ 7][ l2       & 0x3f][0]; v2 |= efp[ 7][ l2 & 0x3f][1];
  524.     v1 |= efp[ 6][(l2>>=6)  & 0x3f][0]; v2 |= efp[ 6][ l2 & 0x3f][1];
  525.     v1 |= efp[ 5][(l2>>=10) & 0x3f][0]; v2 |= efp[ 5][ l2 & 0x3f][1];
  526.     v1 |= efp[ 4][(l2>>=6)  & 0x3f][0]; v2 |= efp[ 4][ l2 & 0x3f][1];
  527.  
  528.     v1 |= efp[11][ r1       & 0x3f][0]; v2 |= efp[11][ r1 & 0x3f][1];
  529.     v1 |= efp[10][(r1>>=6)  & 0x3f][0]; v2 |= efp[10][ r1 & 0x3f][1];
  530.     v1 |= efp[ 9][(r1>>=10) & 0x3f][0]; v2 |= efp[ 9][ r1 & 0x3f][1];
  531.     v1 |= efp[ 8][(r1>>=6)  & 0x3f][0]; v2 |= efp[ 8][ r1 & 0x3f][1];
  532.  
  533.     v1 |= efp[15][ r2       & 0x3f][0]; v2 |= efp[15][ r2 & 0x3f][1];
  534.     v1 |= efp[14][(r2>>=6)  & 0x3f][0]; v2 |= efp[14][ r2 & 0x3f][1];
  535.     v1 |= efp[13][(r2>>=10) & 0x3f][0]; v2 |= efp[13][ r2 & 0x3f][1];
  536.     v1 |= efp[12][(r2>>=6)  & 0x3f][0]; v2 |= efp[12][ r2 & 0x3f][1];
  537.     
  538.     outbuf[0] = salt[0];
  539.     outbuf[1] = salt[1] ? salt[1] : salt[0];
  540.  
  541.     for(i=0; i<5; i++)
  542.       outbuf[i+2] = bin_to_ascii((v1>>(26-6*i)) & 0x3f);
  543.  
  544.     s  = (v2 & 0xf) << 2;             /* Save the rightmost 4 bit a moment */
  545.     v2 = (v2>>2) | ((v1 & 0x3)<<30);  /* Shift two bits of v1 onto v2      */
  546.  
  547.     for(i=5; i<10; i++)
  548.       outbuf[i+2] = bin_to_ascii((v2>>(56-6*i)) & 0x3f);
  549.  
  550.     outbuf[12] = bin_to_ascii(s);
  551.     outbuf[13] = 0;
  552.  
  553.     return outbuf;
  554.   }
  555.  
  556. char *crypt();
  557.  
  558. /* Stub to provide fcrypt compatibility */
  559.    
  560. char *fcrypt(key, salt)
  561.   char *key;
  562.   char *salt;
  563.   { return crypt(key, salt);
  564.   }
  565.  
  566.