crypt2.cc Source File

00001 /****************************************************************************
00002  * crypt2.cc
00003  *
00004  * This file was converted to C++ from Java by Will Shackleford
00005  * on 25-Mar-1997, after downloading http://www.zeh.com/local/jfd/crypt.html
00006  * which contained a java version, created by jdumas@zgs.com. Both
00007  * the C version and the Java version may eventually be used to add
00008  * security to NML.
00009  *
00010  * Java-based implementation of the unix crypt command
00011  *
00012  * Based upon C source code written by Eric Young, eay@psych.uq.oz.au
00013  *
00014  ****************************************************************************/
00015 
00016 
00017 #include "crypt2.hh"
00018 
00019 #include <string.h>
00020 
00021 
00022 #ifndef DEBUG_CRYPT
00023 #ifndef NO_CRYPT_MAIN
00024 #define NO_CRYPT_MAIN
00025 #endif
00026 #endif
00027 
00028 #ifndef NO_CRYPT_MAIN
00029 #include <stdio.h>
00030 #else
00031 #ifdef DEBUG_CRYPT
00032 #undef DEBUG_CRYPT
00033 #endif
00034 #endif
00035 
00036 #define ITERATIONS (16)
00037 
00038 unsigned int con_salt[] = {
00039   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00040   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00041   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00042   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00043   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00044   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
00045   0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
00046   0x0A, 0x0B, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
00047   0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
00048   0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A,
00049   0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22,
00050   0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
00051   0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C,
00052   0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34,
00053   0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C,
00054   0x3D, 0x3E, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00,
00055 };
00056 
00057 unsigned int shifts2[] = {
00058   0, 0, 1, 1, 1, 1, 1, 1,
00059   0, 1, 1, 1, 1, 1, 1, 0
00060 };
00061 
00062 unsigned int skb[8][64] = {
00063   {
00064    /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
00065    0x00000000, 0x00000010, 0x20000000, 0x20000010,
00066    0x00010000, 0x00010010, 0x20010000, 0x20010010,
00067    0x00000800, 0x00000810, 0x20000800, 0x20000810,
00068    0x00010800, 0x00010810, 0x20010800, 0x20010810,
00069    0x00000020, 0x00000030, 0x20000020, 0x20000030,
00070    0x00010020, 0x00010030, 0x20010020, 0x20010030,
00071    0x00000820, 0x00000830, 0x20000820, 0x20000830,
00072    0x00010820, 0x00010830, 0x20010820, 0x20010830,
00073    0x00080000, 0x00080010, 0x20080000, 0x20080010,
00074    0x00090000, 0x00090010, 0x20090000, 0x20090010,
00075    0x00080800, 0x00080810, 0x20080800, 0x20080810,
00076    0x00090800, 0x00090810, 0x20090800, 0x20090810,
00077    0x00080020, 0x00080030, 0x20080020, 0x20080030,
00078    0x00090020, 0x00090030, 0x20090020, 0x20090030,
00079    0x00080820, 0x00080830, 0x20080820, 0x20080830,
00080    0x00090820, 0x00090830, 0x20090820, 0x20090830,
00081    },
00082   {
00083    /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
00084    0x00000000, 0x02000000, 0x00002000, 0x02002000,
00085    0x00200000, 0x02200000, 0x00202000, 0x02202000,
00086    0x00000004, 0x02000004, 0x00002004, 0x02002004,
00087    0x00200004, 0x02200004, 0x00202004, 0x02202004,
00088    0x00000400, 0x02000400, 0x00002400, 0x02002400,
00089    0x00200400, 0x02200400, 0x00202400, 0x02202400,
00090    0x00000404, 0x02000404, 0x00002404, 0x02002404,
00091    0x00200404, 0x02200404, 0x00202404, 0x02202404,
00092    0x10000000, 0x12000000, 0x10002000, 0x12002000,
00093    0x10200000, 0x12200000, 0x10202000, 0x12202000,
00094    0x10000004, 0x12000004, 0x10002004, 0x12002004,
00095    0x10200004, 0x12200004, 0x10202004, 0x12202004,
00096    0x10000400, 0x12000400, 0x10002400, 0x12002400,
00097    0x10200400, 0x12200400, 0x10202400, 0x12202400,
00098    0x10000404, 0x12000404, 0x10002404, 0x12002404,
00099    0x10200404, 0x12200404, 0x10202404, 0x12202404,
00100    },
00101   {
00102    /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
00103    0x00000000, 0x00000001, 0x00040000, 0x00040001,
00104    0x01000000, 0x01000001, 0x01040000, 0x01040001,
00105    0x00000002, 0x00000003, 0x00040002, 0x00040003,
00106    0x01000002, 0x01000003, 0x01040002, 0x01040003,
00107    0x00000200, 0x00000201, 0x00040200, 0x00040201,
00108    0x01000200, 0x01000201, 0x01040200, 0x01040201,
00109    0x00000202, 0x00000203, 0x00040202, 0x00040203,
00110    0x01000202, 0x01000203, 0x01040202, 0x01040203,
00111    0x08000000, 0x08000001, 0x08040000, 0x08040001,
00112    0x09000000, 0x09000001, 0x09040000, 0x09040001,
00113    0x08000002, 0x08000003, 0x08040002, 0x08040003,
00114    0x09000002, 0x09000003, 0x09040002, 0x09040003,
00115    0x08000200, 0x08000201, 0x08040200, 0x08040201,
00116    0x09000200, 0x09000201, 0x09040200, 0x09040201,
00117    0x08000202, 0x08000203, 0x08040202, 0x08040203,
00118    0x09000202, 0x09000203, 0x09040202, 0x09040203,
00119    },
00120   {
00121    /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
00122    0x00000000, 0x00100000, 0x00000100, 0x00100100,
00123    0x00000008, 0x00100008, 0x00000108, 0x00100108,
00124    0x00001000, 0x00101000, 0x00001100, 0x00101100,
00125    0x00001008, 0x00101008, 0x00001108, 0x00101108,
00126    0x04000000, 0x04100000, 0x04000100, 0x04100100,
00127    0x04000008, 0x04100008, 0x04000108, 0x04100108,
00128    0x04001000, 0x04101000, 0x04001100, 0x04101100,
00129    0x04001008, 0x04101008, 0x04001108, 0x04101108,
00130    0x00020000, 0x00120000, 0x00020100, 0x00120100,
00131    0x00020008, 0x00120008, 0x00020108, 0x00120108,
00132    0x00021000, 0x00121000, 0x00021100, 0x00121100,
00133    0x00021008, 0x00121008, 0x00021108, 0x00121108,
00134    0x04020000, 0x04120000, 0x04020100, 0x04120100,
00135    0x04020008, 0x04120008, 0x04020108, 0x04120108,
00136    0x04021000, 0x04121000, 0x04021100, 0x04121100,
00137    0x04021008, 0x04121008, 0x04021108, 0x04121108,
00138    },
00139   {
00140    /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
00141    0x00000000, 0x10000000, 0x00010000, 0x10010000,
00142    0x00000004, 0x10000004, 0x00010004, 0x10010004,
00143    0x20000000, 0x30000000, 0x20010000, 0x30010000,
00144    0x20000004, 0x30000004, 0x20010004, 0x30010004,
00145    0x00100000, 0x10100000, 0x00110000, 0x10110000,
00146    0x00100004, 0x10100004, 0x00110004, 0x10110004,
00147    0x20100000, 0x30100000, 0x20110000, 0x30110000,
00148    0x20100004, 0x30100004, 0x20110004, 0x30110004,
00149    0x00001000, 0x10001000, 0x00011000, 0x10011000,
00150    0x00001004, 0x10001004, 0x00011004, 0x10011004,
00151    0x20001000, 0x30001000, 0x20011000, 0x30011000,
00152    0x20001004, 0x30001004, 0x20011004, 0x30011004,
00153    0x00101000, 0x10101000, 0x00111000, 0x10111000,
00154    0x00101004, 0x10101004, 0x00111004, 0x10111004,
00155    0x20101000, 0x30101000, 0x20111000, 0x30111000,
00156    0x20101004, 0x30101004, 0x20111004, 0x30111004,
00157    },
00158   {
00159    /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
00160    0x00000000, 0x08000000, 0x00000008, 0x08000008,
00161    0x00000400, 0x08000400, 0x00000408, 0x08000408,
00162    0x00020000, 0x08020000, 0x00020008, 0x08020008,
00163    0x00020400, 0x08020400, 0x00020408, 0x08020408,
00164    0x00000001, 0x08000001, 0x00000009, 0x08000009,
00165    0x00000401, 0x08000401, 0x00000409, 0x08000409,
00166    0x00020001, 0x08020001, 0x00020009, 0x08020009,
00167    0x00020401, 0x08020401, 0x00020409, 0x08020409,
00168    0x02000000, 0x0A000000, 0x02000008, 0x0A000008,
00169    0x02000400, 0x0A000400, 0x02000408, 0x0A000408,
00170    0x02020000, 0x0A020000, 0x02020008, 0x0A020008,
00171    0x02020400, 0x0A020400, 0x02020408, 0x0A020408,
00172    0x02000001, 0x0A000001, 0x02000009, 0x0A000009,
00173    0x02000401, 0x0A000401, 0x02000409, 0x0A000409,
00174    0x02020001, 0x0A020001, 0x02020009, 0x0A020009,
00175    0x02020401, 0x0A020401, 0x02020409, 0x0A020409,
00176    },
00177   {
00178    /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
00179    0x00000000, 0x00000100, 0x00080000, 0x00080100,
00180    0x01000000, 0x01000100, 0x01080000, 0x01080100,
00181    0x00000010, 0x00000110, 0x00080010, 0x00080110,
00182    0x01000010, 0x01000110, 0x01080010, 0x01080110,
00183    0x00200000, 0x00200100, 0x00280000, 0x00280100,
00184    0x01200000, 0x01200100, 0x01280000, 0x01280100,
00185    0x00200010, 0x00200110, 0x00280010, 0x00280110,
00186    0x01200010, 0x01200110, 0x01280010, 0x01280110,
00187    0x00000200, 0x00000300, 0x00080200, 0x00080300,
00188    0x01000200, 0x01000300, 0x01080200, 0x01080300,
00189    0x00000210, 0x00000310, 0x00080210, 0x00080310,
00190    0x01000210, 0x01000310, 0x01080210, 0x01080310,
00191    0x00200200, 0x00200300, 0x00280200, 0x00280300,
00192    0x01200200, 0x01200300, 0x01280200, 0x01280300,
00193    0x00200210, 0x00200310, 0x00280210, 0x00280310,
00194    0x01200210, 0x01200310, 0x01280210, 0x01280310,
00195    },
00196   {
00197    /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
00198    0x00000000, 0x04000000, 0x00040000, 0x04040000,
00199    0x00000002, 0x04000002, 0x00040002, 0x04040002,
00200    0x00002000, 0x04002000, 0x00042000, 0x04042000,
00201    0x00002002, 0x04002002, 0x00042002, 0x04042002,
00202    0x00000020, 0x04000020, 0x00040020, 0x04040020,
00203    0x00000022, 0x04000022, 0x00040022, 0x04040022,
00204    0x00002020, 0x04002020, 0x00042020, 0x04042020,
00205    0x00002022, 0x04002022, 0x00042022, 0x04042022,
00206    0x00000800, 0x04000800, 0x00040800, 0x04040800,
00207    0x00000802, 0x04000802, 0x00040802, 0x04040802,
00208    0x00002800, 0x04002800, 0x00042800, 0x04042800,
00209    0x00002802, 0x04002802, 0x00042802, 0x04042802,
00210    0x00000820, 0x04000820, 0x00040820, 0x04040820,
00211    0x00000822, 0x04000822, 0x00040822, 0x04040822,
00212    0x00002820, 0x04002820, 0x00042820, 0x04042820,
00213    0x00002822, 0x04002822, 0x00042822, 0x04042822,
00214    },
00215 };
00216 
00217 unsigned int SPtrans[8][64] = {
00218   {
00219    /* nibble 0 */
00220    0x00820200, 0x00020000, 0x80800000, 0x80820200,
00221    0x00800000, 0x80020200, 0x80020000, 0x80800000,
00222    0x80020200, 0x00820200, 0x00820000, 0x80000200,
00223    0x80800200, 0x00800000, 0x00000000, 0x80020000,
00224    0x00020000, 0x80000000, 0x00800200, 0x00020200,
00225    0x80820200, 0x00820000, 0x80000200, 0x00800200,
00226    0x80000000, 0x00000200, 0x00020200, 0x80820000,
00227    0x00000200, 0x80800200, 0x80820000, 0x00000000,
00228    0x00000000, 0x80820200, 0x00800200, 0x80020000,
00229    0x00820200, 0x00020000, 0x80000200, 0x00800200,
00230    0x80820000, 0x00000200, 0x00020200, 0x80800000,
00231    0x80020200, 0x80000000, 0x80800000, 0x00820000,
00232    0x80820200, 0x00020200, 0x00820000, 0x80800200,
00233    0x00800000, 0x80000200, 0x80020000, 0x00000000,
00234    0x00020000, 0x00800000, 0x80800200, 0x00820200,
00235    0x80000000, 0x80820000, 0x00000200, 0x80020200,
00236    },
00237   {
00238    /* nibble 1 */
00239    0x10042004, 0x00000000, 0x00042000, 0x10040000,
00240    0x10000004, 0x00002004, 0x10002000, 0x00042000,
00241    0x00002000, 0x10040004, 0x00000004, 0x10002000,
00242    0x00040004, 0x10042000, 0x10040000, 0x00000004,
00243    0x00040000, 0x10002004, 0x10040004, 0x00002000,
00244    0x00042004, 0x10000000, 0x00000000, 0x00040004,
00245    0x10002004, 0x00042004, 0x10042000, 0x10000004,
00246    0x10000000, 0x00040000, 0x00002004, 0x10042004,
00247    0x00040004, 0x10042000, 0x10002000, 0x00042004,
00248    0x10042004, 0x00040004, 0x10000004, 0x00000000,
00249    0x10000000, 0x00002004, 0x00040000, 0x10040004,
00250    0x00002000, 0x10000000, 0x00042004, 0x10002004,
00251    0x10042000, 0x00002000, 0x00000000, 0x10000004,
00252    0x00000004, 0x10042004, 0x00042000, 0x10040000,
00253    0x10040004, 0x00040000, 0x00002004, 0x10002000,
00254    0x10002004, 0x00000004, 0x10040000, 0x00042000,
00255    },
00256   {
00257    /* nibble 2 */
00258    0x41000000, 0x01010040, 0x00000040, 0x41000040,
00259    0x40010000, 0x01000000, 0x41000040, 0x00010040,
00260    0x01000040, 0x00010000, 0x01010000, 0x40000000,
00261    0x41010040, 0x40000040, 0x40000000, 0x41010000,
00262    0x00000000, 0x40010000, 0x01010040, 0x00000040,
00263    0x40000040, 0x41010040, 0x00010000, 0x41000000,
00264    0x41010000, 0x01000040, 0x40010040, 0x01010000,
00265    0x00010040, 0x00000000, 0x01000000, 0x40010040,
00266    0x01010040, 0x00000040, 0x40000000, 0x00010000,
00267    0x40000040, 0x40010000, 0x01010000, 0x41000040,
00268    0x00000000, 0x01010040, 0x00010040, 0x41010000,
00269    0x40010000, 0x01000000, 0x41010040, 0x40000000,
00270    0x40010040, 0x41000000, 0x01000000, 0x41010040,
00271    0x00010000, 0x01000040, 0x41000040, 0x00010040,
00272    0x01000040, 0x00000000, 0x41010000, 0x40000040,
00273    0x41000000, 0x40010040, 0x00000040, 0x01010000,
00274    },
00275   {
00276    /* nibble 3 */
00277    0x00100402, 0x04000400, 0x00000002, 0x04100402,
00278    0x00000000, 0x04100000, 0x04000402, 0x00100002,
00279    0x04100400, 0x04000002, 0x04000000, 0x00000402,
00280    0x04000002, 0x00100402, 0x00100000, 0x04000000,
00281    0x04100002, 0x00100400, 0x00000400, 0x00000002,
00282    0x00100400, 0x04000402, 0x04100000, 0x00000400,
00283    0x00000402, 0x00000000, 0x00100002, 0x04100400,
00284    0x04000400, 0x04100002, 0x04100402, 0x00100000,
00285    0x04100002, 0x00000402, 0x00100000, 0x04000002,
00286    0x00100400, 0x04000400, 0x00000002, 0x04100000,
00287    0x04000402, 0x00000000, 0x00000400, 0x00100002,
00288    0x00000000, 0x04100002, 0x04100400, 0x00000400,
00289    0x04000000, 0x04100402, 0x00100402, 0x00100000,
00290    0x04100402, 0x00000002, 0x04000400, 0x00100402,
00291    0x00100002, 0x00100400, 0x04100000, 0x04000402,
00292    0x00000402, 0x04000000, 0x04000002, 0x04100400,
00293    },
00294   {
00295    /* nibble 4 */
00296    0x02000000, 0x00004000, 0x00000100, 0x02004108,
00297    0x02004008, 0x02000100, 0x00004108, 0x02004000,
00298    0x00004000, 0x00000008, 0x02000008, 0x00004100,
00299    0x02000108, 0x02004008, 0x02004100, 0x00000000,
00300    0x00004100, 0x02000000, 0x00004008, 0x00000108,
00301    0x02000100, 0x00004108, 0x00000000, 0x02000008,
00302    0x00000008, 0x02000108, 0x02004108, 0x00004008,
00303    0x02004000, 0x00000100, 0x00000108, 0x02004100,
00304    0x02004100, 0x02000108, 0x00004008, 0x02004000,
00305    0x00004000, 0x00000008, 0x02000008, 0x02000100,
00306    0x02000000, 0x00004100, 0x02004108, 0x00000000,
00307    0x00004108, 0x02000000, 0x00000100, 0x00004008,
00308    0x02000108, 0x00000100, 0x00000000, 0x02004108,
00309    0x02004008, 0x02004100, 0x00000108, 0x00004000,
00310    0x00004100, 0x02004008, 0x02000100, 0x00000108,
00311    0x00000008, 0x00004108, 0x02004000, 0x02000008,
00312    },
00313   {
00314    /* nibble 5 */
00315    0x20000010, 0x00080010, 0x00000000, 0x20080800,
00316    0x00080010, 0x00000800, 0x20000810, 0x00080000,
00317    0x00000810, 0x20080810, 0x00080800, 0x20000000,
00318    0x20000800, 0x20000010, 0x20080000, 0x00080810,
00319    0x00080000, 0x20000810, 0x20080010, 0x00000000,
00320    0x00000800, 0x00000010, 0x20080800, 0x20080010,
00321    0x20080810, 0x20080000, 0x20000000, 0x00000810,
00322    0x00000010, 0x00080800, 0x00080810, 0x20000800,
00323    0x00000810, 0x20000000, 0x20000800, 0x00080810,
00324    0x20080800, 0x00080010, 0x00000000, 0x20000800,
00325    0x20000000, 0x00000800, 0x20080010, 0x00080000,
00326    0x00080010, 0x20080810, 0x00080800, 0x00000010,
00327    0x20080810, 0x00080800, 0x00080000, 0x20000810,
00328    0x20000010, 0x20080000, 0x00080810, 0x00000000,
00329    0x00000800, 0x20000010, 0x20000810, 0x20080800,
00330    0x20080000, 0x00000810, 0x00000010, 0x20080010,
00331    },
00332   {
00333    /* nibble 6 */
00334    0x00001000, 0x00000080, 0x00400080, 0x00400001,
00335    0x00401081, 0x00001001, 0x00001080, 0x00000000,
00336    0x00400000, 0x00400081, 0x00000081, 0x00401000,
00337    0x00000001, 0x00401080, 0x00401000, 0x00000081,
00338    0x00400081, 0x00001000, 0x00001001, 0x00401081,
00339    0x00000000, 0x00400080, 0x00400001, 0x00001080,
00340    0x00401001, 0x00001081, 0x00401080, 0x00000001,
00341    0x00001081, 0x00401001, 0x00000080, 0x00400000,
00342    0x00001081, 0x00401000, 0x00401001, 0x00000081,
00343    0x00001000, 0x00000080, 0x00400000, 0x00401001,
00344    0x00400081, 0x00001081, 0x00001080, 0x00000000,
00345    0x00000080, 0x00400001, 0x00000001, 0x00400080,
00346    0x00000000, 0x00400081, 0x00400080, 0x00001080,
00347    0x00000081, 0x00001000, 0x00401081, 0x00400000,
00348    0x00401080, 0x00000001, 0x00001001, 0x00401081,
00349    0x00400001, 0x00401080, 0x00401000, 0x00001001,
00350    },
00351   {
00352    /* nibble 7 */
00353    0x08200020, 0x08208000, 0x00008020, 0x00000000,
00354    0x08008000, 0x00200020, 0x08200000, 0x08208020,
00355    0x00000020, 0x08000000, 0x00208000, 0x00008020,
00356    0x00208020, 0x08008020, 0x08000020, 0x08200000,
00357    0x00008000, 0x00208020, 0x00200020, 0x08008000,
00358    0x08208020, 0x08000020, 0x00000000, 0x00208000,
00359    0x08000000, 0x00200000, 0x08008020, 0x08200020,
00360    0x00200000, 0x00008000, 0x08208000, 0x00000020,
00361    0x00200000, 0x00008000, 0x08000020, 0x08208020,
00362    0x00008020, 0x08000000, 0x00000000, 0x00208000,
00363    0x08200020, 0x08008020, 0x08008000, 0x00200020,
00364    0x08208000, 0x00000020, 0x00200020, 0x08008000,
00365    0x08208020, 0x00200000, 0x08200000, 0x08000020,
00366    0x00208000, 0x00008020, 0x08008020, 0x08200000,
00367    0x00000020, 0x08208000, 0x00208020, 0x00000000,
00368    0x08000000, 0x08200020, 0x00008000, 0x00208020}
00369 };
00370 
00371 unsigned int cov_2char[] = {
00372   0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
00373   0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
00374   0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
00375   0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
00376   0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62,
00377   0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
00378   0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72,
00379   0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
00380 };
00381 
00382 unsigned int
00383 charToUnsigned (unsigned char b)
00384 {
00385   unsigned int value = (unsigned int) b;
00386 
00387   return (value);
00388 }
00389 
00390 unsigned int
00391 fourCharsToInt (unsigned char b[], unsigned int offset)
00392 {
00393   unsigned int value;
00394 
00395   value = charToUnsigned (b[offset++]);
00396   value |= (charToUnsigned (b[offset++]) << 8);
00397   value |= (charToUnsigned (b[offset++]) << 16);
00398   value |= (charToUnsigned (b[offset++]) << 24);
00399 
00400   return (value);
00401 }
00402 
00403 void
00404 intToFourChars (unsigned int iValue, unsigned char b[], unsigned int offset)
00405 {
00406   b[offset++] = (unsigned char) ((iValue) & 0xff);
00407   b[offset++] = (unsigned char) ((iValue >> 8) & 0xff);
00408   b[offset++] = (unsigned char) ((iValue >> 16) & 0xff);
00409   b[offset++] = (unsigned char) ((iValue >> 24) & 0xff);
00410 }
00411 
00412 void
00413 PERM_OP (unsigned int a, unsigned int b, unsigned int n, unsigned int m,
00414          unsigned int results[])
00415 {
00416   unsigned int t;
00417 #ifdef DEBUG_CRYPT
00418   printf ("PERM_OP(%8.8X,%8.8X,%d,%d,results[]) called.\n", a, b, n, m);
00419 #endif
00420 
00421   t = ((a >> n) ^ b) & m;
00422   a ^= t << n;
00423   b ^= t;
00424 
00425   results[0] = a;
00426   results[1] = b;
00427 #ifdef DEBUG_CRYPT
00428   printf ("PERM_OP(): results[] =  %8.8X , %8.8X .\n", a, b);
00429 #endif
00430 
00431 }
00432 
00433 unsigned int
00434 HPERM_OP (unsigned int a, int n, unsigned int m)
00435 {
00436   unsigned int t;
00437 
00438   t = ((a << (16 - n)) ^ a) & m;
00439   a = a ^ t ^ (t >> (16 - n));
00440 
00441   return (a);
00442 }
00443 
00444 unsigned int *
00445 des_set_key (unsigned char *key)
00446 {
00447   static unsigned int schedule[ITERATIONS * 2];
00448 
00449   unsigned int c = fourCharsToInt (key, 0);
00450   unsigned int d = fourCharsToInt (key, 4);
00451 
00452   unsigned int results[2];
00453 
00454   PERM_OP (d, c, 4, 0x0f0f0f0f, results);
00455   d = results[0];
00456   c = results[1];
00457 
00458   c = HPERM_OP (c, -2, 0xcccc0000);
00459   d = HPERM_OP (d, -2, 0xcccc0000);
00460 
00461   PERM_OP (d, c, 1, 0x55555555, results);
00462   d = results[0];
00463   c = results[1];
00464 
00465   PERM_OP (c, d, 8, 0x00ff00ff, results);
00466   c = results[0];
00467   d = results[1];
00468 
00469   PERM_OP (d, c, 1, 0x55555555, results);
00470   d = results[0];
00471   c = results[1];
00472 
00473   d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) |
00474        ((d & 0x00ff0000) >> 16) | ((c & 0xf0000000) >> 4));
00475   c &= 0x0fffffff;
00476 
00477   unsigned int s, t;
00478   unsigned int j = 0;
00479 
00480   for (unsigned int i = 0; i < ITERATIONS; i++)
00481     {
00482       if (shifts2[i])
00483         {
00484           c = (c >> 2) | (c << 26);
00485           d = (d >> 2) | (d << 26);
00486         }
00487       else
00488         {
00489           c = (c >> 1) | (c << 27);
00490           d = (d >> 1) | (d << 27);
00491         }
00492 
00493       c &= 0x0fffffff;
00494       d &= 0x0fffffff;
00495 
00496       s = skb[0][(c) & 0x3f] |
00497         skb[1][((c >> 6) & 0x03) | ((c >> 7) & 0x3c)] |
00498         skb[2][((c >> 13) & 0x0f) | ((c >> 14) & 0x30)] |
00499         skb[3][((c >> 20) & 0x01) | ((c >> 21) & 0x06) | ((c >> 22) & 0x38)];
00500 
00501       t = skb[4][(d) & 0x3f] |
00502         skb[5][((d >> 7) & 0x03) | ((d >> 8) & 0x3c)] |
00503         skb[6][(d >> 15) & 0x3f] |
00504         skb[7][((d >> 21) & 0x0f) | ((d >> 22) & 0x30)];
00505 
00506 #ifdef DEBUG_CRYPT
00507       printf
00508         ("des_set_key() : i = %d, c = %8.8X, d = %8.8X, s = %8.8X, t = %8.8X\n",
00509          i, c, d, s, t);
00510 #endif
00511 
00512       schedule[j++] = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff;
00513       s = ((s >> 16) | (t & 0xffff0000));
00514 #ifdef DEBUG_CRYPT
00515       printf ("des_set_key() : s = %8.8X, schedule[%d] = %8.8X\n", s, j - 1,
00516               schedule[j - 1]);
00517 #endif
00518 
00519       s = (s << 4) | (s >> 28);
00520       schedule[j++] = s & 0xffffffff;
00521 #ifdef DEBUG_CRYPT
00522       printf ("des_set_key() : s = %8.8X, schedule[%d] = %8.8X\n", s, j - 1,
00523               schedule[j - 1]);
00524 #endif
00525     }
00526   return (schedule);
00527 }
00528 
00529 unsigned int
00530 D_ENCRYPT (unsigned int L, unsigned int R, unsigned int S, unsigned int E0,
00531            unsigned int E1, unsigned int s[])
00532 {
00533   unsigned int t, u, v;
00534 
00535   v = R ^ (R >> 16);
00536   u = v & E0;
00537   v = v & E1;
00538   u = (u ^ (u << 16)) ^ R ^ s[S];
00539   t = (v ^ (v << 16)) ^ R ^ s[S + 1];
00540   t = (t >> 4) | (t << 28);
00541 
00542   L ^= SPtrans[1][(t) & 0x3f] |
00543     SPtrans[3][(t >> 8) & 0x3f] |
00544     SPtrans[5][(t >> 16) & 0x3f] |
00545     SPtrans[7][(t >> 24) & 0x3f] |
00546     SPtrans[0][(u) & 0x3f] |
00547     SPtrans[2][(u >> 8) & 0x3f] |
00548     SPtrans[4][(u >> 16) & 0x3f] | SPtrans[6][(u >> 24) & 0x3f];
00549 
00550   return (L);
00551 }
00552 
00553 unsigned int *
00554 body (unsigned int *schedule, unsigned int Eswap0, unsigned int Eswap1)
00555 {
00556   unsigned int left = 0;
00557   unsigned int right = 0;
00558   unsigned int t = 0;
00559 
00560   for (unsigned int j = 0; j < 25; j++)
00561     {
00562       for (unsigned int i = 0; i < ITERATIONS * 2; i += 4)
00563         {
00564           left = D_ENCRYPT (left, right, i, Eswap0, Eswap1, schedule);
00565           right = D_ENCRYPT (right, left, i + 2, Eswap0, Eswap1, schedule);
00566         }
00567       t = left;
00568       left = right;
00569       right = t;
00570     }
00571 
00572   t = right;
00573 
00574   right = (left >> 1) | (left << 31);
00575   left = (t >> 1) | (t << 31);
00576 
00577   left &= 0xffffffff;
00578   right &= 0xffffffff;
00579 
00580   unsigned int results[2];
00581 
00582   PERM_OP (right, left, 1, 0x55555555, results);
00583   right = results[0];
00584   left = results[1];
00585 
00586   PERM_OP (left, right, 8, 0x00ff00ff, results);
00587   left = results[0];
00588   right = results[1];
00589 
00590   PERM_OP (right, left, 2, 0x33333333, results);
00591   right = results[0];
00592   left = results[1];
00593 
00594   PERM_OP (left, right, 16, 0x0000ffff, results);
00595   left = results[0];
00596   right = results[1];
00597 
00598   PERM_OP (right, left, 4, 0x0f0f0f0f, results);
00599   right = results[0];
00600   left = results[1];
00601 
00602   static unsigned int out[2];
00603 
00604   out[0] = left;
00605   out[1] = right;
00606 
00607   return (out);
00608 }
00609 
00610 char *
00611 rcs_crypt (const char *original, const char *salt)
00612 {
00613 //  rcs_print("encrypting %s with %s\n", original, salt);
00614   unsigned int i, y, u;
00615 
00616   if (strlen (salt) < 2)
00617     return NULL;
00618 
00619   static unsigned char buffer[256];
00620   memset (buffer, 0, 256);
00621 
00622   unsigned char charZero = (unsigned char) salt[(0)];
00623   unsigned char charOne = (unsigned char) salt[(1)];
00624 
00625   buffer[0] = charZero;
00626   buffer[1] = charOne;
00627 
00628   unsigned int Eswap0 = con_salt[(unsigned int) charZero];
00629   unsigned int Eswap1 = con_salt[(unsigned int) charOne] << 4;
00630 
00631   unsigned char key[8];
00632 
00633   for (i = 0; i < 8; i++)
00634     key[i] = (char) 0;
00635 
00636 #ifdef DEBUG_CRYPT
00637   printf ("original = %s\n", original);
00638 #endif
00639 
00640   for (i = 0; i < 8 && i < strlen (original); i++)
00641     {
00642       unsigned int iChar = (unsigned int) original[(i)];
00643 
00644       key[i] = (unsigned char) (iChar << 1);
00645     }
00646 #ifdef DEBUG_CRYPT
00647   printf ("key = ");
00648   for (int jj = 0; jj < 8; jj++)
00649     {
00650       if (jj % 8 == 0)
00651         {
00652           printf ("\n");
00653         }
00654       printf (" %8.8X ", key[jj]);
00655     }
00656   printf ("\n");
00657 #endif
00658 
00659   unsigned int *schedule = des_set_key (key);
00660 #ifdef DEBUG_CRYPT
00661   printf ("schedule = ");
00662   for (int ii = 0; ii < ITERATIONS * 2; ii++)
00663     {
00664       if (ii % 8 == 0)
00665         {
00666           printf ("\n");
00667         }
00668       printf (" %8.8X ", schedule[ii]);
00669     }
00670   printf ("\n");
00671 #endif
00672 
00673   unsigned int *out = body (schedule, Eswap0, Eswap1);
00674 #ifdef DEBUG_CRYPT
00675   printf ("out = ");
00676   for (int iii = 0; iii < 2; iii++)
00677     {
00678       printf (" %8.8X ", out[iii]);
00679     }
00680   printf ("\n");
00681 #endif
00682 
00683   unsigned char b[9];
00684 
00685   intToFourChars (out[0], b, 0);
00686   intToFourChars (out[1], b, 4);
00687   b[8] = 0;
00688 
00689   for (i = 2, y = 0, u = 0x80; i < 13; i++)
00690     {
00691       for (unsigned int j = 0, c = 0; j < 6; j++)
00692         {
00693           c <<= 1;
00694 
00695           if (((unsigned int) b[y] & u) != 0)
00696             c |= 1;
00697 
00698           u = u >> 1;
00699 
00700           if (u == 0)
00701             {
00702               y++;
00703               u = 0x80;
00704             }
00705           buffer[i] = (unsigned char) cov_2char[c];
00706         }
00707     }
00708   return ((char *) buffer);
00709 }
00710 
00711 #ifndef NO_CRYPT_MAIN
00712 
00713 int
00714 main (int argc, char **argv)
00715 {
00716   if (argc >= 2)
00717     {
00718       puts (rcs_crypt (argv[2], argv[1]));
00719       return 0;
00720     }
00721   return -1;
00722 }
00723 #endif