feisty meow concerns codebase  2.140
UnixCrypt.java
Go to the documentation of this file.
1 package org.feistymeow.encryption;
2 
3 import java.util.ArrayList;
4 
5 /****************************************************************************
6  * Java-based implementation of the unix UnixCrypt(3) command
7  *
8  * Based upon C source code written by Eric Young, eay@psych.uq.oz.au
9  * Java conversion by John F. Dumas, jdumas@zgs.com
10  *
11  * Found at http://locutus.kingwoodcable.com/jfd/UnixCrypt.html
12  * Minor optimizations by Wes Biggs, wes@cacas.org
13  *
14  * Eric's original code is licensed under the BSD license. As this is
15  * derivative, the same license applies.
16  *
17  * Note: UnixCrypt.class is much smaller when compiled with javac -O
18  ****************************************************************************/
19 
20 public class UnixCrypt
21 {
22  private UnixCrypt() {} // defined so class can't be instantiated.
23 
24  private static final int ITERATIONS = 16;
25 
26  private static final boolean shifts2[] = {
27  false, false, true, true, true, true, true, true,
28  false, true, true, true, true, true, true, false
29  };
30 
31  private static final int skb[][] = {
32  {
33  /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
34  0x00000000, 0x00000010, 0x20000000, 0x20000010,
35  0x00010000, 0x00010010, 0x20010000, 0x20010010,
36  0x00000800, 0x00000810, 0x20000800, 0x20000810,
37  0x00010800, 0x00010810, 0x20010800, 0x20010810,
38  0x00000020, 0x00000030, 0x20000020, 0x20000030,
39  0x00010020, 0x00010030, 0x20010020, 0x20010030,
40  0x00000820, 0x00000830, 0x20000820, 0x20000830,
41  0x00010820, 0x00010830, 0x20010820, 0x20010830,
42  0x00080000, 0x00080010, 0x20080000, 0x20080010,
43  0x00090000, 0x00090010, 0x20090000, 0x20090010,
44  0x00080800, 0x00080810, 0x20080800, 0x20080810,
45  0x00090800, 0x00090810, 0x20090800, 0x20090810,
46  0x00080020, 0x00080030, 0x20080020, 0x20080030,
47  0x00090020, 0x00090030, 0x20090020, 0x20090030,
48  0x00080820, 0x00080830, 0x20080820, 0x20080830,
49  0x00090820, 0x00090830, 0x20090820, 0x20090830,
50  },
51  {
52  /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
53  0x00000000, 0x02000000, 0x00002000, 0x02002000,
54  0x00200000, 0x02200000, 0x00202000, 0x02202000,
55  0x00000004, 0x02000004, 0x00002004, 0x02002004,
56  0x00200004, 0x02200004, 0x00202004, 0x02202004,
57  0x00000400, 0x02000400, 0x00002400, 0x02002400,
58  0x00200400, 0x02200400, 0x00202400, 0x02202400,
59  0x00000404, 0x02000404, 0x00002404, 0x02002404,
60  0x00200404, 0x02200404, 0x00202404, 0x02202404,
61  0x10000000, 0x12000000, 0x10002000, 0x12002000,
62  0x10200000, 0x12200000, 0x10202000, 0x12202000,
63  0x10000004, 0x12000004, 0x10002004, 0x12002004,
64  0x10200004, 0x12200004, 0x10202004, 0x12202004,
65  0x10000400, 0x12000400, 0x10002400, 0x12002400,
66  0x10200400, 0x12200400, 0x10202400, 0x12202400,
67  0x10000404, 0x12000404, 0x10002404, 0x12002404,
68  0x10200404, 0x12200404, 0x10202404, 0x12202404,
69  },
70  {
71  /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
72  0x00000000, 0x00000001, 0x00040000, 0x00040001,
73  0x01000000, 0x01000001, 0x01040000, 0x01040001,
74  0x00000002, 0x00000003, 0x00040002, 0x00040003,
75  0x01000002, 0x01000003, 0x01040002, 0x01040003,
76  0x00000200, 0x00000201, 0x00040200, 0x00040201,
77  0x01000200, 0x01000201, 0x01040200, 0x01040201,
78  0x00000202, 0x00000203, 0x00040202, 0x00040203,
79  0x01000202, 0x01000203, 0x01040202, 0x01040203,
80  0x08000000, 0x08000001, 0x08040000, 0x08040001,
81  0x09000000, 0x09000001, 0x09040000, 0x09040001,
82  0x08000002, 0x08000003, 0x08040002, 0x08040003,
83  0x09000002, 0x09000003, 0x09040002, 0x09040003,
84  0x08000200, 0x08000201, 0x08040200, 0x08040201,
85  0x09000200, 0x09000201, 0x09040200, 0x09040201,
86  0x08000202, 0x08000203, 0x08040202, 0x08040203,
87  0x09000202, 0x09000203, 0x09040202, 0x09040203,
88  },
89  {
90  /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
91  0x00000000, 0x00100000, 0x00000100, 0x00100100,
92  0x00000008, 0x00100008, 0x00000108, 0x00100108,
93  0x00001000, 0x00101000, 0x00001100, 0x00101100,
94  0x00001008, 0x00101008, 0x00001108, 0x00101108,
95  0x04000000, 0x04100000, 0x04000100, 0x04100100,
96  0x04000008, 0x04100008, 0x04000108, 0x04100108,
97  0x04001000, 0x04101000, 0x04001100, 0x04101100,
98  0x04001008, 0x04101008, 0x04001108, 0x04101108,
99  0x00020000, 0x00120000, 0x00020100, 0x00120100,
100  0x00020008, 0x00120008, 0x00020108, 0x00120108,
101  0x00021000, 0x00121000, 0x00021100, 0x00121100,
102  0x00021008, 0x00121008, 0x00021108, 0x00121108,
103  0x04020000, 0x04120000, 0x04020100, 0x04120100,
104  0x04020008, 0x04120008, 0x04020108, 0x04120108,
105  0x04021000, 0x04121000, 0x04021100, 0x04121100,
106  0x04021008, 0x04121008, 0x04021108, 0x04121108,
107  },
108  {
109  /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
110  0x00000000, 0x10000000, 0x00010000, 0x10010000,
111  0x00000004, 0x10000004, 0x00010004, 0x10010004,
112  0x20000000, 0x30000000, 0x20010000, 0x30010000,
113  0x20000004, 0x30000004, 0x20010004, 0x30010004,
114  0x00100000, 0x10100000, 0x00110000, 0x10110000,
115  0x00100004, 0x10100004, 0x00110004, 0x10110004,
116  0x20100000, 0x30100000, 0x20110000, 0x30110000,
117  0x20100004, 0x30100004, 0x20110004, 0x30110004,
118  0x00001000, 0x10001000, 0x00011000, 0x10011000,
119  0x00001004, 0x10001004, 0x00011004, 0x10011004,
120  0x20001000, 0x30001000, 0x20011000, 0x30011000,
121  0x20001004, 0x30001004, 0x20011004, 0x30011004,
122  0x00101000, 0x10101000, 0x00111000, 0x10111000,
123  0x00101004, 0x10101004, 0x00111004, 0x10111004,
124  0x20101000, 0x30101000, 0x20111000, 0x30111000,
125  0x20101004, 0x30101004, 0x20111004, 0x30111004,
126  },
127  {
128  /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
129  0x00000000, 0x08000000, 0x00000008, 0x08000008,
130  0x00000400, 0x08000400, 0x00000408, 0x08000408,
131  0x00020000, 0x08020000, 0x00020008, 0x08020008,
132  0x00020400, 0x08020400, 0x00020408, 0x08020408,
133  0x00000001, 0x08000001, 0x00000009, 0x08000009,
134  0x00000401, 0x08000401, 0x00000409, 0x08000409,
135  0x00020001, 0x08020001, 0x00020009, 0x08020009,
136  0x00020401, 0x08020401, 0x00020409, 0x08020409,
137  0x02000000, 0x0A000000, 0x02000008, 0x0A000008,
138  0x02000400, 0x0A000400, 0x02000408, 0x0A000408,
139  0x02020000, 0x0A020000, 0x02020008, 0x0A020008,
140  0x02020400, 0x0A020400, 0x02020408, 0x0A020408,
141  0x02000001, 0x0A000001, 0x02000009, 0x0A000009,
142  0x02000401, 0x0A000401, 0x02000409, 0x0A000409,
143  0x02020001, 0x0A020001, 0x02020009, 0x0A020009,
144  0x02020401, 0x0A020401, 0x02020409, 0x0A020409,
145  },
146  {
147  /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
148  0x00000000, 0x00000100, 0x00080000, 0x00080100,
149  0x01000000, 0x01000100, 0x01080000, 0x01080100,
150  0x00000010, 0x00000110, 0x00080010, 0x00080110,
151  0x01000010, 0x01000110, 0x01080010, 0x01080110,
152  0x00200000, 0x00200100, 0x00280000, 0x00280100,
153  0x01200000, 0x01200100, 0x01280000, 0x01280100,
154  0x00200010, 0x00200110, 0x00280010, 0x00280110,
155  0x01200010, 0x01200110, 0x01280010, 0x01280110,
156  0x00000200, 0x00000300, 0x00080200, 0x00080300,
157  0x01000200, 0x01000300, 0x01080200, 0x01080300,
158  0x00000210, 0x00000310, 0x00080210, 0x00080310,
159  0x01000210, 0x01000310, 0x01080210, 0x01080310,
160  0x00200200, 0x00200300, 0x00280200, 0x00280300,
161  0x01200200, 0x01200300, 0x01280200, 0x01280300,
162  0x00200210, 0x00200310, 0x00280210, 0x00280310,
163  0x01200210, 0x01200310, 0x01280210, 0x01280310,
164  },
165  {
166  /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
167  0x00000000, 0x04000000, 0x00040000, 0x04040000,
168  0x00000002, 0x04000002, 0x00040002, 0x04040002,
169  0x00002000, 0x04002000, 0x00042000, 0x04042000,
170  0x00002002, 0x04002002, 0x00042002, 0x04042002,
171  0x00000020, 0x04000020, 0x00040020, 0x04040020,
172  0x00000022, 0x04000022, 0x00040022, 0x04040022,
173  0x00002020, 0x04002020, 0x00042020, 0x04042020,
174  0x00002022, 0x04002022, 0x00042022, 0x04042022,
175  0x00000800, 0x04000800, 0x00040800, 0x04040800,
176  0x00000802, 0x04000802, 0x00040802, 0x04040802,
177  0x00002800, 0x04002800, 0x00042800, 0x04042800,
178  0x00002802, 0x04002802, 0x00042802, 0x04042802,
179  0x00000820, 0x04000820, 0x00040820, 0x04040820,
180  0x00000822, 0x04000822, 0x00040822, 0x04040822,
181  0x00002820, 0x04002820, 0x00042820, 0x04042820,
182  0x00002822, 0x04002822, 0x00042822, 0x04042822,
183  }
184  };
185 
186  private static final int SPtrans[][] = {
187  {
188  /* nibble 0 */
189  0x00820200, 0x00020000, 0x80800000, 0x80820200,
190  0x00800000, 0x80020200, 0x80020000, 0x80800000,
191  0x80020200, 0x00820200, 0x00820000, 0x80000200,
192  0x80800200, 0x00800000, 0x00000000, 0x80020000,
193  0x00020000, 0x80000000, 0x00800200, 0x00020200,
194  0x80820200, 0x00820000, 0x80000200, 0x00800200,
195  0x80000000, 0x00000200, 0x00020200, 0x80820000,
196  0x00000200, 0x80800200, 0x80820000, 0x00000000,
197  0x00000000, 0x80820200, 0x00800200, 0x80020000,
198  0x00820200, 0x00020000, 0x80000200, 0x00800200,
199  0x80820000, 0x00000200, 0x00020200, 0x80800000,
200  0x80020200, 0x80000000, 0x80800000, 0x00820000,
201  0x80820200, 0x00020200, 0x00820000, 0x80800200,
202  0x00800000, 0x80000200, 0x80020000, 0x00000000,
203  0x00020000, 0x00800000, 0x80800200, 0x00820200,
204  0x80000000, 0x80820000, 0x00000200, 0x80020200,
205  },
206  {
207  /* nibble 1 */
208  0x10042004, 0x00000000, 0x00042000, 0x10040000,
209  0x10000004, 0x00002004, 0x10002000, 0x00042000,
210  0x00002000, 0x10040004, 0x00000004, 0x10002000,
211  0x00040004, 0x10042000, 0x10040000, 0x00000004,
212  0x00040000, 0x10002004, 0x10040004, 0x00002000,
213  0x00042004, 0x10000000, 0x00000000, 0x00040004,
214  0x10002004, 0x00042004, 0x10042000, 0x10000004,
215  0x10000000, 0x00040000, 0x00002004, 0x10042004,
216  0x00040004, 0x10042000, 0x10002000, 0x00042004,
217  0x10042004, 0x00040004, 0x10000004, 0x00000000,
218  0x10000000, 0x00002004, 0x00040000, 0x10040004,
219  0x00002000, 0x10000000, 0x00042004, 0x10002004,
220  0x10042000, 0x00002000, 0x00000000, 0x10000004,
221  0x00000004, 0x10042004, 0x00042000, 0x10040000,
222  0x10040004, 0x00040000, 0x00002004, 0x10002000,
223  0x10002004, 0x00000004, 0x10040000, 0x00042000,
224  },
225  {
226  /* nibble 2 */
227  0x41000000, 0x01010040, 0x00000040, 0x41000040,
228  0x40010000, 0x01000000, 0x41000040, 0x00010040,
229  0x01000040, 0x00010000, 0x01010000, 0x40000000,
230  0x41010040, 0x40000040, 0x40000000, 0x41010000,
231  0x00000000, 0x40010000, 0x01010040, 0x00000040,
232  0x40000040, 0x41010040, 0x00010000, 0x41000000,
233  0x41010000, 0x01000040, 0x40010040, 0x01010000,
234  0x00010040, 0x00000000, 0x01000000, 0x40010040,
235  0x01010040, 0x00000040, 0x40000000, 0x00010000,
236  0x40000040, 0x40010000, 0x01010000, 0x41000040,
237  0x00000000, 0x01010040, 0x00010040, 0x41010000,
238  0x40010000, 0x01000000, 0x41010040, 0x40000000,
239  0x40010040, 0x41000000, 0x01000000, 0x41010040,
240  0x00010000, 0x01000040, 0x41000040, 0x00010040,
241  0x01000040, 0x00000000, 0x41010000, 0x40000040,
242  0x41000000, 0x40010040, 0x00000040, 0x01010000,
243  },
244  {
245  /* nibble 3 */
246  0x00100402, 0x04000400, 0x00000002, 0x04100402,
247  0x00000000, 0x04100000, 0x04000402, 0x00100002,
248  0x04100400, 0x04000002, 0x04000000, 0x00000402,
249  0x04000002, 0x00100402, 0x00100000, 0x04000000,
250  0x04100002, 0x00100400, 0x00000400, 0x00000002,
251  0x00100400, 0x04000402, 0x04100000, 0x00000400,
252  0x00000402, 0x00000000, 0x00100002, 0x04100400,
253  0x04000400, 0x04100002, 0x04100402, 0x00100000,
254  0x04100002, 0x00000402, 0x00100000, 0x04000002,
255  0x00100400, 0x04000400, 0x00000002, 0x04100000,
256  0x04000402, 0x00000000, 0x00000400, 0x00100002,
257  0x00000000, 0x04100002, 0x04100400, 0x00000400,
258  0x04000000, 0x04100402, 0x00100402, 0x00100000,
259  0x04100402, 0x00000002, 0x04000400, 0x00100402,
260  0x00100002, 0x00100400, 0x04100000, 0x04000402,
261  0x00000402, 0x04000000, 0x04000002, 0x04100400,
262  },
263  {
264  /* nibble 4 */
265  0x02000000, 0x00004000, 0x00000100, 0x02004108,
266  0x02004008, 0x02000100, 0x00004108, 0x02004000,
267  0x00004000, 0x00000008, 0x02000008, 0x00004100,
268  0x02000108, 0x02004008, 0x02004100, 0x00000000,
269  0x00004100, 0x02000000, 0x00004008, 0x00000108,
270  0x02000100, 0x00004108, 0x00000000, 0x02000008,
271  0x00000008, 0x02000108, 0x02004108, 0x00004008,
272  0x02004000, 0x00000100, 0x00000108, 0x02004100,
273  0x02004100, 0x02000108, 0x00004008, 0x02004000,
274  0x00004000, 0x00000008, 0x02000008, 0x02000100,
275  0x02000000, 0x00004100, 0x02004108, 0x00000000,
276  0x00004108, 0x02000000, 0x00000100, 0x00004008,
277  0x02000108, 0x00000100, 0x00000000, 0x02004108,
278  0x02004008, 0x02004100, 0x00000108, 0x00004000,
279  0x00004100, 0x02004008, 0x02000100, 0x00000108,
280  0x00000008, 0x00004108, 0x02004000, 0x02000008,
281  },
282  {
283  /* nibble 5 */
284  0x20000010, 0x00080010, 0x00000000, 0x20080800,
285  0x00080010, 0x00000800, 0x20000810, 0x00080000,
286  0x00000810, 0x20080810, 0x00080800, 0x20000000,
287  0x20000800, 0x20000010, 0x20080000, 0x00080810,
288  0x00080000, 0x20000810, 0x20080010, 0x00000000,
289  0x00000800, 0x00000010, 0x20080800, 0x20080010,
290  0x20080810, 0x20080000, 0x20000000, 0x00000810,
291  0x00000010, 0x00080800, 0x00080810, 0x20000800,
292  0x00000810, 0x20000000, 0x20000800, 0x00080810,
293  0x20080800, 0x00080010, 0x00000000, 0x20000800,
294  0x20000000, 0x00000800, 0x20080010, 0x00080000,
295  0x00080010, 0x20080810, 0x00080800, 0x00000010,
296  0x20080810, 0x00080800, 0x00080000, 0x20000810,
297  0x20000010, 0x20080000, 0x00080810, 0x00000000,
298  0x00000800, 0x20000010, 0x20000810, 0x20080800,
299  0x20080000, 0x00000810, 0x00000010, 0x20080010,
300  },
301  {
302  /* nibble 6 */
303  0x00001000, 0x00000080, 0x00400080, 0x00400001,
304  0x00401081, 0x00001001, 0x00001080, 0x00000000,
305  0x00400000, 0x00400081, 0x00000081, 0x00401000,
306  0x00000001, 0x00401080, 0x00401000, 0x00000081,
307  0x00400081, 0x00001000, 0x00001001, 0x00401081,
308  0x00000000, 0x00400080, 0x00400001, 0x00001080,
309  0x00401001, 0x00001081, 0x00401080, 0x00000001,
310  0x00001081, 0x00401001, 0x00000080, 0x00400000,
311  0x00001081, 0x00401000, 0x00401001, 0x00000081,
312  0x00001000, 0x00000080, 0x00400000, 0x00401001,
313  0x00400081, 0x00001081, 0x00001080, 0x00000000,
314  0x00000080, 0x00400001, 0x00000001, 0x00400080,
315  0x00000000, 0x00400081, 0x00400080, 0x00001080,
316  0x00000081, 0x00001000, 0x00401081, 0x00400000,
317  0x00401080, 0x00000001, 0x00001001, 0x00401081,
318  0x00400001, 0x00401080, 0x00401000, 0x00001001,
319  },
320  {
321  /* nibble 7 */
322  0x08200020, 0x08208000, 0x00008020, 0x00000000,
323  0x08008000, 0x00200020, 0x08200000, 0x08208020,
324  0x00000020, 0x08000000, 0x00208000, 0x00008020,
325  0x00208020, 0x08008020, 0x08000020, 0x08200000,
326  0x00008000, 0x00208020, 0x00200020, 0x08008000,
327  0x08208020, 0x08000020, 0x00000000, 0x00208000,
328  0x08000000, 0x00200000, 0x08008020, 0x08200020,
329  0x00200000, 0x00008000, 0x08208000, 0x00000020,
330  0x00200000, 0x00008000, 0x08000020, 0x08208020,
331  0x00008020, 0x08000000, 0x00000000, 0x00208000,
332  0x08200020, 0x08008020, 0x08008000, 0x00200020,
333  0x08208000, 0x00000020, 0x00200020, 0x08008000,
334  0x08208020, 0x00200000, 0x08200000, 0x08000020,
335  0x00208000, 0x00008020, 0x08008020, 0x08200000,
336  0x00000020, 0x08208000, 0x00208020, 0x00000000,
337  0x08000000, 0x08200020, 0x00008000, 0x00208020
338  }
339  };
340 
341  private static final int byteToUnsigned(byte b) {
342  int value = (int) b;
343  return (value >= 0) ? value : value + 256;
344  }
345 
346  private static int fourBytesToInt(byte b[], int offset) {
347  return byteToUnsigned(b[offset++])
348  | (byteToUnsigned(b[offset++]) << 8)
349  | (byteToUnsigned(b[offset++]) << 16)
350  | (byteToUnsigned(b[offset]) << 24);
351  }
352 
353  private static final void intToFourBytes(int iValue, byte b[], int offset) {
354  b[offset++] = (byte)((iValue) & 0xff);
355  b[offset++] = (byte)((iValue >>> 8 ) & 0xff);
356  b[offset++] = (byte)((iValue >>> 16) & 0xff);
357  b[offset] = (byte)((iValue >>> 24) & 0xff);
358  }
359 
360  private static final void PERM_OP(int a, int b, int n, int m, int results[]) {
361  int t;
362 
363  t = ((a >>> n) ^ b) & m;
364  a ^= t << n;
365  b ^= t;
366 
367  results[0] = a;
368  results[1] = b;
369  }
370 
371  private static final int HPERM_OP(int a, int n, int m) {
372  int t;
373 
374  t = ((a << (16 - n)) ^ a) & m;
375  a = a ^ t ^ (t >>> (16 - n));
376 
377  return a;
378  }
379 
380  private static int [] des_set_key(byte key[]) {
381  int schedule[] = new int [ITERATIONS * 2];
382 
383  int c = fourBytesToInt(key, 0);
384  int d = fourBytesToInt(key, 4);
385 
386  int results[] = new int[2];
387 
388  PERM_OP(d, c, 4, 0x0f0f0f0f, results);
389  d = results[0]; c = results[1];
390 
391  c = HPERM_OP(c, -2, 0xcccc0000);
392  d = HPERM_OP(d, -2, 0xcccc0000);
393 
394  PERM_OP(d, c, 1, 0x55555555, results);
395  d = results[0]; c = results[1];
396 
397  PERM_OP(c, d, 8, 0x00ff00ff, results);
398  c = results[0]; d = results[1];
399 
400  PERM_OP(d, c, 1, 0x55555555, results);
401  d = results[0]; c = results[1];
402 
403  d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) |
404  ((d & 0x00ff0000) >>> 16) | ((c & 0xf0000000) >>> 4));
405  c &= 0x0fffffff;
406 
407  int s, t;
408  int j = 0;
409 
410  for(int i = 0; i < ITERATIONS; i ++) {
411  if(shifts2[i]) {
412  c = (c >>> 2) | (c << 26);
413  d = (d >>> 2) | (d << 26);
414  } else {
415  c = (c >>> 1) | (c << 27);
416  d = (d >>> 1) | (d << 27);
417  }
418 
419  c &= 0x0fffffff;
420  d &= 0x0fffffff;
421 
422  s = skb[0][ (c ) & 0x3f ]|
423  skb[1][((c >>> 6) & 0x03) | ((c >>> 7) & 0x3c)]|
424  skb[2][((c >>> 13) & 0x0f) | ((c >>> 14) & 0x30)]|
425  skb[3][((c >>> 20) & 0x01) | ((c >>> 21) & 0x06) |
426  ((c >>> 22) & 0x38)];
427 
428  t = skb[4][ (d ) & 0x3f ]|
429  skb[5][((d >>> 7) & 0x03) | ((d >>> 8) & 0x3c)]|
430  skb[6][ (d >>>15) & 0x3f ]|
431  skb[7][((d >>>21) & 0x0f) | ((d >>> 22) & 0x30)];
432 
433  schedule[j++] = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff;
434  s = ((s >>> 16) | (t & 0xffff0000));
435 
436  s = (s << 4) | (s >>> 28);
437  schedule[j++] = s & 0xffffffff;
438  }
439  return schedule;
440  }
441 
442  private static final int D_ENUnixCrypt(int L, int R, int S, int E0, int E1, int s[]) {
443  int t, u, v;
444 
445  v = R ^ (R >>> 16);
446  u = v & E0;
447  v = v & E1;
448  u = (u ^ (u << 16)) ^ R ^ s[S];
449  t = (v ^ (v << 16)) ^ R ^ s[S + 1];
450  t = (t >>> 4) | (t << 28);
451 
452  L ^= SPtrans[1][(t ) & 0x3f] |
453  SPtrans[3][(t >>> 8) & 0x3f] |
454  SPtrans[5][(t >>> 16) & 0x3f] |
455  SPtrans[7][(t >>> 24) & 0x3f] |
456  SPtrans[0][(u ) & 0x3f] |
457  SPtrans[2][(u >>> 8) & 0x3f] |
458  SPtrans[4][(u >>> 16) & 0x3f] |
459  SPtrans[6][(u >>> 24) & 0x3f];
460 
461  return L;
462  }
463 
464  private static final int [] body(int schedule[], int Eswap0, int Eswap1)
465  {
466  int left = 0;
467  int right = 0;
468  int t = 0;
469 
470  for (int j = 0; j < 25; j ++) {
471  for (int i = 0; i < ITERATIONS * 2; i += 4) {
472  left = D_ENUnixCrypt(left, right, i, Eswap0, Eswap1, schedule);
473  right = D_ENUnixCrypt(right, left, i + 2, Eswap0, Eswap1, schedule);
474  }
475  t = left;
476  left = right;
477  right = t;
478  }
479 
480  t = right;
481 
482  right = (left >>> 1) | (left << 31);
483  left = (t >>> 1) | (t << 31);
484 
485  left &= 0xffffffff;
486  right &= 0xffffffff;
487 
488  int results[] = new int[2];
489 
490  PERM_OP(right, left, 1, 0x55555555, results);
491  right = results[0]; left = results[1];
492 
493  PERM_OP(left, right, 8, 0x00ff00ff, results);
494  left = results[0]; right = results[1];
495 
496  PERM_OP(right, left, 2, 0x33333333, results);
497  right = results[0]; left = results[1];
498 
499  PERM_OP(left, right, 16, 0x0000ffff, results);
500  left = results[0]; right = results[1];
501 
502  PERM_OP(right, left, 4, 0x0f0f0f0f, results);
503  right = results[0]; left = results[1];
504 
505  int out[] = new int[2];
506 
507  out[0] = left;
508  out[1] = right;
509 
510  return out;
511  }
512 
513  public static final String alphabet = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
514 
515  public static final String encrypt(String salt, String original)
516  {
517  // wwb -- Should do some sanity checks: salt needs to be 2 chars, in alpha.
518  while(salt.length() < 2)
519  salt += "A";
520 
521  char[] buffer = new char [13];
522 
523  char charZero = salt.charAt(0);
524  char charOne = salt.charAt(1);
525 
526  buffer[0] = charZero;
527  buffer[1] = charOne;
528 
529  int Eswap0 = alphabet.indexOf(charZero);
530  int Eswap1 = alphabet.indexOf(charOne) << 4;
531  byte key[] = new byte[8];
532 
533  for(int i = 0; i < key.length; i ++)
534  key[i] = (byte)0;
535 
536  for(int i = 0; i < key.length && i < original.length(); i ++)
537  key[i] = (byte) (((int) original.charAt(i)) << 1);
538 
539  int schedule[] = des_set_key(key);
540  int out[] = body(schedule, Eswap0, Eswap1);
541 
542  byte b[] = new byte[9];
543 
544  intToFourBytes(out[0], b, 0);
545  intToFourBytes(out[1], b, 4);
546  b[8] = 0;
547 
548  for(int i = 2, y = 0, u = 0x80; i < 13; i ++) {
549  for(int j = 0, c = 0; j < 6; j ++) {
550  c <<= 1;
551 
552  if(((int)b[y] & u) != 0)
553  c |= 1;
554 
555  u >>>= 1;
556 
557  if (u == 0) {
558  y++;
559  u = 0x80;
560  }
561  buffer[i] = alphabet.charAt(c);
562  }
563  }
564  return new String(buffer);
565  }
566 
567  public static void main(String [] args)
568  {
569  if ( (1 == args.length) && ("list".equalsIgnoreCase(args[0])) )
570  {
571  StringBuffer listChars = new StringBuffer(alphabet);
572  final String password = "italianroast";
573  int salt = 1;
574  ArrayList<String []> pws = new ArrayList<String []>();
575  while( listChars.length() > 0 )
576  {
577  int startLen = listChars.length();
578  String pw = UnixCrypt.encrypt(Integer.toString(salt), password);
579  for( int i = 0; i < pw.length(); ++i )
580  {
581  int pos = listChars.indexOf(pw.substring(i, i+1));
582  if( pos >= 0 )
583  listChars.deleteCharAt(pos);
584  }
585  if( listChars.length() == startLen )
586  ++salt;
587  else
588  pws.add(new String [] { password, pw });
589  }
590  for( String [] pw : pws )
591  System.out.println(pw[0] + " : " + pw[1]);
592  }
593  else if ( 2 == args.length )
594  {
595  System.out.println(UnixCrypt.encrypt(args[0], args[1]));
596  }
597  else
598  {
599  System.out.println("usage: UnixCrypt <salt> <password>");
600  System.out.println("or: \"UnixCrypt list\" to generate a list of password with all possible characters.");
601  }
602  }
603 
604 }
org.feistymeow.encryption.UnixCrypt.encrypt
static final String encrypt(String salt, String original)
Definition: UnixCrypt.java:515
org.feistymeow.encryption.UnixCrypt.main
static void main(String[] args)
Definition: UnixCrypt.java:567
ITERATIONS
const int ITERATIONS
Definition: test_blowfish_crypto.cpp:53