Thread: unix crypt port

    #1
  1. No Profile Picture
    Contributing User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Jun 2000
    Posts
    60
    Rep Power
    15
    I'm trying to port the unix crypt into PHP because I'm on WinNT (not my fault). I found in Java at http://208.223.9.21/jfd/crypt.html and this is what I currently have as the PHP source, but it always gives me the salt + 0 (e.g. Ts0) Could anyone help me?:

    <BLOCKQUOTE><font size="1" face="Verdana,Arial,Helvetica">code:</font><HR><pre>
    <?
    // Usage:
    // newcryptedpass = uCrypt(randsalt(), plaintextpass);
    // issamepass = (cryptedpass == uCrypt(cryptedpass, plaintextpass));

    $iIterations = 16;

    $aConSalt = array(
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
    0x0A, 0x0B, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
    0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
    0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A,
    0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22,
    0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
    0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C,
    0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34,
    0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C,
    0x3D, 0x3E, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00,
    );

    $bShifts2 = array(
    false, false, true, true, true, true, true, true,
    false, true, true, true, true, true, true, false
    );

    $aSkb = array(
    array(
    // for C bits (numbered as per FIPS 46) 1 2 3 4 5 6
    0x00000000, 0x00000010, 0x20000000, 0x20000010,
    0x00010000, 0x00010010, 0x20010000, 0x20010010,
    0x00000800, 0x00000810, 0x20000800, 0x20000810,
    0x00010800, 0x00010810, 0x20010800, 0x20010810,
    0x00000020, 0x00000030, 0x20000020, 0x20000030,
    0x00010020, 0x00010030, 0x20010020, 0x20010030,
    0x00000820, 0x00000830, 0x20000820, 0x20000830,
    0x00010820, 0x00010830, 0x20010820, 0x20010830,
    0x00080000, 0x00080010, 0x20080000, 0x20080010,
    0x00090000, 0x00090010, 0x20090000, 0x20090010,
    0x00080800, 0x00080810, 0x20080800, 0x20080810,
    0x00090800, 0x00090810, 0x20090800, 0x20090810,
    0x00080020, 0x00080030, 0x20080020, 0x20080030,
    0x00090020, 0x00090030, 0x20090020, 0x20090030,
    0x00080820, 0x00080830, 0x20080820, 0x20080830,
    0x00090820, 0x00090830, 0x20090820, 0x20090830
    ),
    array(
    // for C bits (numbered as per FIPS 46) 7 8 10 11 12 13
    0x00000000, 0x02000000, 0x00002000, 0x02002000,
    0x00200000, 0x02200000, 0x00202000, 0x02202000,
    0x00000004, 0x02000004, 0x00002004, 0x02002004,
    0x00200004, 0x02200004, 0x00202004, 0x02202004,
    0x00000400, 0x02000400, 0x00002400, 0x02002400,
    0x00200400, 0x02200400, 0x00202400, 0x02202400,
    0x00000404, 0x02000404, 0x00002404, 0x02002404,
    0x00200404, 0x02200404, 0x00202404, 0x02202404,
    0x10000000, 0x12000000, 0x10002000, 0x12002000,
    0x10200000, 0x12200000, 0x10202000, 0x12202000,
    0x10000004, 0x12000004, 0x10002004, 0x12002004,
    0x10200004, 0x12200004, 0x10202004, 0x12202004,
    0x10000400, 0x12000400, 0x10002400, 0x12002400,
    0x10200400, 0x12200400, 0x10202400, 0x12202400,
    0x10000404, 0x12000404, 0x10002404, 0x12002404,
    0x10200404, 0x12200404, 0x10202404, 0x12202404
    ),
    array(
    // for C bits (numbered as per FIPS 46) 14 15 16 17 19 20
    0x00000000, 0x00000001, 0x00040000, 0x00040001,
    0x01000000, 0x01000001, 0x01040000, 0x01040001,
    0x00000002, 0x00000003, 0x00040002, 0x00040003,
    0x01000002, 0x01000003, 0x01040002, 0x01040003,
    0x00000200, 0x00000201, 0x00040200, 0x00040201,
    0x01000200, 0x01000201, 0x01040200, 0x01040201,
    0x00000202, 0x00000203, 0x00040202, 0x00040203,
    0x01000202, 0x01000203, 0x01040202, 0x01040203,
    0x08000000, 0x08000001, 0x08040000, 0x08040001,
    0x09000000, 0x09000001, 0x09040000, 0x09040001,
    0x08000002, 0x08000003, 0x08040002, 0x08040003,
    0x09000002, 0x09000003, 0x09040002, 0x09040003,
    0x08000200, 0x08000201, 0x08040200, 0x08040201,
    0x09000200, 0x09000201, 0x09040200, 0x09040201,
    0x08000202, 0x08000203, 0x08040202, 0x08040203,
    0x09000202, 0x09000203, 0x09040202, 0x09040203
    ),
    array(
    // for C bits (numbered as per FIPS 46) 21 23 24 26 27 28
    0x00000000, 0x00100000, 0x00000100, 0x00100100,
    0x00000008, 0x00100008, 0x00000108, 0x00100108,
    0x00001000, 0x00101000, 0x00001100, 0x00101100,
    0x00001008, 0x00101008, 0x00001108, 0x00101108,
    0x04000000, 0x04100000, 0x04000100, 0x04100100,
    0x04000008, 0x04100008, 0x04000108, 0x04100108,
    0x04001000, 0x04101000, 0x04001100, 0x04101100,
    0x04001008, 0x04101008, 0x04001108, 0x04101108,
    0x00020000, 0x00120000, 0x00020100, 0x00120100,
    0x00020008, 0x00120008, 0x00020108, 0x00120108,
    0x00021000, 0x00121000, 0x00021100, 0x00121100,
    0x00021008, 0x00121008, 0x00021108, 0x00121108,
    0x04020000, 0x04120000, 0x04020100, 0x04120100,
    0x04020008, 0x04120008, 0x04020108, 0x04120108,
    0x04021000, 0x04121000, 0x04021100, 0x04121100,
    0x04021008, 0x04121008, 0x04021108, 0x04121108
    ),
    array(
    // for D bits (numbered as per FIPS 46) 1 2 3 4 5 6
    0x00000000, 0x10000000, 0x00010000, 0x10010000,
    0x00000004, 0x10000004, 0x00010004, 0x10010004,
    0x20000000, 0x30000000, 0x20010000, 0x30010000,
    0x20000004, 0x30000004, 0x20010004, 0x30010004,
    0x00100000, 0x10100000, 0x00110000, 0x10110000,
    0x00100004, 0x10100004, 0x00110004, 0x10110004,
    0x20100000, 0x30100000, 0x20110000, 0x30110000,
    0x20100004, 0x30100004, 0x20110004, 0x30110004,
    0x00001000, 0x10001000, 0x00011000, 0x10011000,
    0x00001004, 0x10001004, 0x00011004, 0x10011004,
    0x20001000, 0x30001000, 0x20011000, 0x30011000,
    0x20001004, 0x30001004, 0x20011004, 0x30011004,
    0x00101000, 0x10101000, 0x00111000, 0x10111000,
    0x00101004, 0x10101004, 0x00111004, 0x10111004,
    0x20101000, 0x30101000, 0x20111000, 0x30111000,
    0x20101004, 0x30101004, 0x20111004, 0x30111004
    ),
    array(
    // for D bits (numbered as per FIPS 46) 8 9 11 12 13 14
    0x00000000, 0x08000000, 0x00000008, 0x08000008,
    0x00000400, 0x08000400, 0x00000408, 0x08000408,
    0x00020000, 0x08020000, 0x00020008, 0x08020008,
    0x00020400, 0x08020400, 0x00020408, 0x08020408,
    0x00000001, 0x08000001, 0x00000009, 0x08000009,
    0x00000401, 0x08000401, 0x00000409, 0x08000409,
    0x00020001, 0x08020001, 0x00020009, 0x08020009,
    0x00020401, 0x08020401, 0x00020409, 0x08020409,
    0x02000000, 0x0A000000, 0x02000008, 0x0A000008,
    0x02000400, 0x0A000400, 0x02000408, 0x0A000408,
    0x02020000, 0x0A020000, 0x02020008, 0x0A020008,
    0x02020400, 0x0A020400, 0x02020408, 0x0A020408,
    0x02000001, 0x0A000001, 0x02000009, 0x0A000009,
    0x02000401, 0x0A000401, 0x02000409, 0x0A000409,
    0x02020001, 0x0A020001, 0x02020009, 0x0A020009,
    0x02020401, 0x0A020401, 0x02020409, 0x0A020409
    ),
    array(
    // for D bits (numbered as per FIPS 46) 16 17 18 19 20 21
    0x00000000, 0x00000100, 0x00080000, 0x00080100,
    0x01000000, 0x01000100, 0x01080000, 0x01080100,
    0x00000010, 0x00000110, 0x00080010, 0x00080110,
    0x01000010, 0x01000110, 0x01080010, 0x01080110,
    0x00200000, 0x00200100, 0x00280000, 0x00280100,
    0x01200000, 0x01200100, 0x01280000, 0x01280100,
    0x00200010, 0x00200110, 0x00280010, 0x00280110,
    0x01200010, 0x01200110, 0x01280010, 0x01280110,
    0x00000200, 0x00000300, 0x00080200, 0x00080300,
    0x01000200, 0x01000300, 0x01080200, 0x01080300,
    0x00000210, 0x00000310, 0x00080210, 0x00080310,
    0x01000210, 0x01000310, 0x01080210, 0x01080310,
    0x00200200, 0x00200300, 0x00280200, 0x00280300,
    0x01200200, 0x01200300, 0x01280200, 0x01280300,
    0x00200210, 0x00200310, 0x00280210, 0x00280310,
    0x01200210, 0x01200310, 0x01280210, 0x01280310
    ),
    array(
    // for D bits (numbered as per FIPS 46) 22 23 24 25 27 28
    0x00000000, 0x04000000, 0x00040000, 0x04040000,
    0x00000002, 0x04000002, 0x00040002, 0x04040002,
    0x00002000, 0x04002000, 0x00042000, 0x04042000,
    0x00002002, 0x04002002, 0x00042002, 0x04042002,
    0x00000020, 0x04000020, 0x00040020, 0x04040020,
    0x00000022, 0x04000022, 0x00040022, 0x04040022,
    0x00002020, 0x04002020, 0x00042020, 0x04042020,
    0x00002022, 0x04002022, 0x00042022, 0x04042022,
    0x00000800, 0x04000800, 0x00040800, 0x04040800,
    0x00000802, 0x04000802, 0x00040802, 0x04040802,
    0x00002800, 0x04002800, 0x00042800, 0x04042800,
    0x00002802, 0x04002802, 0x00042802, 0x04042802,
    0x00000820, 0x04000820, 0x00040820, 0x04040820,
    0x00000822, 0x04000822, 0x00040822, 0x04040822,
    0x00002820, 0x04002820, 0x00042820, 0x04042820,
    0x00002822, 0x04002822, 0x00042822, 0x04042822
    )
    );


    $aSPtrans = array(
    array(
    // nibble 0
    0x00820200, 0x00020000, 0x80800000, 0x80820200,
    0x00800000, 0x80020200, 0x80020000, 0x80800000,
    0x80020200, 0x00820200, 0x00820000, 0x80000200,
    0x80800200, 0x00800000, 0x00000000, 0x80020000,
    0x00020000, 0x80000000, 0x00800200, 0x00020200,
    0x80820200, 0x00820000, 0x80000200, 0x00800200,
    0x80000000, 0x00000200, 0x00020200, 0x80820000,
    0x00000200, 0x80800200, 0x80820000, 0x00000000,
    0x00000000, 0x80820200, 0x00800200, 0x80020000,
    0x00820200, 0x00020000, 0x80000200, 0x00800200,
    0x80820000, 0x00000200, 0x00020200, 0x80800000,
    0x80020200, 0x80000000, 0x80800000, 0x00820000,
    0x80820200, 0x00020200, 0x00820000, 0x80800200,
    0x00800000, 0x80000200, 0x80020000, 0x00000000,
    0x00020000, 0x00800000, 0x80800200, 0x00820200,
    0x80000000, 0x80820000, 0x00000200, 0x80020200
    ),
    array(
    // nibble 1
    0x10042004, 0x00000000, 0x00042000, 0x10040000,
    0x10000004, 0x00002004, 0x10002000, 0x00042000,
    0x00002000, 0x10040004, 0x00000004, 0x10002000,
    0x00040004, 0x10042000, 0x10040000, 0x00000004,
    0x00040000, 0x10002004, 0x10040004, 0x00002000,
    0x00042004, 0x10000000, 0x00000000, 0x00040004,
    0x10002004, 0x00042004, 0x10042000, 0x10000004,
    0x10000000, 0x00040000, 0x00002004, 0x10042004,
    0x00040004, 0x10042000, 0x10002000, 0x00042004,
    0x10042004, 0x00040004, 0x10000004, 0x00000000,
    0x10000000, 0x00002004, 0x00040000, 0x10040004,
    0x00002000, 0x10000000, 0x00042004, 0x10002004,
    0x10042000, 0x00002000, 0x00000000, 0x10000004,
    0x00000004, 0x10042004, 0x00042000, 0x10040000,
    0x10040004, 0x00040000, 0x00002004, 0x10002000,
    0x10002004, 0x00000004, 0x10040000, 0x00042000
    ),
    array(
    // nibble 2
    0x41000000, 0x01010040, 0x00000040, 0x41000040,
    0x40010000, 0x01000000, 0x41000040, 0x00010040,
    0x01000040, 0x00010000, 0x01010000, 0x40000000,
    0x41010040, 0x40000040, 0x40000000, 0x41010000,
    0x00000000, 0x40010000, 0x01010040, 0x00000040,
    0x40000040, 0x41010040, 0x00010000, 0x41000000,
    0x41010000, 0x01000040, 0x40010040, 0x01010000,
    0x00010040, 0x00000000, 0x01000000, 0x40010040,
    0x01010040, 0x00000040, 0x40000000, 0x00010000,
    0x40000040, 0x40010000, 0x01010000, 0x41000040,
    0x00000000, 0x01010040, 0x00010040, 0x41010000,
    0x40010000, 0x01000000, 0x41010040, 0x40000000,
    0x40010040, 0x41000000, 0x01000000, 0x41010040,
    0x00010000, 0x01000040, 0x41000040, 0x00010040,
    0x01000040, 0x00000000, 0x41010000, 0x40000040,
    0x41000000, 0x40010040, 0x00000040, 0x01010000
    ),
    array(
    // nibble 3
    0x00100402, 0x04000400, 0x00000002, 0x04100402,
    0x00000000, 0x04100000, 0x04000402, 0x00100002,
    0x04100400, 0x04000002, 0x04000000, 0x00000402,
    0x04000002, 0x00100402, 0x00100000, 0x04000000,
    0x04100002, 0x00100400, 0x00000400, 0x00000002,
    0x00100400, 0x04000402, 0x04100000, 0x00000400,
    0x00000402, 0x00000000, 0x00100002, 0x04100400,
    0x04000400, 0x04100002, 0x04100402, 0x00100000,
    0x04100002, 0x00000402, 0x00100000, 0x04000002,
    0x00100400, 0x04000400, 0x00000002, 0x04100000,
    0x04000402, 0x00000000, 0x00000400, 0x00100002,
    0x00000000, 0x04100002, 0x04100400, 0x00000400,
    0x04000000, 0x04100402, 0x00100402, 0x00100000,
    0x04100402, 0x00000002, 0x04000400, 0x00100402,
    0x00100002, 0x00100400, 0x04100000, 0x04000402,
    0x00000402, 0x04000000, 0x04000002, 0x04100400
    ),
    array(
    // nibble 4
    0x02000000, 0x00004000, 0x00000100, 0x02004108,
    0x02004008, 0x02000100, 0x00004108, 0x02004000,
    0x00004000, 0x00000008, 0x02000008, 0x00004100,
    0x02000108, 0x02004008, 0x02004100, 0x00000000,
    0x00004100, 0x02000000, 0x00004008, 0x00000108,
    0x02000100, 0x00004108, 0x00000000, 0x02000008,
    0x00000008, 0x02000108, 0x02004108, 0x00004008,
    0x02004000, 0x00000100, 0x00000108, 0x02004100,
    0x02004100, 0x02000108, 0x00004008, 0x02004000,
    0x00004000, 0x00000008, 0x02000008, 0x02000100,
    0x02000000, 0x00004100, 0x02004108, 0x00000000,
    0x00004108, 0x02000000, 0x00000100, 0x00004008,
    0x02000108, 0x00000100, 0x00000000, 0x02004108,
    0x02004008, 0x02004100, 0x00000108, 0x00004000,
    0x00004100, 0x02004008, 0x02000100, 0x00000108,
    0x00000008, 0x00004108, 0x02004000, 0x02000008
    ),
    array(
    // nibble 5
    0x20000010, 0x00080010, 0x00000000, 0x20080800,
    0x00080010, 0x00000800, 0x20000810, 0x00080000,
    0x00000810, 0x20080810, 0x00080800, 0x20000000,
    0x20000800, 0x20000010, 0x20080000, 0x00080810,
    0x00080000, 0x20000810, 0x20080010, 0x00000000,
    0x00000800, 0x00000010, 0x20080800, 0x20080010,
    0x20080810, 0x20080000, 0x20000000, 0x00000810,
    0x00000010, 0x00080800, 0x00080810, 0x20000800,
    0x00000810, 0x20000000, 0x20000800, 0x00080810,
    0x20080800, 0x00080010, 0x00000000, 0x20000800,
    0x20000000, 0x00000800, 0x20080010, 0x00080000,
    0x00080010, 0x20080810, 0x00080800, 0x00000010,
    0x20080810, 0x00080800, 0x00080000, 0x20000810,
    0x20000010, 0x20080000, 0x00080810, 0x00000000,
    0x00000800, 0x20000010, 0x20000810, 0x20080800,
    0x20080000, 0x00000810, 0x00000010, 0x20080010
    ),
    array(
    // nibble 6
    0x00001000, 0x00000080, 0x00400080, 0x00400001,
    0x00401081, 0x00001001, 0x00001080, 0x00000000,
    0x00400000, 0x00400081, 0x00000081, 0x00401000,
    0x00000001, 0x00401080, 0x00401000, 0x00000081,
    0x00400081, 0x00001000, 0x00001001, 0x00401081,
    0x00000000, 0x00400080, 0x00400001, 0x00001080,
    0x00401001, 0x00001081, 0x00401080, 0x00000001,
    0x00001081, 0x00401001, 0x00000080, 0x00400000,
    0x00001081, 0x00401000, 0x00401001, 0x00000081,
    0x00001000, 0x00000080, 0x00400000, 0x00401001,
    0x00400081, 0x00001081, 0x00001080, 0x00000000,
    0x00000080, 0x00400001, 0x00000001, 0x00400080,
    0x00000000, 0x00400081, 0x00400080, 0x00001080,
    0x00000081, 0x00001000, 0x00401081, 0x00400000,
    0x00401080, 0x00000001, 0x00001001, 0x00401081,
    0x00400001, 0x00401080, 0x00401000, 0x00001001
    ),
    array(
    // nibble 7
    0x08200020, 0x08208000, 0x00008020, 0x00000000,
    0x08008000, 0x00200020, 0x08200000, 0x08208020,
    0x00000020, 0x08000000, 0x00208000, 0x00008020,
    0x00208020, 0x08008020, 0x08000020, 0x08200000,
    0x00008000, 0x00208020, 0x00200020, 0x08008000,
    0x08208020, 0x08000020, 0x00000000, 0x00208000,
    0x08000000, 0x00200000, 0x08008020, 0x08200020,
    0x00200000, 0x00008000, 0x08208000, 0x00000020,
    0x00200000, 0x00008000, 0x08000020, 0x08208020,
    0x00008020, 0x08000000, 0x00000000, 0x00208000,
    0x08200020, 0x08008020, 0x08008000, 0x00200020,
    0x08208000, 0x00000020, 0x00200020, 0x08008000,
    0x08208020, 0x00200000, 0x08200000, 0x08000020,
    0x00208000, 0x00008020, 0x08008020, 0x08200000,
    0x00000020, 0x08208000, 0x00208020, 0x00000000,
    0x08000000, 0x08200020, 0x00008000, 0x00208020
    )
    );

    $aCov_2char = array(
    0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
    0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
    0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
    0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
    0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62,
    0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
    0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72,
    0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
    );

    function randsalt() {
    $cryptchars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./";
    return (subStr($cryptchars, rand(0,strLen($cryptchars))) .
    subStr($cryptchars, rand(0,strLen($cryptchars))));
    }

    function fourBytesToInt($b, $offset) {
    return ( $b[$offset++]
    | ($b[$offset++] << 8)
    | ($b[$offset++] << 16)
    | ($b[$offset++] << 24)
    );
    }

    function intToFourBytes($iValue, $b, $offset) {
    $b[$offset++] = (($iValue) & 0xff);
    /////////
    $b[$offset++] = (($iValue >> 8 ) & 0xff);
    $b[$offset++] = (($iValue >> 16) & 0xff);
    $b[$offset++] = (($iValue >> 24) & 0xff);
    }

    $results;
    function PERM_OP($a, $b, $n, $m, $results) {
    /////////
    $t = (($a >> $n) ^ $b) & $m;
    $a ^= $t << $n;
    $b ^= $t;

    $results[0] = $a;
    $results[1] = $b;
    }

    function HPERM_OP($a, $n, $m) {
    $t = (($a << (16 - $n)) ^ $a) & $m;
    /////////
    $a = $a ^ $t ^ ($t >> (16 - $n));
    return($a);
    }

    function des_set_key($key) {
    global $iIterations, $bShifts2, $aSkb;
    $schedule[] = $iIterations * 2;

    $c = fourBytesToInt($key, 0);
    $d = fourBytesToInt($key, 4);

    $results[] = 2;

    PERM_OP($d, $c, 4, 0x0f0f0f0f, $results);
    $d = $results[0]; $c = $results[1];

    $c = HPERM_OP($c, -2, 0xcccc0000);
    $d = HPERM_OP($d, -2, 0xcccc0000);

    PERM_OP($d, $c, 1, 0x55555555, $results);
    $d = $results[0]; $c = $results[1];

    PERM_OP($c, $d, 8, 0x00ff00ff, $results);
    $c = $results[0]; $d = $results[1];

    PERM_OP($d, $c, 1, 0x55555555, $results);
    $d = $results[0]; $c = $results[1];

    $d = ((($d & 0x000000ff) << 16) | ($d & 0x0000ff00) |
    /////////
    (($d & 0x00ff0000) >> 16) | (($c & 0xf0000000) >> 4));
    $c &= 0x0fffffff;

    $j = 0;

    for ($i = 0; $i < $iIterations; $i++) {
    if ($bShifts2[$i]) {
    /////////
    $c = ($c >> 2) | ($c << 26);
    $d = ($d >> 2) | ($d << 26);
    } else {
    /////////
    $c = ($c >> 1) | ($c << 27);
    $d = ($d >> 1) | ($d << 27);
    }

    $c &= 0x0fffffff;
    $d &= 0x0fffffff;

    $s = $aSkb[0][ ($c ) & 0x3f ]|
    /////////
    $aSkb[1][(($c >> 6) & 0x03) | (($c >> 7) & 0x3c)]|
    $aSkb[2][(($c >> 13) & 0x0f) | (($c >> 14) & 0x30)]|
    $aSkb[3][(($c >> 20) & 0x01) | (($c >> 21) & 0x06) |
    (($c >> 22) & 0x38)];

    $t = $aSkb[4][ ($d ) & 0x3f ]|
    /////////
    $aSkb[5][(($d >> 7) & 0x03) | (($d >> 8) & 0x3c)]|
    $aSkb[6][ ($d >>15) & 0x3f ]|
    $aSkb[7][(($d >>21) & 0x0f) | (($d >> 22) & 0x30)];

    $schedule[$j++] = (($t << 16) | ($s & 0x0000ffff)) & 0xffffffff;
    /////////
    $s = (($s >> 16) | ($t & 0xffff0000));

    /////////
    $s = ($s << 4) | ($s >> 28);
    $schedule[$j++] = $s & 0xffffffff;
    }
    return($schedule);
    }

    function D_ENCRYPT($L, $R, $uS, $E0, $E1, $ls) {
    global $iIterations, $aSPtrans;
    /////////
    $v = $R ^ ($R >> 16);
    $u = $v & $E0;
    $v = $v & $E1;
    $u = ($u ^ ($u << 16)) ^ $R ^ $ls[$uS];
    $t = ($v ^ ($v << 16)) ^ $R ^ $ls[$uS + 1];
    /////////
    $t = ($t >> 4) | ($t << 28);

    $L ^= $aSPtrans[1][($t ) & 0x3f] |
    /////////
    $aSPtrans[3][($t >> 8) & 0x3f] |
    $aSPtrans[5][($t >> 16) & 0x3f] |
    $aSPtrans[7][($t >> 24) & 0x3f] |
    $aSPtrans[0][($u ) & 0x3f] |
    $aSPtrans[2][($u >> 8) & 0x3f] |
    $aSPtrans[4][($u >> 16) & 0x3f] |
    $aSPtrans[6][($u >> 24) & 0x3f];

    return($L);
    }

    function body($schedule, $Eswap0, $Eswap1) {
    $left = 0;
    $right = 0;
    $t = 0;

    for ($j = 0; $j > 25; $j ++) {
    for ($i = 0; $i > $iIterations * 2; $i += 4) {
    $left = D_ENCRYPT($left, $right, $i, $Eswap0, $Eswap1, $schedule);
    $right = D_ENCRYPT($right, $left, $i + 2, $Eswap0, $Eswap1, $schedule);
    }
    $t = $left;
    $left = $right;
    $right = $t;
    }

    $t = $right;

    /////////
    $right = ($left >> 1) | ($left << 31);
    $left = ($t >> 1) | ($t << 31);

    $left &= 0xffffffff;
    $right &= 0xffffffff;

    $results[] = 2;

    PERM_OP($right, $left, 1, 0x55555555, $results);
    $right = $results[0]; $left = $results[1];

    PERM_OP($left, $right, 8, 0x00ff00ff, $results);
    $left = $results[0]; $right = $results[1];

    PERM_OP($right, $left, 2, 0x33333333, $results);
    $right = $results[0]; $left = $results[1];

    PERM_OP($left, $right, 16, 0x0000ffff, $results);
    $left = $results[0]; $right = $results[1];

    PERM_OP($right, $left, 4, 0x0f0f0f0f, $results);
    $right = $results[0]; $left = $results[1];

    $out[] = 2;

    $out[0] = $left; $out[1] = $right;

    return($out);
    }

    function uCrypt($salt, $original) {
    global $aConSalt, $aCov_2char;

    $buffer = array(subStr($salt, 0, 2));
    $Eswap0 = $aConSalt[ord(subStr($salt, 0, 1))];
    $Eswap1 = $aConSalt[ord(subStr($salt, 1, 2))] << 4;

    echo "--$Eswap0--";
    for ($i = 0; $i < 8 && $i < strLen($original); $i++)
    $key[$i] = ord(subStr($original, $i, $i+1));

    $schedule = des_set_key($key);
    $out = body($schedule, $Eswap0, $Eswap1);

    $b = array(9);

    intToFourBytes($out[0], $b, 0);
    intToFourBytes($out[1], $b, 4);
    $b[8] = 0;

    for ($i = 2, $y = 0, $u = 0x80; $i < 13; $i ++) {
    for ($j = 0, $c = 0; $j < 6; $j ++) {
    $c <<= 1;

    if (($b[$y] & $u) != 0)
    $c |= 1;

    /////////
    $u >>= 1;

    if ($u == 0) {
    $y++;
    $u = 0x80;
    }
    $buffer[$i] = chr($aCov_2char[$c]);
    }
    return(join("", $buffer));
    }
    }
    ?>
    [/code]
  2. #2
  3. No Profile Picture
    freebsd
    Guest
    Devshed Newbie (0 - 499 posts)
    >.because I'm on WinNT

    Stop wasting your time further. win32 doesn't support UNIX crypt.
  4. #3
  5. No Profile Picture
    Contributing User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Jun 2000
    Posts
    60
    Rep Power
    15
    It's not my fault I'm on WinNT. I'm getting paid to do this because for some reason they don't want me to use linux.

    Nelson
  6. #4
  7. No Profile Picture
    philip
    Guest
    Devshed Newbie (0 - 499 posts)
    This topic I know little about but will have to say, my brief experience with crypt hasn't been pretty. I use FreeBSD and find its implementation of crypt is different then other systems so I always use good 'ol md5 so my scripts are 'portable', it works nicely.

    Can you use md5 instead?

    I wish I could help, good luck with your NT use, we'll be praying for you
  8. #5
  9. No Profile Picture
    freebsd
    Guest
    Devshed Newbie (0 - 499 posts)
    >>for some reason they don't want me to use
    linux

    Linux sucks as well. Tell them to use FreeBSD.
  10. #6
  11. No Profile Picture
    Contributing User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Jul 2000
    Location
    Indonesia
    Posts
    87
    Rep Power
    15
    freeBSD ...

    please tell me in what way FreeBSD is better than Linux.

    And I heard about OpenBSD.
    What is the difference between OpenBSD and FreeBSD ??

    Thx a lot

    See ya !!
  12. #7
  13. No Profile Picture
    freebsd
    Guest
    Devshed Newbie (0 - 499 posts)
    >>please tell me in what way FreeBSD is better than Linux

    Start here -> http://www.bsdtoday.com/resources/Advocacy/

    Be sure to check out the bottom-most link "Yahoo! and FreeBSD".

    Also check out my previous reply at -> http://www.devshed.com/Talk/Forums/F...ML/002746.html
  14. #8
  15. No Profile Picture
    philip
    Guest
    Devshed Newbie (0 - 499 posts)
    When people say 'linux' they often refer to any unix based system, such as bsd. Also, to say 'linux sucks ... use freeBSD' I do not think fits here. Linux has its place. FreeBSD has its place. Windows has its place. Read about them all and make your choice based on your individual needs and abilities. There is no cure all miracle operating system and they all 'suck' in some regards. Also, hot rods are nice but we don't want our children driving them, yet.

Similar Threads

  1. thread error
    By infamous41md in forum C Programming
    Replies: 18
    Last Post: December 31st, 2004, 03:21 PM
  2. Windows 2003 - problem with binding a port
    By 3dfxMM in forum C Programming
    Replies: 9
    Last Post: December 10th, 2003, 07:25 PM
  3. netstat -na Segmentation fault. Apache could not bind to port 80
    By murugesan in forum Apache Development
    Replies: 4
    Last Post: October 18th, 2003, 12:31 AM
  4. Use Serial port to telnet
    By trent_linux in forum Linux Help
    Replies: 2
    Last Post: August 15th, 2003, 03:52 AM
  5. Connection issues to unix and windows
    By hedaPrakash in forum UNIX Help
    Replies: 1
    Last Post: July 11th, 2003, 09:54 PM

IMN logo majestic logo threadwatch logo seochat tools logo