home *** CD-ROM | disk | FTP | other *** search
/ The Hacker's Encyclopedia 1998 / hackers_encyclopedia.iso / hacking / unix / crackunx.txt / Sources / crack-fcrypt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-25  |  24.0 KB  |  906 lines
  1. /*
  2.  * This program is copyright Alec Muffett 1991 except for some portions of
  3.  * code in "crack-fcrypt.c" which are copyright Robert Baldwin, Icarus Sparry
  4.  * and Alec Muffett.  The author(s) disclaims all responsibility or liability
  5.  * with respect to it's usage or its effect upon hardware or computer
  6.  * systems, and maintain copyright as set out in the "LICENCE" document which
  7.  * accompanies distributions of Crack v4.0 and upwards.
  8.  */
  9.  
  10. /*
  11.  * Misc defs for the fast password transform optimisations.
  12.  */
  13.  
  14. #include "crack.h"
  15.  
  16. #define    reg    register
  17. #define    uns    unsigned
  18. #define unsb    uns char
  19. #define    unsl    uns long
  20.  
  21. /*
  22.  * Types for the different ways to represent DES bit patterns.  Bits are
  23.  * always right justified within fields.  Bits which have lower indices in
  24.  * the NBS spec are stored in the vax bits with less significance (e.g., Bit
  25.  * 1 of NBS spec is stored in the bit with weight 2 ** 0 to the Vax.
  26.  */
  27.  
  28. #define    obpb1    unsb        /* One bit per byte. */
  29. #define sbpb6    unsb        /* Six bits per byte, 6 held. */
  30. #define sbpb6R    unsb        /* Six bits per byte Reversed order, 6 held. */
  31. #define    sbpb24    unsl        /* Six bits per byte, 24 held. */
  32. #define    ebpb24    unsl        /* Eight bits per bit, 24 held. */
  33. #define    fbpb4    unsb        /* Four bits per byte, 4 held. */
  34. #define    fbpb4R    unsb        /* Four bits per byte Reversed order, 4 held. */
  35.  
  36. /*
  37.  * The operation (6 * x) is often better optimised as this (for really
  38.  * braindead compilers) - AEM
  39.  */
  40.  
  41. #ifdef BRAINDEAD6
  42. #define SIX_TIMES(exprn)        (((exprn) << 2) + ((exprn) << 1))
  43. #else
  44. #define SIX_TIMES(exprn)        (6 * (exprn))
  45. #endif                /* BRAINDEAD6 */
  46.  
  47. /* DES transformation type... */
  48.  
  49. union SDATA
  50. {
  51.     sbpb24 b[2];
  52.     sbpb6 c[8];
  53. };
  54. #ifndef FDES_4BYTE        /* Thanks to Matt Bishop for this idea -AEM. */
  55. #define SIZEFIX        0
  56. #define INDIRECT(a,b)     (a)[b]
  57. #else
  58. #define SIZEFIX        2    /* "n" where 2^n == sizeof(sbpb24) */
  59. #define INDIRECT(a,b)     (*((sbpb24 *)(((unsigned char *) a) + (b))))
  60. #endif
  61.  
  62. /*
  63.  * These used to be rather slow and frequently used functions - AEM
  64.  */
  65.  
  66. #define TF_TO_SIXBIT(tf) \
  67.     (sbpb24)((tf & 077L) | \
  68.         ((tf & 07700L) << 2) | \
  69.         ((tf & 0770000L) << 4) | \
  70.         ((tf & 077000000L) << 6))
  71.  
  72. #define SIXBIT_TO_TF(sb) \
  73.     (ebpb24)((sb & 0x3fL) | \
  74.         ((sb & 0x3f00L) >> 2) | \
  75.         ((sb & 0x3f0000L) >> 4) | \
  76.         ((sb & 0x3f000000L) >> 6))
  77.  
  78. /*
  79.  * Data segment gathered into one place, try to keep this stuff long aligned
  80.  * - AEM
  81.  */
  82.  
  83. static char iobuf[16];
  84. static obpb1 crypt_block[72];    /* 72 is next multiple of 8 bytes after 66 */
  85. static sbpb24 KS[32];
  86. static sbpb24 S0H[64], S1H[64], S2H[64], S3H[64];
  87. static sbpb24 S4H[64], S5H[64], S6H[64], S7H[64];
  88. static sbpb24 S0L[64], S1L[64], S2L[64], S3L[64];
  89. static sbpb24 S4L[64], S5L[64], S6L[64], S7L[64];
  90. static sbpb24 out96[4];
  91.  
  92. /*
  93.  * Start of the real thing
  94.  */
  95.  
  96. void
  97. fsetkey ()
  98. {
  99.     /*
  100.      * This used to be utterly horrendous. It still is, but it's much, much,
  101.      * smaller... (and quite a bit faster...) - AEM
  102.      */
  103.     static unsb KeyToKS[] =
  104.     {
  105.     9, 50, 33, 59, 48, 16, 32, 56, 1, 8, 18, 41, 2, 34, 25, 24,
  106.     43, 57, 58, 0, 35, 26, 17, 40, 21, 27, 38, 53, 36, 3, 46, 29,
  107.     4, 52, 22, 28, 60, 20, 37, 62, 14, 19, 44, 13, 12, 61, 54, 30,
  108.     1, 42, 25, 51, 40, 8, 24, 48, 58, 0, 10, 33, 59, 26, 17, 16,
  109.     35, 49, 50, 57, 56, 18, 9, 32, 13, 19, 30, 45, 28, 62, 38, 21,
  110.     27, 44, 14, 20, 52, 12, 29, 54, 6, 11, 36, 5, 4, 53, 46, 22,
  111.     50, 26, 9, 35, 24, 57, 8, 32, 42, 49, 59, 17, 43, 10, 1, 0,
  112.     48, 33, 34, 41, 40, 2, 58, 16, 60, 3, 14, 29, 12, 46, 22, 5,
  113.     11, 28, 61, 4, 36, 27, 13, 38, 53, 62, 20, 52, 19, 37, 30, 6,
  114.     34, 10, 58, 48, 8, 41, 57, 16, 26, 33, 43, 1, 56, 59, 50, 49,
  115.     32, 17, 18, 25, 24, 51, 42, 0, 44, 54, 61, 13, 27, 30, 6, 52,
  116.     62, 12, 45, 19, 20, 11, 60, 22, 37, 46, 4, 36, 3, 21, 14, 53,
  117.     18, 59, 42, 32, 57, 25, 41, 0, 10, 17, 56, 50, 40, 43, 34, 33,
  118.     16, 1, 2, 9, 8, 35, 26, 49, 28, 38, 45, 60, 11, 14, 53, 36,
  119.     46, 27, 29, 3, 4, 62, 44, 6, 21, 30, 19, 20, 54, 5, 61, 37,
  120.     2, 43, 26, 16, 41, 9, 25, 49, 59, 1, 40, 34, 24, 56, 18, 17,
  121.     0, 50, 51, 58, 57, 48, 10, 33, 12, 22, 29, 44, 62, 61, 37, 20,
  122.     30, 11, 13, 54, 19, 46, 28, 53, 5, 14, 3, 4, 38, 52, 45, 21,
  123.     51, 56, 10, 0, 25, 58, 9, 33, 43, 50, 24, 18, 8, 40, 2, 1,
  124.     49, 34, 35, 42, 41, 32, 59, 17, 27, 6, 13, 28, 46, 45, 21, 4,
  125.     14, 62, 60, 38, 3, 30, 12, 37, 52, 61, 54, 19, 22, 36, 29, 5,
  126.     35, 40, 59, 49, 9, 42, 58, 17, 56, 34, 8, 2, 57, 24, 51, 50,
  127.     33, 18, 48, 26, 25, 16, 43, 1, 11, 53, 60, 12, 30, 29, 5, 19,
  128.     61, 46, 44, 22, 54, 14, 27, 21, 36, 45, 38, 3, 6, 20, 13, 52,
  129.     56, 32, 51, 41, 1, 34, 50, 9, 48, 26, 0, 59, 49, 16, 43, 42,
  130.     25, 10, 40, 18, 17, 8, 35, 58, 3, 45, 52, 4, 22, 21, 60, 11,
  131.     53, 38, 36, 14, 46, 6, 19, 13, 28, 37, 30, 62, 61, 12, 5, 44,
  132.     40, 16, 35, 25, 50, 18, 34, 58, 32, 10, 49, 43, 33, 0, 56, 26,
  133.     9, 59, 24, 2, 1, 57, 48, 42, 54, 29, 36, 19, 6, 5, 44, 62,
  134.     37, 22, 20, 61, 30, 53, 3, 60, 12, 21, 14, 46, 45, 27, 52, 28,
  135.     24, 0, 48, 9, 34, 2, 18, 42, 16, 59, 33, 56, 17, 49, 40, 10,
  136.     58, 43, 8, 51, 50, 41, 32, 26, 38, 13, 20, 3, 53, 52, 28, 46,
  137.     21, 6, 4, 45, 14, 37, 54, 44, 27, 5, 61, 30, 29, 11, 36, 12,
  138.     8, 49, 32, 58, 18, 51, 2, 26, 0, 43, 17, 40, 1, 33, 24, 59,
  139.     42, 56, 57, 35, 34, 25, 16, 10, 22, 60, 4, 54, 37, 36, 12, 30,
  140.     5, 53, 19, 29, 61, 21, 38, 28, 11, 52, 45, 14, 13, 62, 20, 27,
  141.     57, 33, 16, 42, 2, 35, 51, 10, 49, 56, 1, 24, 50, 17, 8, 43,
  142.     26, 40, 41, 48, 18, 9, 0, 59, 6, 44, 19, 38, 21, 20, 27, 14,
  143.     52, 37, 3, 13, 45, 5, 22, 12, 62, 36, 29, 61, 60, 46, 4, 11,
  144.     41, 17, 0, 26, 51, 48, 35, 59, 33, 40, 50, 8, 34, 1, 57, 56,
  145.     10, 24, 25, 32, 2, 58, 49, 43, 53, 28, 3, 22, 5, 4, 11, 61,
  146.     36, 21, 54, 60, 29, 52, 6, 27, 46, 20, 13, 45, 44, 30, 19, 62,
  147.     25, 1, 49, 10, 35, 32, 48, 43, 17, 24, 34, 57, 18, 50, 41, 40,
  148.     59, 8, 9, 16, 51, 42, 33, 56, 37, 12, 54, 6, 52, 19, 62, 45,
  149.     20, 5, 38, 44, 13, 36, 53, 11, 30, 4, 60, 29, 28, 14, 3, 46,
  150.     17, 58, 41, 2, 56, 24, 40, 35, 9, 16, 26, 49, 10, 42, 33, 32,
  151.     51, 0, 1, 8, 43, 34, 25, 48, 29, 4, 46, 61, 44, 11, 54, 37,
  152.     12, 60, 30, 36, 5, 28, 45, 3, 22, 27, 52, 21, 20, 6, 62, 38
  153.     };
  154.  
  155.     reg int i;
  156.     reg unsigned long r;
  157.     reg unsb *k;
  158.  
  159.     k = KeyToKS;
  160.  
  161.     for (i = 0; i < 32; i++)
  162.     {
  163.     /* 16-bit tweaks suggested by cip_maz@fb6tcp.physik.uni-paderborn.de */
  164.     /* inlining speedup tweak suggested by tahorsley@csd.harris.com */
  165.     /* (strange addition compensates missing TF_TO_SIXBIT) */
  166.     r = (unsigned long) crypt_block[*(k++)];
  167.     r |= (unsigned long) crypt_block[*(k++)] << 1;
  168.     r |= (unsigned long) crypt_block[*(k++)] << 2;
  169.     r |= (unsigned long) crypt_block[*(k++)] << 3;
  170.     r |= (unsigned long) crypt_block[*(k++)] << 4;
  171.     r |= (unsigned long) crypt_block[*(k++)] << 5;
  172.     r |= (unsigned long) crypt_block[*(k++)] << (2 + 6);
  173.     r |= (unsigned long) crypt_block[*(k++)] << (2 + 7);
  174.     r |= (unsigned long) crypt_block[*(k++)] << (2 + 8);
  175.     r |= (unsigned long) crypt_block[*(k++)] << (2 + 9);
  176.     r |= (unsigned long) crypt_block[*(k++)] << (2 + 10);
  177.     r |= (unsigned long) crypt_block[*(k++)] << (2 + 11);
  178.     r |= (unsigned long) crypt_block[*(k++)] << (4 + 12);
  179.     r |= (unsigned long) crypt_block[*(k++)] << (4 + 13);
  180.     r |= (unsigned long) crypt_block[*(k++)] << (4 + 14);
  181.     r |= (unsigned long) crypt_block[*(k++)] << (4 + 15);
  182.     r |= (unsigned long) crypt_block[*(k++)] << (4 + 16);
  183.     r |= (unsigned long) crypt_block[*(k++)] << (4 + 17);
  184.     r |= (unsigned long) crypt_block[*(k++)] << (6 + 18);
  185.     r |= (unsigned long) crypt_block[*(k++)] << (6 + 19);
  186.     r |= (unsigned long) crypt_block[*(k++)] << (6 + 20);
  187.     r |= (unsigned long) crypt_block[*(k++)] << (6 + 21);
  188.     r |= (unsigned long) crypt_block[*(k++)] << (6 + 22);
  189.     r |= (unsigned long) crypt_block[*(k++)] << (6 + 23);
  190.     KS[i] = r;
  191.     }
  192. }
  193.  
  194. void
  195. XForm (saltvalue)
  196.     sbpb24 saltvalue;
  197. {
  198. #ifdef BIG_ENDIAN        /* Icarus Sparry, Bath - mod AEM */
  199. #define STEP --
  200. #define START &sdata.c[7]
  201. #define Dl sdata.b[1]
  202. #define Dh sdata.b[0]
  203. #else
  204. #ifdef LITTLE_ENDIAN
  205. #define STEP ++
  206. #define START &sdata.c[0]
  207. #define Dl sdata.b[0]
  208. #define Dh sdata.b[1]
  209. #endif
  210.     /* else error */
  211. #endif
  212.     union SDATA sdata;
  213.     reg sbpb24 Rl;
  214.     reg sbpb24 Rh;
  215.     reg sbpb24 Ll;
  216.     reg sbpb24 Lh;
  217.     reg sbpb6 *dp;
  218.     int loop;
  219.     int kloop;
  220.     sbpb24 *kp;
  221.     reg sbpb24 k;
  222. #ifdef FDES_8BYTE
  223.     reg sbpb24 tmpi;
  224. #endif                /* FDES_8BYTE */
  225.  
  226.     Ll = Lh = Rl = Rh = 0;
  227.  
  228.     for (loop = 25; loop--; /* nothing */ )
  229.     {
  230.     kp = KS;
  231.     for (kloop = 8; kloop--; /* nothing */ )
  232.     {
  233.         k = (Rl ^ Rh) & saltvalue;
  234. #ifndef FDES_8BYTE
  235.         Dl = (k ^ Rl ^ *kp++) << SIZEFIX;
  236.         Dh = (k ^ Rh ^ *kp++) << SIZEFIX;
  237. #else
  238.         /* hack to make things work better - matthew kaufman */
  239.         /* I haven't tried any of this - I don't have a cray... AEM */
  240.         tmpi = (k ^ Rl ^ *kp++);
  241.         sdata.c[3] = (tmpi >> 24) & 0x00ff;
  242.         sdata.c[2] = (tmpi >> 16) & 0x00ff;
  243.         sdata.c[1] = (tmpi >> 8) & 0x00ff;
  244.         sdata.c[0] = (tmpi) & 0x00ff;
  245.         tmpi = (k ^ Rh ^ *kp++);
  246.         sdata.c[7] = (tmpi >> 24) & 0x00ff;
  247.         sdata.c[6] = (tmpi >> 16) & 0x00ff;
  248.         sdata.c[5] = (tmpi >> 8) & 0x00ff;
  249.         sdata.c[4] = (tmpi) & 0x00ff;
  250. #endif                /* FDES_8BYTE */
  251.  
  252.         dp = START;
  253.         Lh ^= INDIRECT (S0H, *dp);
  254.         Ll ^= INDIRECT (S0L, *dp STEP);
  255.         Lh ^= INDIRECT (S1H, *dp);
  256.         Ll ^= INDIRECT (S1L, *dp STEP);
  257.         Lh ^= INDIRECT (S2H, *dp);
  258.         Ll ^= INDIRECT (S2L, *dp STEP);
  259.         Lh ^= INDIRECT (S3H, *dp);
  260.         Ll ^= INDIRECT (S3L, *dp STEP);
  261.         Lh ^= INDIRECT (S4H, *dp);
  262.         Ll ^= INDIRECT (S4L, *dp STEP);
  263.         Lh ^= INDIRECT (S5H, *dp);
  264.         Ll ^= INDIRECT (S5L, *dp STEP);
  265.         Lh ^= INDIRECT (S6H, *dp);
  266.         Ll ^= INDIRECT (S6L, *dp STEP);
  267.         Lh ^= INDIRECT (S7H, *dp);
  268.         Ll ^= INDIRECT (S7L, *dp STEP);
  269.  
  270.         k = (Ll ^ Lh) & saltvalue;
  271. #ifndef FDES_8BYTE
  272.         Dl = (k ^ Ll ^ *kp++) << SIZEFIX;
  273.         Dh = (k ^ Lh ^ *kp++) << SIZEFIX;
  274. #else
  275.         tmpi = (k ^ Ll ^ *kp++);
  276.         sdata.c[3] = (tmpi >> 24) & 0x00ff;
  277.         sdata.c[2] = (tmpi >> 16) & 0x00ff;
  278.         sdata.c[1] = (tmpi >> 8) & 0x00ff;
  279.         sdata.c[0] = (tmpi) & 0x00ff;
  280.         tmpi = (k ^ Lh ^ *kp++);
  281.         sdata.c[7] = (tmpi >> 24) & 0x00ff;
  282.         sdata.c[6] = (tmpi >> 16) & 0x00ff;
  283.         sdata.c[5] = (tmpi >> 8) & 0x00ff;
  284.         sdata.c[4] = (tmpi) & 0x00ff;
  285. #endif                /* FDES_8BYTE */
  286.  
  287.         dp = START;
  288.         Rh ^= INDIRECT (S0H, *dp);
  289.         Rl ^= INDIRECT (S0L, *dp STEP);
  290.         Rh ^= INDIRECT (S1H, *dp);
  291.         Rl ^= INDIRECT (S1L, *dp STEP);
  292.         Rh ^= INDIRECT (S2H, *dp);
  293.         Rl ^= INDIRECT (S2L, *dp STEP);
  294.         Rh ^= INDIRECT (S3H, *dp);
  295.         Rl ^= INDIRECT (S3L, *dp STEP);
  296.         Rh ^= INDIRECT (S4H, *dp);
  297.         Rl ^= INDIRECT (S4L, *dp STEP);
  298.         Rh ^= INDIRECT (S5H, *dp);
  299.         Rl ^= INDIRECT (S5L, *dp STEP);
  300.         Rh ^= INDIRECT (S6H, *dp);
  301.         Rl ^= INDIRECT (S6L, *dp STEP);
  302.         Rh ^= INDIRECT (S7H, *dp);
  303.         Rl ^= INDIRECT (S7L, *dp STEP);
  304.     }
  305.  
  306.     Ll ^= Rl;
  307.     Lh ^= Rh;
  308.     Rl ^= Ll;
  309.     Rh ^= Lh;
  310.     Ll ^= Rl;
  311.     Lh ^= Rh;
  312.     }
  313.  
  314.     /*
  315.      * for reasons that I cannot explain, if I insert the contents of the
  316.      * UnXForm function right HERE, making the tweaks as necessary to avoid
  317.      * using out96[] to pass data, I LOSE 30% of my speed.  I don't know why.
  318.      * Hence, I continue to use out96[]...
  319.      */
  320.     {
  321.     reg sbpb24 *qp;
  322.     qp = out96;
  323.     *qp++ = Ll;
  324.     *qp++ = Lh;
  325.     *qp++ = Rl;
  326.     *qp++ = Rh;
  327.     }
  328. }
  329.  
  330. void
  331. UnXForm ()
  332. {
  333.     reg sbpb24 Rl;
  334.     reg sbpb24 Rh;
  335.     reg sbpb24 Ll;
  336.     reg sbpb24 Lh;
  337.     reg obpb1 *ptr;
  338.     reg long int mask;
  339.     register long int *lip;
  340.  
  341.     Ll = SIXBIT_TO_TF (out96[0]);
  342.     Lh = SIXBIT_TO_TF (out96[1]);
  343.     Rl = SIXBIT_TO_TF (out96[2]);
  344.     Rh = SIXBIT_TO_TF (out96[3]);
  345.  
  346. #ifdef BUILTIN_CLEAR
  347.     lip = (long int *) crypt_block;
  348.     for (mask = (sizeof (crypt_block) / sizeof (long int)); mask--; /* - */ )
  349.     {
  350.     *(lip++) = 0L;
  351.     }
  352. #else                /* BUILTIN_CLEAR */
  353.     bzero (crypt_block, 66);
  354. #endif                /* BUILTIN_CLEAR */
  355.  
  356.     ptr = crypt_block;
  357.     mask = 0x000400L;
  358.     if (Rl & mask)
  359.     *ptr = 0x01;
  360.     ptr++;
  361.     if (Ll & mask)
  362.     *ptr = 0x01;
  363.     ptr++;
  364.     mask = 0x400000L;
  365.     if (Rl & mask)
  366.     *ptr = 0x01;
  367.     ptr++;
  368.     if (Ll & mask)
  369.     *ptr = 0x01;
  370.     ptr++;
  371.     mask = 0x000400L;
  372.     if (Rh & mask)
  373.     *ptr = 0x01;
  374.     ptr++;
  375.     if (Lh & mask)
  376.     *ptr = 0x01;
  377.     ptr++;
  378.     mask = 0x400000L;
  379.     if (Rh & mask)
  380.     *ptr = 0x01;
  381.     ptr++;
  382.     if (Lh & mask)
  383.     *ptr = 0x01;
  384.     ptr++;
  385.     mask = 0x000200L;
  386.     if (Rl & mask)
  387.     *ptr = 0x01;
  388.     ptr++;
  389.     if (Ll & mask)
  390.     *ptr = 0x01;
  391.     ptr++;
  392.     mask = 0x200000L;
  393.     if (Rl & mask)
  394.     *ptr = 0x01;
  395.     ptr++;
  396.     if (Ll & mask)
  397.     *ptr = 0x01;
  398.     ptr++;
  399.     mask = 0x000200L;
  400.     if (Rh & mask)
  401.     *ptr = 0x01;
  402.     ptr++;
  403.     if (Lh & mask)
  404.     *ptr = 0x01;
  405.     ptr++;
  406.     mask = 0x200000L;
  407.     if (Rh & mask)
  408.     *ptr = 0x01;
  409.     ptr++;
  410.     if (Lh & mask)
  411.     *ptr = 0x01;
  412.     ptr++;
  413.     mask = 0x000100L;
  414.     if (Rl & mask)
  415.     *ptr = 0x01;
  416.     ptr++;
  417.     if (Ll & mask)
  418.     *ptr = 0x01;
  419.     ptr++;
  420.     mask = 0x100000L;
  421.     if (Rl & mask)
  422.     *ptr = 0x01;
  423.     ptr++;
  424.     if (Ll & mask)
  425.     *ptr = 0x01;
  426.     ptr++;
  427.     mask = 0x000100L;
  428.     if (Rh & mask)
  429.     *ptr = 0x01;
  430.     ptr++;
  431.     if (Lh & mask)
  432.     *ptr = 0x01;
  433.     ptr++;
  434.     mask = 0x100000L;
  435.     if (Rh & mask)
  436.     *ptr = 0x01;
  437.     ptr++;
  438.     if (Lh & mask)
  439.     *ptr = 0x01;
  440.     ptr++;
  441.     mask = 0x000080L;
  442.     if (Rl & mask)
  443.     *ptr = 0x01;
  444.     ptr++;
  445.     if (Ll & mask)
  446.     *ptr = 0x01;
  447.     ptr++;
  448.     mask = 0x080000L;
  449.     if (Rl & mask)
  450.     *ptr = 0x01;
  451.     ptr++;
  452.     if (Ll & mask)
  453.     *ptr = 0x01;
  454.     ptr++;
  455.     mask = 0x000080L;
  456.     if (Rh & mask)
  457.     *ptr = 0x01;
  458.     ptr++;
  459.     if (Lh & mask)
  460.     *ptr = 0x01;
  461.     ptr++;
  462.     mask = 0x080000L;
  463.     if (Rh & mask)
  464.     *ptr = 0x01;
  465.     ptr++;
  466.     if (Lh & mask)
  467.     *ptr = 0x01;
  468.     ptr++;
  469.     mask = 0x000010L;
  470.     if (Rl & mask)
  471.     *ptr = 0x01;
  472.     ptr++;
  473.     if (Ll & mask)
  474.     *ptr = 0x01;
  475.     ptr++;
  476.     mask = 0x010000L;
  477.     if (Rl & mask)
  478.     *ptr = 0x01;
  479.     ptr++;
  480.     if (Ll & mask)
  481.     *ptr = 0x01;
  482.     ptr++;
  483.     mask = 0x000010L;
  484.     if (Rh & mask)
  485.     *ptr = 0x01;
  486.     ptr++;
  487.     if (Lh & mask)
  488.     *ptr = 0x01;
  489.     ptr++;
  490.     mask = 0x010000L;
  491.     if (Rh & mask)
  492.     *ptr = 0x01;
  493.     ptr++;
  494.     if (Lh & mask)
  495.     *ptr = 0x01;
  496.     ptr++;
  497.     mask = 0x000008L;
  498.     if (Rl & mask)
  499.     *ptr = 0x01;
  500.     ptr++;
  501.     if (Ll & mask)
  502.     *ptr = 0x01;
  503.     ptr++;
  504.     mask = 0x008000L;
  505.     if (Rl & mask)
  506.     *ptr = 0x01;
  507.     ptr++;
  508.     if (Ll & mask)
  509.     *ptr = 0x01;
  510.     ptr++;
  511.     mask = 0x000008L;
  512.     if (Rh & mask)
  513.     *ptr = 0x01;
  514.     ptr++;
  515.     if (Lh & mask)
  516.     *ptr = 0x01;
  517.     ptr++;
  518.     mask = 0x008000L;
  519.     if (Rh & mask)
  520.     *ptr = 0x01;
  521.     ptr++;
  522.     if (Lh & mask)
  523.     *ptr = 0x01;
  524.     ptr++;
  525.     mask = 0x000004L;
  526.     if (Rl & mask)
  527.     *ptr = 0x01;
  528.     ptr++;
  529.     if (Ll & mask)
  530.     *ptr = 0x01;
  531.     ptr++;
  532.     mask = 0x004000L;
  533.     if (Rl & mask)
  534.     *ptr = 0x01;
  535.     ptr++;
  536.     if (Ll & mask)
  537.     *ptr = 0x01;
  538.     ptr++;
  539.     mask = 0x000004L;
  540.     if (Rh & mask)
  541.     *ptr = 0x01;
  542.     ptr++;
  543.     if (Lh & mask)
  544.     *ptr = 0x01;
  545.     ptr++;
  546.     mask = 0x004000L;
  547.     if (Rh & mask)
  548.     *ptr = 0x01;
  549.     ptr++;
  550.     if (Lh & mask)
  551.     *ptr = 0x01;
  552.     ptr++;
  553.     mask = 0x000002L;
  554.     if (Rl & mask)
  555.     *ptr = 0x01;
  556.     ptr++;
  557.     if (Ll & mask)
  558.     *ptr = 0x01;
  559.     ptr++;
  560.     mask = 0x002000L;
  561.     if (Rl & mask)
  562.     *ptr = 0x01;
  563.     ptr++;
  564.     if (Ll & mask)
  565.     *ptr = 0x01;
  566.     ptr++;
  567.     mask = 0x000002L;
  568.     if (Rh & mask)
  569.     *ptr = 0x01;
  570.     ptr++;
  571.     if (Lh & mask)
  572.     *ptr = 0x01;
  573.     ptr++;
  574.     mask = 0x002000L;
  575.     if (Rh & mask)
  576.     *ptr = 0x01;
  577.     ptr++;
  578.     if (Lh & mask)
  579.     *ptr = 0x01;
  580.     ptr++;
  581. }
  582.  
  583. char *
  584. fcrypt (pw, salt)
  585.     char *pw;
  586.     char *salt;
  587. {
  588.     /* Table lookups for salts reduce fcrypt() overhead dramatically */
  589.     static sbpb24 salt0[] =
  590.     {
  591.     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  592.     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  593.     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  594.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 5, 6, 7, 8, 9, 10, 11, 12,
  595.     13, 14, 15, 16, 17,
  596.  
  597.     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  598.     32, 33, 34, 35, 36, 37, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
  599.     42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
  600.     58, 59, 60, 61, 62, 63, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
  601.     12, 13, 14, 15, 16, 17,
  602.  
  603.     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  604.     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  605.     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  606.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
  607.  
  608.     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  609.     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  610.     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  611.     0, 1, 2, 3, 4
  612.     };
  613.     static sbpb24 salt1[] =
  614.     {
  615.     1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  616.     1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  617.     2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944,
  618.     3008, 3072, 3136, 3200, 3264, 3328, 3392, 3456, 3520, 3584,
  619.     3648, 3712, 3776, 3840, 3904, 3968, 4032, 0, 64, 128, 192, 256,
  620.     320, 384, 448, 512, 576, 640, 704, 320, 384, 448, 512, 576, 640,
  621.     704, 768, 832, 896, 960, 1024, 1088,
  622.  
  623.     1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  624.     1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  625.     2368, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560,
  626.     2624, 2688, 2752, 2816, 2880, 2944, 3008, 3072, 3136, 3200,
  627.     3264, 3328, 3392, 3456, 3520, 3584, 3648, 3712, 3776, 3840,
  628.     3904, 3968, 4032, 0, 64, 128, 192, 256, 320, 384, 448, 512, 576,
  629.     640, 704, 768, 832, 896, 960, 1024, 1088,
  630.  
  631.     1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  632.     1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  633.     2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944,
  634.     3008, 3072, 3136, 3200, 3264, 3328, 3392, 3456, 3520, 3584,
  635.     3648, 3712, 3776, 3840, 3904, 3968, 4032, 0, 64, 128, 192, 256,
  636.     320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024,
  637.     1088,
  638.  
  639.     1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664,
  640.     1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304,
  641.     2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944,
  642.     3008, 3072, 3136, 3200, 3264, 3328, 3392, 3456, 3520, 3584,
  643.     3648, 3712, 3776, 3840, 3904, 3968, 4032, 0, 64, 128, 192, 256
  644.     };
  645.  
  646.     /* final perutation desalting */
  647.     static obpb1 final[] =
  648.     {
  649.     46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66,
  650.     67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
  651.     83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103,
  652.     104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
  653.     117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
  654.     130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
  655.     143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
  656.     156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
  657.     169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
  658.     182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
  659.     195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
  660.     208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
  661.     221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
  662.     234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
  663.     247, 248, 249, 250, 251, 252, 253, 254, 255,
  664.     /* Truncate overflow bits at 256 */
  665.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  666.     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  667.     32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  668.     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58
  669.     };
  670.  
  671.     reg int i, j, k;
  672.     reg long int *lip;
  673.     sbpb24 saltvalue;
  674.  
  675. #ifdef BUILTIN_CLEAR
  676.     lip = (long int *) crypt_block;
  677.     for (i = (sizeof (crypt_block) / sizeof (long int)); i--; /* - */ )
  678.     {
  679.     *(lip++) = 0L;
  680.     }
  681. #else                /* BUILTIN_CLEAR */
  682.     bzero (crypt_block, 66);
  683. #endif                /* BUILTIN_CLEAR */
  684.  
  685.     for (i = 0; (k = *pw) && i < 64; pw++)
  686.     {
  687.     crypt_block[i++] = (k >> 6) & 01;
  688.     crypt_block[i++] = (k >> 5) & 01;
  689.     crypt_block[i++] = (k >> 4) & 01;
  690.     crypt_block[i++] = (k >> 3) & 01;
  691.     crypt_block[i++] = (k >> 2) & 01;
  692.     crypt_block[i++] = (k >> 1) & 01;
  693.     crypt_block[i++] = (k >> 0) & 01;
  694.     i++;            /* have to skip one here (parity bit) */
  695.     }
  696.  
  697.     fsetkey ( /* crypt_block */ );
  698.  
  699. #ifdef BUILTIN_CLEAR
  700.     lip = (long int *) crypt_block;
  701.     for (i = (sizeof (crypt_block) / sizeof (long int)); i--; /* - */ )
  702.     {
  703.     *(lip++) = 0L;
  704.     }
  705. #else                /* BUILTIN_CLEAR */
  706.     bzero (crypt_block, 66);
  707. #endif                /* BUILTIN_CLEAR */
  708.  
  709.     iobuf[0] = salt[0];
  710.     iobuf[1] = salt[1];
  711.  
  712.     saltvalue = salt0[iobuf[0]] | salt1[iobuf[1]];
  713.     saltvalue = TF_TO_SIXBIT (saltvalue);
  714.  
  715.     XForm (saltvalue);
  716.     UnXForm ();
  717.  
  718.     for (i = 0; i < 11; i++)
  719.     {
  720.     k = 0;
  721.  
  722.     for (j = 0; j < 6; j++)
  723.     {
  724.         k = (k << 1) | crypt_block[SIX_TIMES (i) + j];
  725.     }
  726.     iobuf[i + 2] = final[k];
  727.     }
  728.  
  729.     iobuf[i + 2] = 0;
  730.  
  731.     if (iobuf[1] == 0)
  732.     {
  733.     iobuf[1] = iobuf[0];
  734.     }
  735.     return (iobuf);
  736. }
  737. /********* INITIALISATION ROUTINES *********/
  738.  
  739. fbpb4
  740. lookupS (tableno, t6bits)
  741.     unsl tableno;
  742.     sbpb6R t6bits;
  743. {
  744.     static fbpb4R S[8][64] =
  745.     {
  746.     14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
  747.     0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
  748.     4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
  749.     15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
  750.  
  751.     15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
  752.     3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
  753.     0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
  754.     13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
  755.  
  756.     10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
  757.     13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
  758.     13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
  759.     1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
  760.  
  761.     7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
  762.     13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
  763.     10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
  764.     3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
  765.  
  766.     2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
  767.     14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
  768.     4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
  769.     11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
  770.  
  771.     12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
  772.     10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
  773.     9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
  774.     4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
  775.  
  776.     4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
  777.     13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
  778.     1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
  779.     6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
  780.  
  781.     13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
  782.     1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
  783.     7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
  784.     2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11,
  785.     };
  786.     sbpb6 fixed6bits;
  787.     fbpb4R r;
  788.     fbpb4 fixedr;
  789.  
  790.     fixed6bits = (((t6bits >> 0) & 01) << 5) +
  791.     (((t6bits >> 1) & 01) << 3) +
  792.     (((t6bits >> 2) & 01) << 2) +
  793.     (((t6bits >> 3) & 01) << 1) +
  794.     (((t6bits >> 4) & 01) << 0) +
  795.     (((t6bits >> 5) & 01) << 4);
  796.  
  797.     r = S[tableno][fixed6bits];
  798.  
  799.     fixedr = (((r >> 3) & 01) << 0) +
  800.     (((r >> 2) & 01) << 1) +
  801.     (((r >> 1) & 01) << 2) +
  802.     (((r >> 0) & 01) << 3);
  803.  
  804.     return (fixedr);
  805. }
  806.  
  807. void
  808. init (tableno, lowptr, highptr)
  809.     unsl tableno;
  810.     sbpb24 *lowptr, *highptr;
  811. {
  812.  
  813.     static unsb P[] =
  814.     {
  815.     15, 6, 19, 20,
  816.     28, 11, 27, 16,
  817.     0, 14, 22, 25,
  818.     4, 17, 30, 9,
  819.     1, 7, 23, 13,
  820.     31, 26, 2, 8,
  821.     18, 12, 29, 5,
  822.     21, 10, 3, 24,
  823.     };
  824.  
  825.     static unsb E[] =
  826.     {
  827.     31, 0, 1, 2, 3, 4,
  828.     3, 4, 5, 6, 7, 8,
  829.     7, 8, 9, 10, 11, 12,
  830.     11, 12, 13, 14, 15, 16,
  831.     15, 16, 17, 18, 19, 20,
  832.     19, 20, 21, 22, 23, 24,
  833.     23, 24, 25, 26, 27, 28,
  834.     27, 28, 29, 30, 31, 0,
  835.     };
  836.  
  837.     static obpb1 tmp32[32];
  838.     static obpb1 tmpP32[32];
  839.     static obpb1 tmpE[48];
  840.  
  841.     int j, k, i;
  842.     int tablenoX4;
  843.     reg sbpb24 spare24;
  844.  
  845.     tablenoX4 = tableno * 4;
  846.  
  847.     for (j = 0; j < 64; j++)
  848.     {
  849.     k = lookupS (tableno, j);
  850.  
  851.     for (i = 0; i < 32; i++)
  852.     {
  853.         tmp32[i] = 0;
  854.     }
  855.  
  856.     for (i = 0; i < 4; i++)
  857.     {
  858.         tmp32[tablenoX4 + i] = (k >> i) & 01;
  859.     }
  860.  
  861.     for (i = 0; i < 32; i++)
  862.     {
  863.         tmpP32[i] = tmp32[P[i]];
  864.     }
  865.  
  866.     for (i = 0; i < 48; i++)
  867.     {
  868.         tmpE[i] = tmpP32[E[i]];
  869.     }
  870.  
  871.     lowptr[j] = 0L;
  872.     highptr[j] = 0L;
  873.  
  874.     for (i = 0; i < 24; i++)
  875.     {
  876.         lowptr[j] |= (unsigned long) tmpE[i] << i;
  877.     }
  878.  
  879.     for (k = 0, i = 24; i < 48; i++, k++)
  880.     {
  881.         highptr[j] |= (unsigned long) tmpE[i] << k;
  882.     }
  883.  
  884.     spare24 = lowptr[j];    /* to allow for macro expansion */
  885.     lowptr[j] = TF_TO_SIXBIT (spare24);
  886.  
  887.     spare24 = highptr[j];    /* to allow for macro expansion */
  888.     highptr[j] = TF_TO_SIXBIT (spare24);
  889.     }
  890. }
  891.  
  892.  
  893. int
  894. init_des ()
  895. {
  896.     init (0L, S0L, S0H);
  897.     init (1L, S1L, S1H);
  898.     init (2L, S2L, S2H);
  899.     init (3L, S3L, S3H);
  900.     init (4L, S4L, S4H);
  901.     init (5L, S5L, S5H);
  902.     init (6L, S6L, S6H);
  903.     init (7L, S7L, S7H);
  904.     return (0);
  905. }
  906.