KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > knowgate > jcifs > util > DES


1 // DesCipher - the DES encryption method
2 //
3 // The meat of this code is by Dave Zimmerman <dzimm@widget.com>, and is:
4 //
5 // Copyright (c) 1996 Widget Workshop, Inc. All Rights Reserved.
6 //
7 // Permission to use, copy, modify, and distribute this software
8 // and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
9 // without fee is hereby granted, provided that this copyright notice is kept
10 // intact.
11 //
12 // WIDGET WORKSHOP MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY
13 // OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
14 // TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
15 // PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WIDGET WORKSHOP SHALL NOT BE LIABLE
16 // FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
17 // DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
18 //
19 // THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
20 // CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
21 // PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
22 // NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
23 // SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
24 // SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
25 // PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES"). WIDGET WORKSHOP
26 // SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
27 // HIGH RISK ACTIVITIES.
28 //
29 //
30 // The rest is:
31 //
32 // Copyright (C) 1996 by Jef Poskanzer <jef@acme.com>. All rights reserved.
33 //
34 // Copyright (C) 1996 by Wolfgang Platzer
35 // email: wplatzer@iaik.tu-graz.ac.at
36 //
37 // All rights reserved.
38 //
39 // Redistribution and use in source and binary forms, with or without
40 // modification, are permitted provided that the following conditions
41 // are met:
42 // 1. Redistributions of source code must retain the above copyright
43 // notice, this list of conditions and the following disclaimer.
44 // 2. Redistributions in binary form must reproduce the above copyright
45 // notice, this list of conditions and the following disclaimer in the
46 // documentation and/or other materials provided with the distribution.
47 //
48 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
49 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 // ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
52 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 // SUCH DAMAGE.
59 //
60
61 package com.knowgate.jcifs.util;
62
63
64 /**
65  * This code is derived from the above source
66  * JCIFS API
67  * Norbert Hranitzky
68  *
69  * <p>and modified again by Michael B. Allen
70  */
71
72 public class DES {
73
74
75     private int[] encryptKeys = new int[32];
76     private int[] decryptKeys = new int[32];
77
78     private int[] tempInts = new int[2];
79
80
81     public DES( ) {
82
83     }
84
85     // Constructor, byte-array key.
86 public DES( byte[] key ) {
87         if( key.length == 7 ) {
88             byte[] key8 = new byte[8];
89             makeSMBKey( key, key8 );
90             setKey( key8 );
91         } else {
92             setKey( key );
93         }
94     }
95
96
97     public static void makeSMBKey(byte[] key7, byte[] key8) {
98
99         int i;
100
101         key8[0] = (byte) ( ( key7[0] >> 1) & 0xff);
102         key8[1] = (byte)(( ((key7[0] & 0x01) << 6) | (((key7[1] & 0xff)>>2) & 0xff)) & 0xff );
103         key8[2] = (byte)(( ((key7[1] & 0x03) << 5) | (((key7[2] & 0xff)>>3) & 0xff)) & 0xff );
104         key8[3] = (byte)(( ((key7[2] & 0x07) << 4) | (((key7[3] & 0xff)>>4) & 0xff)) & 0xff );
105         key8[4] = (byte)(( ((key7[3] & 0x0F) << 3) | (((key7[4] & 0xff)>>5) & 0xff)) & 0xff );
106         key8[5] = (byte)(( ((key7[4] & 0x1F) << 2) | (((key7[5] & 0xff)>>6) & 0xff)) & 0xff );
107         key8[6] = (byte)(( ((key7[5] & 0x3F) << 1) | (((key7[6] & 0xff)>>7) & 0xff)) & 0xff );
108         key8[7] = (byte)(key7[6] & 0x7F);
109         for (i=0;i<8;i++) {
110             key8[i] = (byte)( key8[i] << 1);
111         }
112     }
113
114     /// Set the key.
115 public void setKey( byte[] key ) {
116
117         // CHECK PAROTY TBD
118 deskey( key, true, encryptKeys );
119         deskey( key, false, decryptKeys );
120     }
121
122     // Turn an 8-byte key into internal keys.
123 private void deskey( byte[] keyBlock, boolean encrypting, int[] KnL ) {
124
125         int i, j, l, m, n;
126         int[] pc1m = new int[56];
127         int[] pcr = new int[56];
128         int[] kn = new int[32];
129
130         for ( j = 0; j < 56; ++j ) {
131             l = pc1[j];
132             m = l & 07;
133             pc1m[j] = ( (keyBlock[l >>> 3] & bytebit[m]) != 0 )? 1: 0;
134         }
135
136         for ( i = 0; i < 16; ++i ) {
137
138             if ( encrypting )
139                 m = i << 1;
140             else
141                 m = (15-i) << 1;
142             n = m+1;
143             kn[m] = kn[n] = 0;
144             for ( j = 0; j < 28; ++j ) {
145                 l = j+totrot[i];
146                 if ( l < 28 )
147                     pcr[j] = pc1m[l];
148                 else
149                     pcr[j] = pc1m[l-28];
150             }
151             for ( j=28; j < 56; ++j ) {
152                 l = j+totrot[i];
153                 if ( l < 56 )
154                     pcr[j] = pc1m[l];
155                 else
156                     pcr[j] = pc1m[l-28];
157             }
158             for ( j = 0; j < 24; ++j ) {
159                 if ( pcr[pc2[j]] != 0 )
160                     kn[m] |= bigbyte[j];
161                 if ( pcr[pc2[j+24]] != 0 )
162                     kn[n] |= bigbyte[j];
163             }
164         }
165         cookey( kn, KnL );
166     }
167
168     private void cookey( int[] raw, int KnL[] ) {
169         int raw0, raw1;
170         int rawi, KnLi;
171         int i;
172
173         for ( i = 0, rawi = 0, KnLi = 0; i < 16; ++i ) {
174             raw0 = raw[rawi++];
175             raw1 = raw[rawi++];
176             KnL[KnLi] = (raw0 & 0x00fc0000) << 6;
177             KnL[KnLi] |= (raw0 & 0x00000fc0) << 10;
178             KnL[KnLi] |= (raw1 & 0x00fc0000) >>> 10;
179             KnL[KnLi] |= (raw1 & 0x00000fc0) >>> 6;
180             ++KnLi;
181             KnL[KnLi] = (raw0 & 0x0003f000) << 12;
182             KnL[KnLi] |= (raw0 & 0x0000003f) << 16;
183             KnL[KnLi] |= (raw1 & 0x0003f000) >>> 4;
184             KnL[KnLi] |= (raw1 & 0x0000003f);
185             ++KnLi;
186         }
187     }
188
189
190     /// Encrypt a block of eight bytes.
191 private void encrypt( byte[] clearText, int clearOff, byte[] cipherText, int cipherOff ) {
192
193         squashBytesToInts( clearText, clearOff, tempInts, 0, 2 );
194         des( tempInts, tempInts, encryptKeys );
195         spreadIntsToBytes( tempInts, 0, cipherText, cipherOff, 2 );
196     }
197
198     /// Decrypt a block of eight bytes.
199 private void decrypt( byte[] cipherText, int cipherOff, byte[] clearText, int clearOff ) {
200
201         squashBytesToInts( cipherText, cipherOff, tempInts, 0, 2 );
202         des( tempInts, tempInts, decryptKeys );
203         spreadIntsToBytes( tempInts, 0, clearText, clearOff, 2 );
204     }
205
206     // The DES function.
207 private void des( int[] inInts, int[] outInts, int[] keys ) {
208
209         int fval, work, right, leftt;
210         int round;
211         int keysi = 0;
212
213         leftt = inInts[0];
214         right = inInts[1];
215
216         work = ((leftt >>> 4) ^ right) & 0x0f0f0f0f;
217         right ^= work;
218         leftt ^= (work << 4);
219
220         work = ((leftt >>> 16) ^ right) & 0x0000ffff;
221         right ^= work;
222         leftt ^= (work << 16);
223
224         work = ((right >>> 2) ^ leftt) & 0x33333333;
225         leftt ^= work;
226         right ^= (work << 2);
227
228         work = ((right >>> 8) ^ leftt) & 0x00ff00ff;
229         leftt ^= work;
230         right ^= (work << 8);
231         right = (right << 1) | ((right >>> 31) & 1);
232
233         work = (leftt ^ right) & 0xaaaaaaaa;
234         leftt ^= work;
235         right ^= work;
236         leftt = (leftt << 1) | ((leftt >>> 31) & 1);
237
238         for ( round = 0; round < 8; ++round ) {
239             work = (right << 28) | (right >>> 4);
240             work ^= keys[keysi++];
241             fval = SP7[ work & 0x0000003f ];
242             fval |= SP5[(work >>> 8) & 0x0000003f ];
243             fval |= SP3[(work >>> 16) & 0x0000003f ];
244             fval |= SP1[(work >>> 24) & 0x0000003f ];
245             work = right ^ keys[keysi++];
246             fval |= SP8[ work & 0x0000003f ];
247             fval |= SP6[(work >>> 8) & 0x0000003f ];
248             fval |= SP4[(work >>> 16) & 0x0000003f ];
249             fval |= SP2[(work >>> 24) & 0x0000003f ];
250             leftt ^= fval;
251             work = (leftt << 28) | (leftt >>> 4);
252             work ^= keys[keysi++];
253             fval = SP7[ work & 0x0000003f ];
254             fval |= SP5[(work >>> 8) & 0x0000003f ];
255             fval |= SP3[(work >>> 16) & 0x0000003f ];
256             fval |= SP1[(work >>> 24) & 0x0000003f ];
257             work = leftt ^ keys[keysi++];
258             fval |= SP8[ work & 0x0000003f ];
259             fval |= SP6[(work >>> 8) & 0x0000003f ];
260             fval |= SP4[(work >>> 16) & 0x0000003f ];
261             fval |= SP2[(work >>> 24) & 0x0000003f ];
262             right ^= fval;
263         }
264
265         right = (right << 31) | (right >>> 1);
266         work = (leftt ^ right) & 0xaaaaaaaa;
267         leftt ^= work;
268         right ^= work;
269         leftt = (leftt << 31) | (leftt >>> 1);
270         work = ((leftt >>> 8) ^ right) & 0x00ff00ff;
271         right ^= work;
272         leftt ^= (work << 8);
273         work = ((leftt >>> 2) ^ right) & 0x33333333;
274         right ^= work;
275         leftt ^= (work << 2);
276         work = ((right >>> 16) ^ leftt) & 0x0000ffff;
277         leftt ^= work;
278         right ^= (work << 16);
279         work = ((right >>> 4) ^ leftt) & 0x0f0f0f0f;
280         leftt ^= work;
281         right ^= (work << 4);
282         outInts[0] = right;
283         outInts[1] = leftt;
284     }
285
286
287     /// Encrypt a block of bytes.
288 public void encrypt( byte[] clearText, byte[] cipherText ) {
289         encrypt( clearText, 0, cipherText, 0 );
290     }
291
292     /// Decrypt a block of bytes.
293 public void decrypt( byte[] cipherText, byte[] clearText ) {
294
295         decrypt( cipherText, 0, clearText, 0 );
296     }
297
298     /**
299      * encrypts an array where the length must be a multiple of 8
300      */
301     public byte[] encrypt(byte[] clearText) {
302
303         int length = clearText.length;
304
305         if (length % 8 != 0) {
306             System.out.println("Array must be a multiple of 8");
307             return null;
308         }
309
310         byte[] cipherText = new byte[length];
311         int count = length / 8;
312
313         for (int i=0; i<count; i++)
314             encrypt(clearText, i*8, cipherText, i*8);
315
316         return cipherText;
317     }
318
319     /**
320      * decrypts an array where the length must be a multiple of 8
321      */
322     public byte[] decrypt(byte[] cipherText) {
323
324         int length = cipherText.length;
325
326         if (length % 8 != 0) {
327             System.out.println("Array must be a multiple of 8");
328             return null;
329         }
330
331         byte[] clearText = new byte[length];
332         int count = length / 8;
333
334         for (int i=0; i<count; i++)
335             encrypt(cipherText, i*8, clearText, i*8);
336
337         return clearText;
338     }
339
340
341     // Tables, permutations, S-boxes, etc.
342
343     private static byte[] bytebit = {
344         (byte)0x80, (byte)0x40, (byte)0x20, (byte)0x10,
345         (byte)0x08, (byte)0x04, (byte)0x02, (byte)0x01
346     };
347     private static int[] bigbyte = {
348         0x800000, 0x400000, 0x200000, 0x100000,
349         0x080000, 0x040000, 0x020000, 0x010000,
350         0x008000, 0x004000, 0x002000, 0x001000,
351         0x000800, 0x000400, 0x000200, 0x000100,
352         0x000080, 0x000040, 0x000020, 0x000010,
353         0x000008, 0x000004, 0x000002, 0x000001
354     };
355     private static byte[] pc1 = {
356         (byte)56, (byte)48, (byte)40, (byte)32, (byte)24, (byte)16, (byte) 8,
357         (byte) 0, (byte)57, (byte)49, (byte)41, (byte)33, (byte)25, (byte)17,
358         (byte) 9, (byte) 1, (byte)58, (byte)50, (byte)42, (byte)34, (byte)26,
359         (byte)18, (byte)10, (byte) 2, (byte)59, (byte)51, (byte)43, (byte)35,
360         (byte)62, (byte)54, (byte)46, (byte)38, (byte)30, (byte)22, (byte)14,
361         (byte) 6, (byte)61, (byte)53, (byte)45, (byte)37, (byte)29, (byte)21,
362         (byte)13, (byte) 5, (byte)60, (byte)52, (byte)44, (byte)36, (byte)28,
363         (byte)20, (byte)12, (byte) 4, (byte)27, (byte)19, (byte)11, (byte)3
364     };
365     private static int[] totrot = {
366         1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28
367     };
368
369     private static byte[] pc2 = {
370         (byte)13, (byte)16, (byte)10, (byte)23, (byte) 0, (byte) 4,
371         (byte) 2, (byte)27, (byte)14, (byte) 5, (byte)20, (byte) 9,
372         (byte)22, (byte)18, (byte)11, (byte)3 , (byte)25, (byte) 7,
373         (byte)15, (byte) 6, (byte)26, (byte)19, (byte)12, (byte) 1,
374         (byte)40, (byte)51, (byte)30, (byte)36, (byte)46, (byte)54,
375         (byte)29, (byte)39, (byte)50, (byte)44, (byte)32, (byte)47,
376         (byte)43, (byte)48, (byte)38, (byte)55, (byte)33, (byte)52,
377         (byte)45, (byte)41, (byte)49, (byte)35, (byte)28, (byte)31,
378     };
379
380     private static int[] SP1 = {
381         0x01010400, 0x00000000, 0x00010000, 0x01010404,
382         0x01010004, 0x00010404, 0x00000004, 0x00010000,
383         0x00000400, 0x01010400, 0x01010404, 0x00000400,
384         0x01000404, 0x01010004, 0x01000000, 0x00000004,
385         0x00000404, 0x01000400, 0x01000400, 0x00010400,
386         0x00010400, 0x01010000, 0x01010000, 0x01000404,
387         0x00010004, 0x01000004, 0x01000004, 0x00010004,
388         0x00000000, 0x00000404, 0x00010404, 0x01000000,
389         0x00010000, 0x01010404, 0x00000004, 0x01010000,
390         0x01010400, 0x01000000, 0x01000000, 0x00000400,
391         0x01010004, 0x00010000, 0x00010400, 0x01000004,
392         0x00000400, 0x00000004, 0x01000404, 0x00010404,
393         0x01010404, 0x00010004, 0x01010000, 0x01000404,
394         0x01000004, 0x00000404, 0x00010404, 0x01010400,
395         0x00000404, 0x01000400, 0x01000400, 0x00000000,
396         0x00010004, 0x00010400, 0x00000000, 0x01010004
397     };
398     private static int[] SP2 = {
399         0x80108020, 0x80008000, 0x00008000, 0x00108020,
400         0x00100000, 0x00000020, 0x80100020, 0x80008020,
401         0x80000020, 0x80108020, 0x80108000, 0x80000000,
402         0x80008000, 0x00100000, 0x00000020, 0x80100020,
403         0x00108000, 0x00100020, 0x80008020, 0x00000000,
404         0x80000000, 0x00008000, 0x00108020, 0x80100000,
405         0x00100020, 0x80000020, 0x00000000, 0x00108000,
406         0x00008020, 0x80108000, 0x80100000, 0x00008020,
407         0x00000000, 0x00108020, 0x80100020, 0x00100000,
408         0x80008020, 0x80100000, 0x80108000, 0x00008000,
409         0x80100000, 0x80008000, 0x00000020, 0x80108020,
410         0x00108020, 0x00000020, 0x00008000, 0x80000000,
411         0x00008020, 0x80108000, 0x00100000, 0x80000020,
412         0x00100020, 0x80008020, 0x80000020, 0x00100020,
413         0x00108000, 0x00000000, 0x80008000, 0x00008020,
414         0x80000000, 0x80100020, 0x80108020, 0x00108000
415     };
416     private static int[] SP3 = {
417         0x00000208, 0x08020200, 0x00000000, 0x08020008,
418         0x08000200, 0x00000000, 0x00020208, 0x08000200,
419         0x00020008, 0x08000008, 0x08000008, 0x00020000,
420         0x08020208, 0x00020008, 0x08020000, 0x00000208,
421         0x08000000, 0x00000008, 0x08020200, 0x00000200,
422         0x00020200, 0x08020000, 0x08020008, 0x00020208,
423         0x08000208, 0x00020200, 0x00020000, 0x08000208,
424         0x00000008, 0x08020208, 0x00000200, 0x08000000,
425         0x08020200, 0x08000000, 0x00020008, 0x00000208,
426         0x00020000, 0x08020200, 0x08000200, 0x00000000,
427         0x00000200, 0x00020008, 0x08020208, 0x08000200,
428         0x08000008, 0x00000200, 0x00000000, 0x08020008,
429         0x08000208, 0x00020000, 0x08000000, 0x08020208,
430         0x00000008, 0x00020208, 0x00020200, 0x08000008,
431         0x08020000, 0x08000208, 0x00000208, 0x08020000,
432         0x00020208, 0x00000008, 0x08020008, 0x00020200
433     };
434     private static int[] SP4 = {
435         0x00802001, 0x00002081, 0x00002081, 0x00000080,
436         0x00802080, 0x00800081, 0x00800001, 0x00002001,
437         0x00000000, 0x00802000, 0x00802000, 0x00802081,
438         0x00000081, 0x00000000, 0x00800080, 0x00800001,
439         0x00000001, 0x00002000, 0x00800000, 0x00802001,
440         0x00000080, 0x00800000, 0x00002001, 0x00002080,
441         0x00800081, 0x00000001, 0x00002080, 0x00800080,
442         0x00002000, 0x00802080, 0x00802081, 0x00000081,
443         0x00800080, 0x00800001, 0x00802000, 0x00802081,
444         0x00000081, 0x00000000, 0x00000000, 0x00802000,
445         0x00002080, 0x00800080, 0x00800081, 0x00000001,
446         0x00802001, 0x00002081, 0x00002081, 0x00000080,
447         0x00802081, 0x00000081, 0x00000001, 0x00002000,
448         0x00800001, 0x00002001, 0x00802080, 0x00800081,
449         0x00002001, 0x00002080, 0x00800000, 0x00802001,
450         0x00000080, 0x00800000, 0x00002000, 0x00802080
451     };
452     private static int[] SP5 = {
453         0x00000100, 0x02080100, 0x02080000, 0x42000100,
454         0x00080000, 0x00000100, 0x40000000, 0x02080000,
455         0x40080100, 0x00080000, 0x02000100, 0x40080100,
456         0x42000100, 0x42080000, 0x00080100, 0x40000000,
457         0x02000000, 0x40080000, 0x40080000, 0x00000000,
458         0x40000100, 0x42080100, 0x42080100, 0x02000100,
459         0x42080000, 0x40000100, 0x00000000, 0x42000000,
460         0x02080100, 0x02000000, 0x42000000, 0x00080100,
461         0x00080000, 0x42000100, 0x00000100, 0x02000000,
462         0x40000000, 0x02080000, 0x42000100, 0x40080100,
463         0x02000100, 0x40000000, 0x42080000, 0x02080100,
464         0x40080100, 0x00000100, 0x02000000, 0x42080000,
465         0x42080100, 0x00080100, 0x42000000, 0x42080100,
466         0x02080000, 0x00000000, 0x40080000, 0x42000000,
467         0x00080100, 0x02000100, 0x40000100, 0x00080000,
468         0x00000000, 0x40080000, 0x02080100, 0x40000100
469     };
470     private static int[] SP6 = {
471         0x20000010, 0x20400000, 0x00004000, 0x20404010,
472         0x20400000, 0x00000010, 0x20404010, 0x00400000,
473         0x20004000, 0x00404010, 0x00400000, 0x20000010,
474         0x00400010, 0x20004000, 0x20000000, 0x00004010,
475         0x00000000, 0x00400010, 0x20004010, 0x00004000,
476         0x00404000, 0x20004010, 0x00000010, 0x20400010,
477         0x20400010, 0x00000000, 0x00404010, 0x20404000,
478         0x00004010, 0x00404000, 0x20404000, 0x20000000,
479         0x20004000, 0x00000010, 0x20400010, 0x00404000,
480         0x20404010, 0x00400000, 0x00004010, 0x20000010,
481         0x00400000, 0x20004000, 0x20000000, 0x00004010,
482         0x20000010, 0x20404010, 0x00404000, 0x20400000,
483         0x00404010, 0x20404000, 0x00000000, 0x20400010,
484         0x00000010, 0x00004000, 0x20400000, 0x00404010,
485         0x00004000, 0x00400010, 0x20004010, 0x00000000,
486         0x20404000, 0x20000000, 0x00400010, 0x20004010
487     };
488     private static int[] SP7 = {
489         0x00200000, 0x04200002, 0x04000802, 0x00000000,
490         0x00000800, 0x04000802, 0x00200802, 0x04200800,
491         0x04200802, 0x00200000, 0x00000000, 0x04000002,
492         0x00000002, 0x04000000, 0x04200002, 0x00000802,
493         0x04000800, 0x00200802, 0x00200002, 0x04000800,
494         0x04000002, 0x04200000, 0x04200800, 0x00200002,
495         0x04200000, 0x00000800, 0x00000802, 0x04200802,
496         0x00200800, 0x00000002, 0x04000000, 0x00200800,
497         0x04000000, 0x00200800, 0x00200000, 0x04000802,
498         0x04000802, 0x04200002, 0x04200002, 0x00000002,
499         0x00200002, 0x04000000, 0x04000800, 0x00200000,
500         0x04200800, 0x00000802, 0x00200802, 0x04200800,
501         0x00000802, 0x04000002, 0x04200802, 0x04200000,
502         0x00200800, 0x00000000, 0x00000002, 0x04200802,
503         0x00000000, 0x00200802, 0x04200000, 0x00000800,
504         0x04000002, 0x04000800, 0x00000800, 0x00200002
505     };
506     private static int[] SP8 = {
507         0x10001040, 0x00001000, 0x00040000, 0x10041040,
508         0x10000000, 0x10001040, 0x00000040, 0x10000000,
509         0x00040040, 0x10040000, 0x10041040, 0x00041000,
510         0x10041000, 0x00041040, 0x00001000, 0x00000040,
511         0x10040000, 0x10000040, 0x10001000, 0x00001040,
512         0x00041000, 0x00040040, 0x10040040, 0x10041000,
513         0x00001040, 0x00000000, 0x00000000, 0x10040040,
514         0x10000040, 0x10001000, 0x00041040, 0x00040000,
515         0x00041040, 0x00040000, 0x10041000, 0x00001000,
516         0x00000040, 0x10040040, 0x00001000, 0x00041040,
517         0x10001000, 0x00000040, 0x10000040, 0x10040000,
518         0x10040040, 0x10000000, 0x00040000, 0x10001040,
519         0x00000000, 0x10041040, 0x00040040, 0x10000040,
520         0x10040000, 0x10001000, 0x10001040, 0x00000000,
521         0x10041040, 0x00041000, 0x00041000, 0x00001040,
522         0x00001040, 0x00040040, 0x10000000, 0x10041000
523     };
524
525
526  /// Squash bytes down to ints.
527 public static void squashBytesToInts( byte[] inBytes, int inOff, int[] outInts,
528                                            int outOff, int intLen ) {
529
530         for ( int i = 0; i < intLen; ++i )
531             outInts[outOff + i] =
532                 ( ( inBytes[inOff + i * 4 ] & 0xff ) << 24 ) |
533                 ( ( inBytes[inOff + i * 4 + 1] & 0xff ) << 16 ) |
534                 ( ( inBytes[inOff + i * 4 + 2] & 0xff ) << 8 ) |
535                  ( inBytes[inOff + i * 4 + 3] & 0xff );
536     }
537
538     /// Spread ints into bytes.
539 public static void spreadIntsToBytes( int[] inInts, int inOff, byte[] outBytes,
540                                          int outOff, int intLen ) {
541
542         for ( int i = 0; i < intLen; ++i ) {
543
544             outBytes[outOff + i * 4 ] = (byte) ( inInts[inOff + i] >>> 24 );
545             outBytes[outOff + i * 4 + 1] = (byte) ( inInts[inOff + i] >>> 16 );
546             outBytes[outOff + i * 4 + 2] = (byte) ( inInts[inOff + i] >>> 8 );
547             outBytes[outOff + i * 4 + 3] = (byte) inInts[inOff + i];
548         }
549     }
550 }
551
Popular Tags