Crypt


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