jcrypt


1   
2   /****************************************************************************
3    * jcrypt.java
4    *
5    * Java-based implementation of the unix crypt command
6    *
7    * Based upon C source code written by Eric Young, eay@psych.uq.oz.au
8    *
9    ****************************************************************************/
10  
11  
12  package com.ca.directory.jxplorer;
13  
14  
15  /** 
16  * This class provides a Java-based implementation of the unix crypt command.
17  *
18  * it was picked up from the web at 
19  * <a HREF=http://www.isd.cme.nist.gov/projects/rcs_lib/>www.isd.cme.nist.gov</a>
20  * and appears to be legally unencumbered.
21  *
22  * @author John Dumas
23  * @author Eric Young
24  */
25  
26  public class jcrypt
27  {
28     private jcrypt() {}
29     private static final int ITERATIONS = 16;
30     private static final int con_salt[] =
31     {
32        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
33        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
34        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
35        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
36        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
37        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
38        0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
39        0x0A, 0x0B, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 
40        0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 
41        0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 
42        0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 
43        0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24, 
44        0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 
45        0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 
46        0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 
47        0x3D, 0x3E, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 
48     };
49  
50     private static final boolean shifts2[] =
51     {
52        false, false, true, true, true, true, true, true,
53        false, true,  true, true, true, true, true, false
54     };
55  
56     private static final int skb[][] =
57     {
58        {
59           /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
60           0x00000000, 0x00000010, 0x20000000, 0x20000010, 
61           0x00010000, 0x00010010, 0x20010000, 0x20010010, 
62           0x00000800, 0x00000810, 0x20000800, 0x20000810, 
63           0x00010800, 0x00010810, 0x20010800, 0x20010810, 
64           0x00000020, 0x00000030, 0x20000020, 0x20000030, 
65           0x00010020, 0x00010030, 0x20010020, 0x20010030, 
66           0x00000820, 0x00000830, 0x20000820, 0x20000830, 
67           0x00010820, 0x00010830, 0x20010820, 0x20010830, 
68           0x00080000, 0x00080010, 0x20080000, 0x20080010, 
69           0x00090000, 0x00090010, 0x20090000, 0x20090010, 
70           0x00080800, 0x00080810, 0x20080800, 0x20080810, 
71           0x00090800, 0x00090810, 0x20090800, 0x20090810, 
72           0x00080020, 0x00080030, 0x20080020, 0x20080030, 
73           0x00090020, 0x00090030, 0x20090020, 0x20090030, 
74           0x00080820, 0x00080830, 0x20080820, 0x20080830, 
75           0x00090820, 0x00090830, 0x20090820, 0x20090830, 
76        },
77        {
78           /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
79           0x00000000, 0x02000000, 0x00002000, 0x02002000, 
80           0x00200000, 0x02200000, 0x00202000, 0x02202000, 
81           0x00000004, 0x02000004, 0x00002004, 0x02002004, 
82           0x00200004, 0x02200004, 0x00202004, 0x02202004, 
83           0x00000400, 0x02000400, 0x00002400, 0x02002400, 
84           0x00200400, 0x02200400, 0x00202400, 0x02202400, 
85           0x00000404, 0x02000404, 0x00002404, 0x02002404, 
86           0x00200404, 0x02200404, 0x00202404, 0x02202404, 
87           0x10000000, 0x12000000, 0x10002000, 0x12002000, 
88           0x10200000, 0x12200000, 0x10202000, 0x12202000, 
89           0x10000004, 0x12000004, 0x10002004, 0x12002004, 
90           0x10200004, 0x12200004, 0x10202004, 0x12202004, 
91           0x10000400, 0x12000400, 0x10002400, 0x12002400, 
92           0x10200400, 0x12200400, 0x10202400, 0x12202400, 
93           0x10000404, 0x12000404, 0x10002404, 0x12002404, 
94           0x10200404, 0x12200404, 0x10202404, 0x12202404, 
95        },
96        {
97           /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
98           0x00000000, 0x00000001, 0x00040000, 0x00040001, 
99           0x01000000, 0x01000001, 0x01040000, 0x01040001, 
100          0x00000002, 0x00000003, 0x00040002, 0x00040003, 
101          0x01000002, 0x01000003, 0x01040002, 0x01040003, 
102          0x00000200, 0x00000201, 0x00040200, 0x00040201, 
103          0x01000200, 0x01000201, 0x01040200, 0x01040201, 
104          0x00000202, 0x00000203, 0x00040202, 0x00040203, 
105          0x01000202, 0x01000203, 0x01040202, 0x01040203, 
106          0x08000000, 0x08000001, 0x08040000, 0x08040001, 
107          0x09000000, 0x09000001, 0x09040000, 0x09040001, 
108          0x08000002, 0x08000003, 0x08040002, 0x08040003, 
109          0x09000002, 0x09000003, 0x09040002, 0x09040003, 
110          0x08000200, 0x08000201, 0x08040200, 0x08040201, 
111          0x09000200, 0x09000201, 0x09040200, 0x09040201, 
112          0x08000202, 0x08000203, 0x08040202, 0x08040203, 
113          0x09000202, 0x09000203, 0x09040202, 0x09040203, 
114       },
115       {
116          /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
117          0x00000000, 0x00100000, 0x00000100, 0x00100100, 
118          0x00000008, 0x00100008, 0x00000108, 0x00100108, 
119          0x00001000, 0x00101000, 0x00001100, 0x00101100, 
120          0x00001008, 0x00101008, 0x00001108, 0x00101108, 
121          0x04000000, 0x04100000, 0x04000100, 0x04100100, 
122          0x04000008, 0x04100008, 0x04000108, 0x04100108, 
123          0x04001000, 0x04101000, 0x04001100, 0x04101100, 
124          0x04001008, 0x04101008, 0x04001108, 0x04101108, 
125          0x00020000, 0x00120000, 0x00020100, 0x00120100, 
126          0x00020008, 0x00120008, 0x00020108, 0x00120108, 
127          0x00021000, 0x00121000, 0x00021100, 0x00121100, 
128          0x00021008, 0x00121008, 0x00021108, 0x00121108, 
129          0x04020000, 0x04120000, 0x04020100, 0x04120100, 
130          0x04020008, 0x04120008, 0x04020108, 0x04120108, 
131          0x04021000, 0x04121000, 0x04021100, 0x04121100, 
132          0x04021008, 0x04121008, 0x04021108, 0x04121108, 
133       },
134       {
135          /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
136          0x00000000, 0x10000000, 0x00010000, 0x10010000, 
137          0x00000004, 0x10000004, 0x00010004, 0x10010004, 
138          0x20000000, 0x30000000, 0x20010000, 0x30010000, 
139          0x20000004, 0x30000004, 0x20010004, 0x30010004, 
140          0x00100000, 0x10100000, 0x00110000, 0x10110000, 
141          0x00100004, 0x10100004, 0x00110004, 0x10110004, 
142          0x20100000, 0x30100000, 0x20110000, 0x30110000, 
143          0x20100004, 0x30100004, 0x20110004, 0x30110004, 
144          0x00001000, 0x10001000, 0x00011000, 0x10011000, 
145          0x00001004, 0x10001004, 0x00011004, 0x10011004, 
146          0x20001000, 0x30001000, 0x20011000, 0x30011000, 
147          0x20001004, 0x30001004, 0x20011004, 0x30011004, 
148          0x00101000, 0x10101000, 0x00111000, 0x10111000, 
149          0x00101004, 0x10101004, 0x00111004, 0x10111004, 
150          0x20101000, 0x30101000, 0x20111000, 0x30111000, 
151          0x20101004, 0x30101004, 0x20111004, 0x30111004, 
152       },
153       {
154          /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
155          0x00000000, 0x08000000, 0x00000008, 0x08000008, 
156          0x00000400, 0x08000400, 0x00000408, 0x08000408, 
157          0x00020000, 0x08020000, 0x00020008, 0x08020008, 
158          0x00020400, 0x08020400, 0x00020408, 0x08020408, 
159          0x00000001, 0x08000001, 0x00000009, 0x08000009, 
160          0x00000401, 0x08000401, 0x00000409, 0x08000409, 
161          0x00020001, 0x08020001, 0x00020009, 0x08020009, 
162          0x00020401, 0x08020401, 0x00020409, 0x08020409, 
163          0x02000000, 0x0A000000, 0x02000008, 0x0A000008, 
164          0x02000400, 0x0A000400, 0x02000408, 0x0A000408, 
165          0x02020000, 0x0A020000, 0x02020008, 0x0A020008, 
166          0x02020400, 0x0A020400, 0x02020408, 0x0A020408, 
167          0x02000001, 0x0A000001, 0x02000009, 0x0A000009, 
168          0x02000401, 0x0A000401, 0x02000409, 0x0A000409, 
169          0x02020001, 0x0A020001, 0x02020009, 0x0A020009, 
170          0x02020401, 0x0A020401, 0x02020409, 0x0A020409, 
171       },
172       {
173          /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
174          0x00000000, 0x00000100, 0x00080000, 0x00080100, 
175          0x01000000, 0x01000100, 0x01080000, 0x01080100, 
176          0x00000010, 0x00000110, 0x00080010, 0x00080110, 
177          0x01000010, 0x01000110, 0x01080010, 0x01080110, 
178          0x00200000, 0x00200100, 0x00280000, 0x00280100, 
179          0x01200000, 0x01200100, 0x01280000, 0x01280100, 
180          0x00200010, 0x00200110, 0x00280010, 0x00280110, 
181          0x01200010, 0x01200110, 0x01280010, 0x01280110, 
182          0x00000200, 0x00000300, 0x00080200, 0x00080300, 
183          0x01000200, 0x01000300, 0x01080200, 0x01080300, 
184          0x00000210, 0x00000310, 0x00080210, 0x00080310, 
185          0x01000210, 0x01000310, 0x01080210, 0x01080310, 
186          0x00200200, 0x00200300, 0x00280200, 0x00280300, 
187          0x01200200, 0x01200300, 0x01280200, 0x01280300, 
188          0x00200210, 0x00200310, 0x00280210, 0x00280310, 
189          0x01200210, 0x01200310, 0x01280210, 0x01280310, 
190       },
191       {
192          /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
193          0x00000000, 0x04000000, 0x00040000, 0x04040000, 
194          0x00000002, 0x04000002, 0x00040002, 0x04040002, 
195          0x00002000, 0x04002000, 0x00042000, 0x04042000, 
196          0x00002002, 0x04002002, 0x00042002, 0x04042002, 
197          0x00000020, 0x04000020, 0x00040020, 0x04040020, 
198          0x00000022, 0x04000022, 0x00040022, 0x04040022, 
199          0x00002020, 0x04002020, 0x00042020, 0x04042020, 
200          0x00002022, 0x04002022, 0x00042022, 0x04042022, 
201          0x00000800, 0x04000800, 0x00040800, 0x04040800, 
202          0x00000802, 0x04000802, 0x00040802, 0x04040802, 
203          0x00002800, 0x04002800, 0x00042800, 0x04042800, 
204          0x00002802, 0x04002802, 0x00042802, 0x04042802, 
205          0x00000820, 0x04000820, 0x00040820, 0x04040820, 
206          0x00000822, 0x04000822, 0x00040822, 0x04040822, 
207          0x00002820, 0x04002820, 0x00042820, 0x04042820, 
208          0x00002822, 0x04002822, 0x00042822, 0x04042822, 
209       },
210    };
211 
212    private static final int SPtrans[][] =
213    {
214       {
215          /* nibble 0 */
216          0x00820200, 0x00020000, 0x80800000, 0x80820200,
217          0x00800000, 0x80020200, 0x80020000, 0x80800000,
218          0x80020200, 0x00820200, 0x00820000, 0x80000200,
219          0x80800200, 0x00800000, 0x00000000, 0x80020000,
220          0x00020000, 0x80000000, 0x00800200, 0x00020200,
221          0x80820200, 0x00820000, 0x80000200, 0x00800200,
222          0x80000000, 0x00000200, 0x00020200, 0x80820000,
223          0x00000200, 0x80800200, 0x80820000, 0x00000000,
224          0x00000000, 0x80820200, 0x00800200, 0x80020000,
225          0x00820200, 0x00020000, 0x80000200, 0x00800200,
226          0x80820000, 0x00000200, 0x00020200, 0x80800000,
227          0x80020200, 0x80000000, 0x80800000, 0x00820000,
228          0x80820200, 0x00020200, 0x00820000, 0x80800200,
229          0x00800000, 0x80000200, 0x80020000, 0x00000000,
230          0x00020000, 0x00800000, 0x80800200, 0x00820200,
231          0x80000000, 0x80820000, 0x00000200, 0x80020200,
232       },
233       {
234          /* nibble 1 */
235          0x10042004, 0x00000000, 0x00042000, 0x10040000,
236          0x10000004, 0x00002004, 0x10002000, 0x00042000,
237          0x00002000, 0x10040004, 0x00000004, 0x10002000,
238          0x00040004, 0x10042000, 0x10040000, 0x00000004,
239          0x00040000, 0x10002004, 0x10040004, 0x00002000,
240          0x00042004, 0x10000000, 0x00000000, 0x00040004,
241          0x10002004, 0x00042004, 0x10042000, 0x10000004,
242          0x10000000, 0x00040000, 0x00002004, 0x10042004,
243          0x00040004, 0x10042000, 0x10002000, 0x00042004,
244          0x10042004, 0x00040004, 0x10000004, 0x00000000,
245          0x10000000, 0x00002004, 0x00040000, 0x10040004,
246          0x00002000, 0x10000000, 0x00042004, 0x10002004,
247          0x10042000, 0x00002000, 0x00000000, 0x10000004,
248          0x00000004, 0x10042004, 0x00042000, 0x10040000,
249          0x10040004, 0x00040000, 0x00002004, 0x10002000,
250          0x10002004, 0x00000004, 0x10040000, 0x00042000,
251       },
252       {
253          /* nibble 2 */
254          0x41000000, 0x01010040, 0x00000040, 0x41000040,
255          0x40010000, 0x01000000, 0x41000040, 0x00010040,
256          0x01000040, 0x00010000, 0x01010000, 0x40000000,
257          0x41010040, 0x40000040, 0x40000000, 0x41010000,
258          0x00000000, 0x40010000, 0x01010040, 0x00000040,
259          0x40000040, 0x41010040, 0x00010000, 0x41000000,
260          0x41010000, 0x01000040, 0x40010040, 0x01010000,
261          0x00010040, 0x00000000, 0x01000000, 0x40010040,
262          0x01010040, 0x00000040, 0x40000000, 0x00010000,
263          0x40000040, 0x40010000, 0x01010000, 0x41000040,
264          0x00000000, 0x01010040, 0x00010040, 0x41010000,
265          0x40010000, 0x01000000, 0x41010040, 0x40000000,
266          0x40010040, 0x41000000, 0x01000000, 0x41010040,
267          0x00010000, 0x01000040, 0x41000040, 0x00010040,
268          0x01000040, 0x00000000, 0x41010000, 0x40000040,
269          0x41000000, 0x40010040, 0x00000040, 0x01010000,
270       },
271       {
272          /* nibble 3 */
273          0x00100402, 0x04000400, 0x00000002, 0x04100402,
274          0x00000000, 0x04100000, 0x04000402, 0x00100002,
275          0x04100400, 0x04000002, 0x04000000, 0x00000402,
276          0x04000002, 0x00100402, 0x00100000, 0x04000000,
277          0x04100002, 0x00100400, 0x00000400, 0x00000002,
278          0x00100400, 0x04000402, 0x04100000, 0x00000400,
279          0x00000402, 0x00000000, 0x00100002, 0x04100400,
280          0x04000400, 0x04100002, 0x04100402, 0x00100000,
281          0x04100002, 0x00000402, 0x00100000, 0x04000002,
282          0x00100400, 0x04000400, 0x00000002, 0x04100000,
283          0x04000402, 0x00000000, 0x00000400, 0x00100002,
284          0x00000000, 0x04100002, 0x04100400, 0x00000400,
285          0x04000000, 0x04100402, 0x00100402, 0x00100000,
286          0x04100402, 0x00000002, 0x04000400, 0x00100402,
287          0x00100002, 0x00100400, 0x04100000, 0x04000402,
288          0x00000402, 0x04000000, 0x04000002, 0x04100400,
289       },
290       {
291          /* nibble 4 */
292          0x02000000, 0x00004000, 0x00000100, 0x02004108,
293          0x02004008, 0x02000100, 0x00004108, 0x02004000,
294          0x00004000, 0x00000008, 0x02000008, 0x00004100,
295          0x02000108, 0x02004008, 0x02004100, 0x00000000,
296          0x00004100, 0x02000000, 0x00004008, 0x00000108,
297          0x02000100, 0x00004108, 0x00000000, 0x02000008,
298          0x00000008, 0x02000108, 0x02004108, 0x00004008,
299          0x02004000, 0x00000100, 0x00000108, 0x02004100,
300          0x02004100, 0x02000108, 0x00004008, 0x02004000,
301          0x00004000, 0x00000008, 0x02000008, 0x02000100,
302          0x02000000, 0x00004100, 0x02004108, 0x00000000,
303          0x00004108, 0x02000000, 0x00000100, 0x00004008,
304          0x02000108, 0x00000100, 0x00000000, 0x02004108,
305          0x02004008, 0x02004100, 0x00000108, 0x00004000,
306          0x00004100, 0x02004008, 0x02000100, 0x00000108,
307          0x00000008, 0x00004108, 0x02004000, 0x02000008,
308       },
309       {
310          /* nibble 5 */
311          0x20000010, 0x00080010, 0x00000000, 0x20080800,
312          0x00080010, 0x00000800, 0x20000810, 0x00080000,
313          0x00000810, 0x20080810, 0x00080800, 0x20000000,
314          0x20000800, 0x20000010, 0x20080000, 0x00080810,
315          0x00080000, 0x20000810, 0x20080010, 0x00000000,
316          0x00000800, 0x00000010, 0x20080800, 0x20080010,
317          0x20080810, 0x20080000, 0x20000000, 0x00000810,
318          0x00000010, 0x00080800, 0x00080810, 0x20000800,
319          0x00000810, 0x20000000, 0x20000800, 0x00080810,
320          0x20080800, 0x00080010, 0x00000000, 0x20000800,
321          0x20000000, 0x00000800, 0x20080010, 0x00080000,
322          0x00080010, 0x20080810, 0x00080800, 0x00000010,
323          0x20080810, 0x00080800, 0x00080000, 0x20000810,
324          0x20000010, 0x20080000, 0x00080810, 0x00000000,
325          0x00000800, 0x20000010, 0x20000810, 0x20080800,
326          0x20080000, 0x00000810, 0x00000010, 0x20080010,
327       },
328       {
329          /* nibble 6 */
330          0x00001000, 0x00000080, 0x00400080, 0x00400001,
331          0x00401081, 0x00001001, 0x00001080, 0x00000000,
332          0x00400000, 0x00400081, 0x00000081, 0x00401000,
333          0x00000001, 0x00401080, 0x00401000, 0x00000081,
334          0x00400081, 0x00001000, 0x00001001, 0x00401081,
335          0x00000000, 0x00400080, 0x00400001, 0x00001080,
336          0x00401001, 0x00001081, 0x00401080, 0x00000001,
337          0x00001081, 0x00401001, 0x00000080, 0x00400000,
338          0x00001081, 0x00401000, 0x00401001, 0x00000081,
339          0x00001000, 0x00000080, 0x00400000, 0x00401001,
340          0x00400081, 0x00001081, 0x00001080, 0x00000000,
341          0x00000080, 0x00400001, 0x00000001, 0x00400080,
342          0x00000000, 0x00400081, 0x00400080, 0x00001080,
343          0x00000081, 0x00001000, 0x00401081, 0x00400000,
344          0x00401080, 0x00000001, 0x00001001, 0x00401081,
345          0x00400001, 0x00401080, 0x00401000, 0x00001001,
346       },
347       {
348          /* nibble 7 */
349          0x08200020, 0x08208000, 0x00008020, 0x00000000,
350          0x08008000, 0x00200020, 0x08200000, 0x08208020,
351          0x00000020, 0x08000000, 0x00208000, 0x00008020,
352          0x00208020, 0x08008020, 0x08000020, 0x08200000,
353          0x00008000, 0x00208020, 0x00200020, 0x08008000,
354          0x08208020, 0x08000020, 0x00000000, 0x00208000,
355          0x08000000, 0x00200000, 0x08008020, 0x08200020,
356          0x00200000, 0x00008000, 0x08208000, 0x00000020,
357          0x00200000, 0x00008000, 0x08000020, 0x08208020,
358          0x00008020, 0x08000000, 0x00000000, 0x00208000,
359          0x08200020, 0x08008020, 0x08008000, 0x00200020,
360          0x08208000, 0x00000020, 0x00200020, 0x08008000,
361          0x08208020, 0x00200000, 0x08200000, 0x08000020,
362          0x00208000, 0x00008020, 0x08008020, 0x08200000,
363          0x00000020, 0x08208000, 0x00208020, 0x00000000,
364          0x08000000, 0x08200020, 0x00008000, 0x00208020
365       }
366    };
367 
368    private static final int cov_2char[] =
369    {
370       0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 
371       0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 
372       0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 
373       0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 
374       0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 
375       0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 
376       0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 
377       0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
378    };
379 
380    private static final int byteToUnsigned(byte b)
381    {
382       int value = (int)b;
383 
384       return(value >= 0 ? value : value + 256);
385    }
386 
387    private static int fourBytesToInt(byte b[], int offset)
388    {
389       int value;
390 
391       value  =  byteToUnsigned(b[offset++]);
392       value |= (byteToUnsigned(b[offset++]) <<  8);
393       value |= (byteToUnsigned(b[offset++]) << 16);
394       value |= (byteToUnsigned(b[offset++]) << 24);
395 
396       return(value);
397    }
398 
399    private static final void intToFourBytes(int iValue, byte b[], int offset)
400    {
401       b[offset++] = (byte)((iValue)        & 0xff);
402       b[offset++] = (byte)((iValue >>> 8 ) & 0xff);
403       b[offset++] = (byte)((iValue >>> 16) & 0xff);
404       b[offset++] = (byte)((iValue >>> 24) & 0xff);
405    }
406 
407    private static final void PERM_OP(int a, int b, int n, int m, int results[])
408    {
409       int t;
410       //CBUtility.log("PERM_OP("+Integer.toHexString(a)+","+Integer.toHexString(b)+","+n+","+m+") called.");
411       t = ((a >>> n) ^ b) & m;
412       a ^= t << n;
413       b ^= t;
414 
415       results[0] = a;
416       results[1] = b;
417       //CBUtility.log("PERM_OP(): results = "+Integer.toHexString(a)+","+Integer.toHexString(b));
418    }
419 
420    private static final int HPERM_OP(int a, int n, int m)
421    {
422       int t;
423 
424       t = ((a << (16 - n)) ^ a) & m;
425       a = a ^ t ^ (t >>> (16 - n));
426 
427       return(a);
428    }
429 
430    private static int [] des_set_key(byte key[])
431    {
432       int schedule[] = new int[ITERATIONS * 2];
433 
434       int c = fourBytesToInt(key, 0);
435       int d = fourBytesToInt(key, 4);
436 
437       int results[] = new int[2];
438 
439       PERM_OP(d, c, 4, 0x0f0f0f0f, results);
440       d = results[0]; c = results[1];
441 
442       c = HPERM_OP(c, -2, 0xcccc0000);
443       d = HPERM_OP(d, -2, 0xcccc0000);
444 
445       PERM_OP(d, c, 1, 0x55555555, results);
446       d = results[0]; c = results[1];
447 
448       PERM_OP(c, d, 8, 0x00ff00ff, results);
449       c = results[0]; d = results[1];
450 
451       PERM_OP(d, c, 1, 0x55555555, results);
452       d = results[0]; c = results[1];
453 
454       d = (((d & 0x000000ff) <<  16) |  (d & 0x0000ff00)     |
455            ((d & 0x00ff0000) >>> 16) | ((c & 0xf0000000) >>> 4));
456       c &= 0x0fffffff;
457 
458       int s, t;
459       int j = 0;
460 
461       for(int i = 0; i < ITERATIONS; i ++)
462       {
463          if(shifts2[i])
464          {
465             c = (c >>> 2) | (c << 26);
466             d = (d >>> 2) | (d << 26);
467          }
468          else
469          {
470             c = (c >>> 1) | (c << 27);
471             d = (d >>> 1) | (d << 27);
472          }
473 
474          c &= 0x0fffffff;
475          d &= 0x0fffffff;
476 
477          s = skb[0][ (c       ) & 0x3f                       ]|
478              skb[1][((c >>>  6) & 0x03) | ((c >>>  7) & 0x3c)]|
479              skb[2][((c >>> 13) & 0x0f) | ((c >>> 14) & 0x30)]|
480              skb[3][((c >>> 20) & 0x01) | ((c >>> 21) & 0x06) |
481                                           ((c >>> 22) & 0x38)];
482 
483          t = skb[4][ (d     )  & 0x3f                       ]|
484              skb[5][((d >>> 7) & 0x03) | ((d >>>  8) & 0x3c)]|
485              skb[6][ (d >>>15) & 0x3f                       ]|
486              skb[7][((d >>>21) & 0x0f) | ((d >>> 22) & 0x30)];
487 
488          // CBUtility.log("des_set_key(): i = "+i+", c = "+Integer.toHexString(c)+", d = "+Integer.toHexString(d)+", s = "+Integer.toHexString(s)+", t = "+Integer.toHexString(t));
489 
490          schedule[j++] = ((t <<  16) | (s & 0x0000ffff)) & 0xffffffff;
491          s             = ((s >>> 16) | (t & 0xffff0000));
492          // CBUtility.log("des_set_key():  s = "+Integer.toHexString(s)+", schedule["+(j-1)+"] = "+Integer.toHexString(schedule[(j-1)]) );
493 
494          s             = (s << 4) | (s >>> 28);
495          schedule[j++] = s & 0xffffffff;
496          // CBUtility.log("des_set_key():  s = "+Integer.toHexString(s)+", schedule["+(j-1)+"] = "+Integer.toHexString(schedule[(j-1)]) );
497     
498       }
499       return(schedule);
500    }
501 
502    private static final int D_ENCRYPT
503    (
504       int L, int R, int S, int E0, int E1, int s[]
505    )
506    {
507       int t, u, v;
508 
509       v = R ^ (R >>> 16);
510       u = v & E0;
511       v = v & E1;
512       u = (u ^ (u << 16)) ^ R ^ s[S];
513       t = (v ^ (v << 16)) ^ R ^ s[S + 1];
514       t = (t >>> 4) | (t << 28);
515 
516       L ^= SPtrans[1][(t       ) & 0x3f] |
517            SPtrans[3][(t >>>  8) & 0x3f] |
518            SPtrans[5][(t >>> 16) & 0x3f] |
519            SPtrans[7][(t >>> 24) & 0x3f] |
520            SPtrans[0][(u       ) & 0x3f] |
521            SPtrans[2][(u >>>  8) & 0x3f] |
522            SPtrans[4][(u >>> 16) & 0x3f] |
523            SPtrans[6][(u >>> 24) & 0x3f];
524 
525       return(L);
526    }
527 
528    private static final int [] body(int schedule[], int Eswap0, int Eswap1)
529    {
530       int left = 0;
531       int right = 0;
532       int t     = 0;
533 
534       for(int j = 0; j < 25; j ++)
535       {
536          for(int i = 0; i < ITERATIONS * 2; i += 4)
537          {
538             left  = D_ENCRYPT(left,  right, i,     Eswap0, Eswap1, schedule);
539             right = D_ENCRYPT(right, left,  i + 2, Eswap0, Eswap1, schedule);
540          }
541          t     = left; 
542          left  = right; 
543          right = t;
544       }
545 
546       t = right;
547 
548       right = (left >>> 1) | (left << 31);
549       left  = (t    >>> 1) | (t    << 31);
550 
551       left  &= 0xffffffff;
552       right &= 0xffffffff;
553 
554       int results[] = new int[2];
555 
556       PERM_OP(right, left, 1, 0x55555555, results); 
557       right = results[0]; left = results[1];
558 
559       PERM_OP(left, right, 8, 0x00ff00ff, results); 
560       left = results[0]; right = results[1];
561 
562       PERM_OP(right, left, 2, 0x33333333, results); 
563       right = results[0]; left = results[1];
564 
565       PERM_OP(left, right, 16, 0x0000ffff, results);
566       left = results[0]; right = results[1];
567 
568       PERM_OP(right, left, 4, 0x0f0f0f0f, results);
569       right = results[0]; left = results[1];
570 
571       int out[] = new int[2];
572 
573       out[0] = left; out[1] = right;
574 
575       return(out);
576    }
577 
578    /**
579    * Encrypts a passwd.
580    *
581    * @param original Password or key before encryption.
582    * @param salt 2 letter string used during encryption and returned at the beggining of the resulting encrypted string.
583   * @return the encrypted passwd with the salt included as the first 2 characters.
584   */
585    public static final String   crypt( String   original, String   salt)
586    {
587       while(salt.length() < 2)
588          salt += "A";
589 
590       StringBuffer   buffer = new StringBuffer  ("             ");
591 
592       char charZero = salt.charAt(0);
593       char charOne  = salt.charAt(1);
594 
595       buffer.setCharAt(0, charZero);
596       buffer.setCharAt(1, charOne);
597 
598       int Eswap0 = con_salt[(int)charZero];
599       int Eswap1 = con_salt[(int)charOne] << 4;
600  
601       byte key[] = new byte[8];
602 
603       for(int i = 0; i < key.length; i ++)
604          key[i] = (byte)0;
605 
606       for(int i = 0; i < key.length && i < original.length(); i ++)
607       {
608          int iChar = (int)original.charAt(i);
609 
610          key[i] = (byte)(iChar << 1);
611       }
612 
613       /*CBUtility.log("key = ");
614       for(int jj = 0; jj < key.length; jj++)
615       {
616         if(jj % 8 == 0)
617         {
618             System.out.print("\n");
619         }
620         System.out.print(" "+Integer.toHexString(key[jj])+" ");
621       } */
622       
623       int schedule[] = des_set_key(key);
624       /* CBUtility.log("schedule = ");
625       for(int ii = 0; ii < schedule.length; ii++)
626       {
627         if(ii % 8 == 0)
628         {
629             System.out.print("\n");
630         }
631         System.out.print(" "+Integer.toHexString(schedule[ii])+" ");
632       } */
633       int out[]      = body(schedule, Eswap0, Eswap1);
634       
635       /* CBUtility.log("out = ");
636       for(int iii = 0; iii < out.length; iii++)
637       {
638         if(iii % 8 == 0)
639         {
640             System.out.print("\n");
641         }
642         System.out.print(" "+Integer.toHexString(out[iii])+" ");
643       } */
644         
645       byte b[] = new byte[9];
646 
647       intToFourBytes(out[0], b, 0);
648       intToFourBytes(out[1], b, 4);
649       b[8] = 0;
650 
651       for(int i = 2, y = 0, u = 0x80; i < 13; i ++)
652       {
653          for(int j = 0, c = 0; j < 6; j ++)
654          {
655             c <<= 1;
656 
657             if(((int)b[y] & u) != 0)
658                c |= 1;
659 
660             u >>>= 1;
661 
662             if(u == 0)
663             {
664                y++;
665                u = 0x80;
666             }
667             buffer.setCharAt(i, (char)cov_2char[c]);
668          }
669       }
670       return(buffer.toString());
671    }
672 
673    /**
674    * Main function called when the class is run as a standalone program.
675    */
676    public static void main(String   args[])
677    {
678       if(args.length >= 2)
679       {
680          System.out.println
681          (
682             "[" + args[0] + "] [" + args[1] + "] => [" +
683             jcrypt.crypt(args[1], args[0]) + "]"
684          );
685       }
686    }
687 }
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags