KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sslexplorer > unixauth > DESCrypt


1 package com.sslexplorer.unixauth;
2 /*******************************************************************************
3  * JCrypt.java
4  *
5  * Java-based implementation of the unix crypt command found at
6  * http://locutus.kingwoodcable.com/jfd/crypt.html.
7  *
8  * Based upon C source code written by Eric Young, eay@psych.uq.oz.au
9  *
10  ******************************************************************************/

11
12 public class DESCrypt {
13     private DESCrypt() {
14     }
15
16     private static final int ITERATIONS = 16;
17
18     private static final int con_salt[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
19                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
20                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
21                     0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
22                     0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
23                     0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C,
24                     0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E,
25                     0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, };
26
27     private static final boolean shifts2[] = { false, false, true, true, true, true, true, true, false, true, true, true, true,
28                     true, true, false };
29
30     private static final int skb[][] = {
31                     {
32                     /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
33                     0x00000000, 0x00000010, 0x20000000, 0x20000010, 0x00010000, 0x00010010, 0x20010000, 0x20010010, 0x00000800,
34                                     0x00000810, 0x20000800, 0x20000810, 0x00010800, 0x00010810, 0x20010800, 0x20010810, 0x00000020,
35                                     0x00000030, 0x20000020, 0x20000030, 0x00010020, 0x00010030, 0x20010020, 0x20010030, 0x00000820,
36                                     0x00000830, 0x20000820, 0x20000830, 0x00010820, 0x00010830, 0x20010820, 0x20010830, 0x00080000,
37                                     0x00080010, 0x20080000, 0x20080010, 0x00090000, 0x00090010, 0x20090000, 0x20090010, 0x00080800,
38                                     0x00080810, 0x20080800, 0x20080810, 0x00090800, 0x00090810, 0x20090800, 0x20090810, 0x00080020,
39                                     0x00080030, 0x20080020, 0x20080030, 0x00090020, 0x00090030, 0x20090020, 0x20090030, 0x00080820,
40                                     0x00080830, 0x20080820, 0x20080830, 0x00090820, 0x00090830, 0x20090820, 0x20090830, },
41                     {
42                     /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
43                     0x00000000, 0x02000000, 0x00002000, 0x02002000, 0x00200000, 0x02200000, 0x00202000, 0x02202000, 0x00000004,
44                                     0x02000004, 0x00002004, 0x02002004, 0x00200004, 0x02200004, 0x00202004, 0x02202004, 0x00000400,
45                                     0x02000400, 0x00002400, 0x02002400, 0x00200400, 0x02200400, 0x00202400, 0x02202400, 0x00000404,
46                                     0x02000404, 0x00002404, 0x02002404, 0x00200404, 0x02200404, 0x00202404, 0x02202404, 0x10000000,
47                                     0x12000000, 0x10002000, 0x12002000, 0x10200000, 0x12200000, 0x10202000, 0x12202000, 0x10000004,
48                                     0x12000004, 0x10002004, 0x12002004, 0x10200004, 0x12200004, 0x10202004, 0x12202004, 0x10000400,
49                                     0x12000400, 0x10002400, 0x12002400, 0x10200400, 0x12200400, 0x10202400, 0x12202400, 0x10000404,
50                                     0x12000404, 0x10002404, 0x12002404, 0x10200404, 0x12200404, 0x10202404, 0x12202404, },
51                     {
52                     /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
53                     0x00000000, 0x00000001, 0x00040000, 0x00040001, 0x01000000, 0x01000001, 0x01040000, 0x01040001, 0x00000002,
54                                     0x00000003, 0x00040002, 0x00040003, 0x01000002, 0x01000003, 0x01040002, 0x01040003, 0x00000200,
55                                     0x00000201, 0x00040200, 0x00040201, 0x01000200, 0x01000201, 0x01040200, 0x01040201, 0x00000202,
56                                     0x00000203, 0x00040202, 0x00040203, 0x01000202, 0x01000203, 0x01040202, 0x01040203, 0x08000000,
57                                     0x08000001, 0x08040000, 0x08040001, 0x09000000, 0x09000001, 0x09040000, 0x09040001, 0x08000002,
58                                     0x08000003, 0x08040002, 0x08040003, 0x09000002, 0x09000003, 0x09040002, 0x09040003, 0x08000200,
59                                     0x08000201, 0x08040200, 0x08040201, 0x09000200, 0x09000201, 0x09040200, 0x09040201, 0x08000202,
60                                     0x08000203, 0x08040202, 0x08040203, 0x09000202, 0x09000203, 0x09040202, 0x09040203, },
61                     {
62                     /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
63                     0x00000000, 0x00100000, 0x00000100, 0x00100100, 0x00000008, 0x00100008, 0x00000108, 0x00100108, 0x00001000,
64                                     0x00101000, 0x00001100, 0x00101100, 0x00001008, 0x00101008, 0x00001108, 0x00101108, 0x04000000,
65                                     0x04100000, 0x04000100, 0x04100100, 0x04000008, 0x04100008, 0x04000108, 0x04100108, 0x04001000,
66                                     0x04101000, 0x04001100, 0x04101100, 0x04001008, 0x04101008, 0x04001108, 0x04101108, 0x00020000,
67                                     0x00120000, 0x00020100, 0x00120100, 0x00020008, 0x00120008, 0x00020108, 0x00120108, 0x00021000,
68                                     0x00121000, 0x00021100, 0x00121100, 0x00021008, 0x00121008, 0x00021108, 0x00121108, 0x04020000,
69                                     0x04120000, 0x04020100, 0x04120100, 0x04020008, 0x04120008, 0x04020108, 0x04120108, 0x04021000,
70                                     0x04121000, 0x04021100, 0x04121100, 0x04021008, 0x04121008, 0x04021108, 0x04121108, },
71                     {
72                     /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
73                     0x00000000, 0x10000000, 0x00010000, 0x10010000, 0x00000004, 0x10000004, 0x00010004, 0x10010004, 0x20000000,
74                                     0x30000000, 0x20010000, 0x30010000, 0x20000004, 0x30000004, 0x20010004, 0x30010004, 0x00100000,
75                                     0x10100000, 0x00110000, 0x10110000, 0x00100004, 0x10100004, 0x00110004, 0x10110004, 0x20100000,
76                                     0x30100000, 0x20110000, 0x30110000, 0x20100004, 0x30100004, 0x20110004, 0x30110004, 0x00001000,
77                                     0x10001000, 0x00011000, 0x10011000, 0x00001004, 0x10001004, 0x00011004, 0x10011004, 0x20001000,
78                                     0x30001000, 0x20011000, 0x30011000, 0x20001004, 0x30001004, 0x20011004, 0x30011004, 0x00101000,
79                                     0x10101000, 0x00111000, 0x10111000, 0x00101004, 0x10101004, 0x00111004, 0x10111004, 0x20101000,
80                                     0x30101000, 0x20111000, 0x30111000, 0x20101004, 0x30101004, 0x20111004, 0x30111004, },
81                     {
82                     /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
83                     0x00000000, 0x08000000, 0x00000008, 0x08000008, 0x00000400, 0x08000400, 0x00000408, 0x08000408, 0x00020000,
84                                     0x08020000, 0x00020008, 0x08020008, 0x00020400, 0x08020400, 0x00020408, 0x08020408, 0x00000001,
85                                     0x08000001, 0x00000009, 0x08000009, 0x00000401, 0x08000401, 0x00000409, 0x08000409, 0x00020001,
86                                     0x08020001, 0x00020009, 0x08020009, 0x00020401, 0x08020401, 0x00020409, 0x08020409, 0x02000000,
87                                     0x0A000000, 0x02000008, 0x0A000008, 0x02000400, 0x0A000400, 0x02000408, 0x0A000408, 0x02020000,
88                                     0x0A020000, 0x02020008, 0x0A020008, 0x02020400, 0x0A020400, 0x02020408, 0x0A020408, 0x02000001,
89                                     0x0A000001, 0x02000009, 0x0A000009, 0x02000401, 0x0A000401, 0x02000409, 0x0A000409, 0x02020001,
90                                     0x0A020001, 0x02020009, 0x0A020009, 0x02020401, 0x0A020401, 0x02020409, 0x0A020409, },
91                     {
92                     /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
93                     0x00000000, 0x00000100, 0x00080000, 0x00080100, 0x01000000, 0x01000100, 0x01080000, 0x01080100, 0x00000010,
94                                     0x00000110, 0x00080010, 0x00080110, 0x01000010, 0x01000110, 0x01080010, 0x01080110, 0x00200000,
95                                     0x00200100, 0x00280000, 0x00280100, 0x01200000, 0x01200100, 0x01280000, 0x01280100, 0x00200010,
96                                     0x00200110, 0x00280010, 0x00280110, 0x01200010, 0x01200110, 0x01280010, 0x01280110, 0x00000200,
97                                     0x00000300, 0x00080200, 0x00080300, 0x01000200, 0x01000300, 0x01080200, 0x01080300, 0x00000210,
98                                     0x00000310, 0x00080210, 0x00080310, 0x01000210, 0x01000310, 0x01080210, 0x01080310, 0x00200200,
99                                     0x00200300, 0x00280200, 0x00280300, 0x01200200, 0x01200300, 0x01280200, 0x01280300, 0x00200210,
100                                     0x00200310, 0x00280210, 0x00280310, 0x01200210, 0x01200310, 0x01280210, 0x01280310, },
101                     {
102                     /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
103                     0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00000002, 0x04000002, 0x00040002, 0x04040002, 0x00002000,
104                                     0x04002000, 0x00042000, 0x04042000, 0x00002002, 0x04002002, 0x00042002, 0x04042002, 0x00000020,
105                                     0x04000020, 0x00040020, 0x04040020, 0x00000022, 0x04000022, 0x00040022, 0x04040022, 0x00002020,
106                                     0x04002020, 0x00042020, 0x04042020, 0x00002022, 0x04002022, 0x00042022, 0x04042022, 0x00000800,
107                                     0x04000800, 0x00040800, 0x04040800, 0x00000802, 0x04000802, 0x00040802, 0x04040802, 0x00002800,
108                                     0x04002800, 0x00042800, 0x04042800, 0x00002802, 0x04002802, 0x00042802, 0x04042802, 0x00000820,
109                                     0x04000820, 0x00040820, 0x04040820, 0x00000822, 0x04000822, 0x00040822, 0x04040822, 0x00002820,
110                                     0x04002820, 0x00042820, 0x04042820, 0x00002822, 0x04002822, 0x00042822, 0x04042822, }, };
111
112     private static final int SPtrans[][] = {
113                     {
114                     /* nibble 0 */
115                     0x00820200, 0x00020000, 0x80800000, 0x80820200, 0x00800000, 0x80020200, 0x80020000, 0x80800000, 0x80020200,
116                                     0x00820200, 0x00820000, 0x80000200, 0x80800200, 0x00800000, 0x00000000, 0x80020000, 0x00020000,
117                                     0x80000000, 0x00800200, 0x00020200, 0x80820200, 0x00820000, 0x80000200, 0x00800200, 0x80000000,
118                                     0x00000200, 0x00020200, 0x80820000, 0x00000200, 0x80800200, 0x80820000, 0x00000000, 0x00000000,
119                                     0x80820200, 0x00800200, 0x80020000, 0x00820200, 0x00020000, 0x80000200, 0x00800200, 0x80820000,
120                                     0x00000200, 0x00020200, 0x80800000, 0x80020200, 0x80000000, 0x80800000, 0x00820000, 0x80820200,
121                                     0x00020200, 0x00820000, 0x80800200, 0x00800000, 0x80000200, 0x80020000, 0x00000000, 0x00020000,
122                                     0x00800000, 0x80800200, 0x00820200, 0x80000000, 0x80820000, 0x00000200, 0x80020200, },
123                     {
124                     /* nibble 1 */
125                     0x10042004, 0x00000000, 0x00042000, 0x10040000, 0x10000004, 0x00002004, 0x10002000, 0x00042000, 0x00002000,
126                                     0x10040004, 0x00000004, 0x10002000, 0x00040004, 0x10042000, 0x10040000, 0x00000004, 0x00040000,
127                                     0x10002004, 0x10040004, 0x00002000, 0x00042004, 0x10000000, 0x00000000, 0x00040004, 0x10002004,
128                                     0x00042004, 0x10042000, 0x10000004, 0x10000000, 0x00040000, 0x00002004, 0x10042004, 0x00040004,
129                                     0x10042000, 0x10002000, 0x00042004, 0x10042004, 0x00040004, 0x10000004, 0x00000000, 0x10000000,
130                                     0x00002004, 0x00040000, 0x10040004, 0x00002000, 0x10000000, 0x00042004, 0x10002004, 0x10042000,
131                                     0x00002000, 0x00000000, 0x10000004, 0x00000004, 0x10042004, 0x00042000, 0x10040000, 0x10040004,
132                                     0x00040000, 0x00002004, 0x10002000, 0x10002004, 0x00000004, 0x10040000, 0x00042000, },
133                     {
134                     /* nibble 2 */
135                     0x41000000, 0x01010040, 0x00000040, 0x41000040, 0x40010000, 0x01000000, 0x41000040, 0x00010040, 0x01000040,
136                                     0x00010000, 0x01010000, 0x40000000, 0x41010040, 0x40000040, 0x40000000, 0x41010000, 0x00000000,
137                                     0x40010000, 0x01010040, 0x00000040, 0x40000040, 0x41010040, 0x00010000, 0x41000000, 0x41010000,
138                                     0x01000040, 0x40010040, 0x01010000, 0x00010040, 0x00000000, 0x01000000, 0x40010040, 0x01010040,
139                                     0x00000040, 0x40000000, 0x00010000, 0x40000040, 0x40010000, 0x01010000, 0x41000040, 0x00000000,
140                                     0x01010040, 0x00010040, 0x41010000, 0x40010000, 0x01000000, 0x41010040, 0x40000000, 0x40010040,
141                                     0x41000000, 0x01000000, 0x41010040, 0x00010000, 0x01000040, 0x41000040, 0x00010040, 0x01000040,
142                                     0x00000000, 0x41010000, 0x40000040, 0x41000000, 0x40010040, 0x00000040, 0x01010000, },
143                     {
144                     /* nibble 3 */
145                     0x00100402, 0x04000400, 0x00000002, 0x04100402, 0x00000000, 0x04100000, 0x04000402, 0x00100002, 0x04100400,
146                                     0x04000002, 0x04000000, 0x00000402, 0x04000002, 0x00100402, 0x00100000, 0x04000000, 0x04100002,
147                                     0x00100400, 0x00000400, 0x00000002, 0x00100400, 0x04000402, 0x04100000, 0x00000400, 0x00000402,
148                                     0x00000000, 0x00100002, 0x04100400, 0x04000400, 0x04100002, 0x04100402, 0x00100000, 0x04100002,
149                                     0x00000402, 0x00100000, 0x04000002, 0x00100400, 0x04000400, 0x00000002, 0x04100000, 0x04000402,
150                                     0x00000000, 0x00000400, 0x00100002, 0x00000000, 0x04100002, 0x04100400, 0x00000400, 0x04000000,
151                                     0x04100402, 0x00100402, 0x00100000, 0x04100402, 0x00000002, 0x04000400, 0x00100402, 0x00100002,
152                                     0x00100400, 0x04100000, 0x04000402, 0x00000402, 0x04000000, 0x04000002, 0x04100400, },
153                     {
154                     /* nibble 4 */
155                     0x02000000, 0x00004000, 0x00000100, 0x02004108, 0x02004008, 0x02000100, 0x00004108, 0x02004000, 0x00004000,
156                                     0x00000008, 0x02000008, 0x00004100, 0x02000108, 0x02004008, 0x02004100, 0x00000000, 0x00004100,
157                                     0x02000000, 0x00004008, 0x00000108, 0x02000100, 0x00004108, 0x00000000, 0x02000008, 0x00000008,
158                                     0x02000108, 0x02004108, 0x00004008, 0x02004000, 0x00000100, 0x00000108, 0x02004100, 0x02004100,
159                                     0x02000108, 0x00004008, 0x02004000, 0x00004000, 0x00000008, 0x02000008, 0x02000100, 0x02000000,
160                                     0x00004100, 0x02004108, 0x00000000, 0x00004108, 0x02000000, 0x00000100, 0x00004008, 0x02000108,
161                                     0x00000100, 0x00000000, 0x02004108, 0x02004008, 0x02004100, 0x00000108, 0x00004000, 0x00004100,
162                                     0x02004008, 0x02000100, 0x00000108, 0x00000008, 0x00004108, 0x02004000, 0x02000008, },
163                     {
164                     /* nibble 5 */
165                     0x20000010, 0x00080010, 0x00000000, 0x20080800, 0x00080010, 0x00000800, 0x20000810, 0x00080000, 0x00000810,
166                                     0x20080810, 0x00080800, 0x20000000, 0x20000800, 0x20000010, 0x20080000, 0x00080810, 0x00080000,
167                                     0x20000810, 0x20080010, 0x00000000, 0x00000800, 0x00000010, 0x20080800, 0x20080010, 0x20080810,
168                                     0x20080000, 0x20000000, 0x00000810, 0x00000010, 0x00080800, 0x00080810, 0x20000800, 0x00000810,
169                                     0x20000000, 0x20000800, 0x00080810, 0x20080800, 0x00080010, 0x00000000, 0x20000800, 0x20000000,
170                                     0x00000800, 0x20080010, 0x00080000, 0x00080010, 0x20080810, 0x00080800, 0x00000010, 0x20080810,
171                                     0x00080800, 0x00080000, 0x20000810, 0x20000010, 0x20080000, 0x00080810, 0x00000000, 0x00000800,
172                                     0x20000010, 0x20000810, 0x20080800, 0x20080000, 0x00000810, 0x00000010, 0x20080010, },
173                     {
174                     /* nibble 6 */
175                     0x00001000, 0x00000080, 0x00400080, 0x00400001, 0x00401081, 0x00001001, 0x00001080, 0x00000000, 0x00400000,
176                                     0x00400081, 0x00000081, 0x00401000, 0x00000001, 0x00401080, 0x00401000, 0x00000081, 0x00400081,
177                                     0x00001000, 0x00001001, 0x00401081, 0x00000000, 0x00400080, 0x00400001, 0x00001080, 0x00401001,
178                                     0x00001081, 0x00401080, 0x00000001, 0x00001081, 0x00401001, 0x00000080, 0x00400000, 0x00001081,
179                                     0x00401000, 0x00401001, 0x00000081, 0x00001000, 0x00000080, 0x00400000, 0x00401001, 0x00400081,
180                                     0x00001081, 0x00001080, 0x00000000, 0x00000080, 0x00400001, 0x00000001, 0x00400080, 0x00000000,
181                                     0x00400081, 0x00400080, 0x00001080, 0x00000081, 0x00001000, 0x00401081, 0x00400000, 0x00401080,
182                                     0x00000001, 0x00001001, 0x00401081, 0x00400001, 0x00401080, 0x00401000, 0x00001001, },
183                     {
184                     /* nibble 7 */
185                     0x08200020, 0x08208000, 0x00008020, 0x00000000, 0x08008000, 0x00200020, 0x08200000, 0x08208020, 0x00000020,
186                                     0x08000000, 0x00208000, 0x00008020, 0x00208020, 0x08008020, 0x08000020, 0x08200000, 0x00008000,
187                                     0x00208020, 0x00200020, 0x08008000, 0x08208020, 0x08000020, 0x00000000, 0x00208000, 0x08000000,
188                                     0x00200000, 0x08008020, 0x08200020, 0x00200000, 0x00008000, 0x08208000, 0x00000020, 0x00200000,
189                                     0x00008000, 0x08000020, 0x08208020, 0x00008020, 0x08000000, 0x00000000, 0x00208000, 0x08200020,
190                                     0x08008020, 0x08008000, 0x00200020, 0x08208000, 0x00000020, 0x00200020, 0x08008000, 0x08208020,
191                                     0x00200000, 0x08200000, 0x08000020, 0x00208000, 0x00008020, 0x08008020, 0x08200000, 0x00000020,
192                                     0x08208000, 0x00208020, 0x00000000, 0x08000000, 0x08200020, 0x00008000, 0x00208020 } };
193
194     private static final int cov_2char[] = { 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42,
195                     0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54,
196                     0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
197                     0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A };
198
199     private static final int byteToUnsigned(byte b) {
200         int value = (int) b;
201
202         return (value >= 0 ? value : value + 256);
203     }
204
205     private static int fourBytesToInt(byte b[], int offset) {
206         int value;
207
208         value = byteToUnsigned(b[offset++]);
209         value |= (byteToUnsigned(b[offset++]) << 8);
210         value |= (byteToUnsigned(b[offset++]) << 16);
211         value |= (byteToUnsigned(b[offset++]) << 24);
212
213         return (value);
214     }
215
216     private static final void intToFourBytes(int iValue, byte b[], int offset) {
217         b[offset++] = (byte) ((iValue) & 0xff);
218         b[offset++] = (byte) ((iValue >>> 8) & 0xff);
219         b[offset++] = (byte) ((iValue >>> 16) & 0xff);
220         b[offset++] = (byte) ((iValue >>> 24) & 0xff);
221     }
222
223     private static final void PERM_OP(int a, int b, int n, int m, int results[]) {
224         int t;
225
226         t = ((a >>> n) ^ b) & m;
227         a ^= t << n;
228         b ^= t;
229
230         results[0] = a;
231         results[1] = b;
232     }
233
234     private static final int HPERM_OP(int a, int n, int m) {
235         int t;
236
237         t = ((a << (16 - n)) ^ a) & m;
238         a = a ^ t ^ (t >>> (16 - n));
239
240         return (a);
241     }
242
243     private static int[] des_set_key(byte key[]) {
244         int schedule[] = new int[ITERATIONS * 2];
245
246         int c = fourBytesToInt(key, 0);
247         int d = fourBytesToInt(key, 4);
248
249         int results[] = new int[2];
250
251         PERM_OP(d, c, 4, 0x0f0f0f0f, results);
252         d = results[0];
253         c = results[1];
254
255         c = HPERM_OP(c, -2, 0xcccc0000);
256         d = HPERM_OP(d, -2, 0xcccc0000);
257
258         PERM_OP(d, c, 1, 0x55555555, results);
259         d = results[0];
260         c = results[1];
261
262         PERM_OP(c, d, 8, 0x00ff00ff, results);
263         c = results[0];
264         d = results[1];
265
266         PERM_OP(d, c, 1, 0x55555555, results);
267         d = results[0];
268         c = results[1];
269
270         d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) | ((d & 0x00ff0000) >>> 16) | ((c & 0xf0000000) >>> 4));
271         c &= 0x0fffffff;
272
273         int s, t;
274         int j = 0;
275
276         for (int i = 0; i < ITERATIONS; i++) {
277             if (shifts2[i]) {
278                 c = (c >>> 2) | (c << 26);
279                 d = (d >>> 2) | (d << 26);
280             } else {
281                 c = (c >>> 1) | (c << 27);
282                 d = (d >>> 1) | (d << 27);
283             }
284
285             c &= 0x0fffffff;
286             d &= 0x0fffffff;
287
288             s = skb[0][(c) & 0x3f] | skb[1][((c >>> 6) & 0x03) | ((c >>> 7) & 0x3c)]
289                             | skb[2][((c >>> 13) & 0x0f) | ((c >>> 14) & 0x30)]
290                             | skb[3][((c >>> 20) & 0x01) | ((c >>> 21) & 0x06) | ((c >>> 22) & 0x38)];
291
292             t = skb[4][(d) & 0x3f] | skb[5][((d >>> 7) & 0x03) | ((d >>> 8) & 0x3c)] | skb[6][(d >>> 15) & 0x3f]
293                             | skb[7][((d >>> 21) & 0x0f) | ((d >>> 22) & 0x30)];
294
295             schedule[j++] = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff;
296             s = ((s >>> 16) | (t & 0xffff0000));
297
298             s = (s << 4) | (s >>> 28);
299             schedule[j++] = s & 0xffffffff;
300         }
301         return (schedule);
302     }
303
304     private static final int D_ENCRYPT(int L, int R, int S, int E0, int E1, int s[]) {
305         int t, u, v;
306
307         v = R ^ (R >>> 16);
308         u = v & E0;
309         v = v & E1;
310         u = (u ^ (u << 16)) ^ R ^ s[S];
311         t = (v ^ (v << 16)) ^ R ^ s[S + 1];
312         t = (t >>> 4) | (t << 28);
313
314         L ^= SPtrans[1][(t) & 0x3f] | SPtrans[3][(t >>> 8) & 0x3f] | SPtrans[5][(t >>> 16) & 0x3f] | SPtrans[7][(t >>> 24) & 0x3f]
315                         | SPtrans[0][(u) & 0x3f] | SPtrans[2][(u >>> 8) & 0x3f] | SPtrans[4][(u >>> 16) & 0x3f]
316                         | SPtrans[6][(u >>> 24) & 0x3f];
317
318         return (L);
319     }
320
321     private static final int[] body(int schedule[], int Eswap0, int Eswap1) {
322         int left = 0;
323         int right = 0;
324         int t = 0;
325
326         for (int j = 0; j < 25; j++) {
327             for (int i = 0; i < ITERATIONS * 2; i += 4) {
328                 left = D_ENCRYPT(left, right, i, Eswap0, Eswap1, schedule);
329                 right = D_ENCRYPT(right, left, i + 2, Eswap0, Eswap1, schedule);
330             }
331             t = left;
332             left = right;
333             right = t;
334         }
335
336         t = right;
337
338         right = (left >>> 1) | (left << 31);
339         left = (t >>> 1) | (t << 31);
340
341         left &= 0xffffffff;
342         right &= 0xffffffff;
343
344         int results[] = new int[2];
345
346         PERM_OP(right, left, 1, 0x55555555, results);
347         right = results[0];
348         left = results[1];
349
350         PERM_OP(left, right, 8, 0x00ff00ff, results);
351         left = results[0];
352         right = results[1];
353
354         PERM_OP(right, left, 2, 0x33333333, results);
355         right = results[0];
356         left = results[1];
357
358         PERM_OP(left, right, 16, 0x0000ffff, results);
359         left = results[0];
360         right = results[1];
361
362         PERM_OP(right, left, 4, 0x0f0f0f0f, results);
363         right = results[0];
364         left = results[1];
365
366         int out[] = new int[2];
367
368         out[0] = left;
369         out[1] = right;
370
371         return (out);
372     }
373
374     public static final String JavaDoc crypt(String JavaDoc salt, String JavaDoc original) {
375         while (salt.length() < 2)
376             salt += "A";
377
378         StringBuffer JavaDoc buffer = new StringBuffer JavaDoc(" ");
379
380         char charZero = salt.charAt(0);
381         char charOne = salt.charAt(1);
382
383         buffer.setCharAt(0, charZero);
384         buffer.setCharAt(1, charOne);
385
386         int Eswap0 = con_salt[(int) charZero];
387         int Eswap1 = con_salt[(int) charOne] << 4;
388
389         byte key[] = new byte[8];
390
391         for (int i = 0; i < key.length; i++)
392             key[i] = (byte) 0;
393
394         for (int i = 0; i < key.length && i < original.length(); i++) {
395             int iChar = (int) original.charAt(i);
396
397             key[i] = (byte) (iChar << 1);
398         }
399
400         int schedule[] = des_set_key(key);
401         int out[] = body(schedule, Eswap0, Eswap1);
402
403         byte b[] = new byte[9];
404
405         intToFourBytes(out[0], b, 0);
406         intToFourBytes(out[1], b, 4);
407         b[8] = 0;
408
409         for (int i = 2, y = 0, u = 0x80; i < 13; i++) {
410             for (int j = 0, c = 0; j < 6; j++) {
411                 c <<= 1;
412
413                 if (((int) b[y] & u) != 0)
414                     c |= 1;
415
416                 u >>>= 1;
417
418                 if (u == 0) {
419                     y++;
420                     u = 0x80;
421                 }
422                 buffer.setCharAt(i, (char) cov_2char[c]);
423             }
424         }
425         return (buffer.toString());
426     }
427
428     public static void main(String JavaDoc args[]) {
429         if (args.length >= 2) {
430             System.out.println("[" + args[0] + "] [" + args[1] + "] => [" + DESCrypt.crypt(args[0], args[1]) + "]");
431         }
432     }
433 }
Popular Tags