source: other-projects/trunk/gs3-release-maker/tasks/sshtaskdef/src/mindbright/vnc/DesCipher.java@ 14627

Last change on this file since 14627 was 14627, checked in by oranfry, 17 years ago

initial import of the gs3-release-maker
File size: 18.1 KB
Line 
1//
2// This DES class has been extracted from package Acme.Crypto for use in VNC.
3// The bytebit[] array has been reversed so that the most significant bit
4// in each byte of the key is ignored, not the least significant. Also the
5// unnecessary odd parity code has been removed.
6//
7// These changes are Copyright (C) 1998 Olivetti & Oracle Research Laboratory
8//
9// This software 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.
12//
13
14// DesCipher - the DES encryption method
15//
16// The meat of this code is by Dave Zimmerman <[email protected]>, and is:
17//
18// Copyright (c) 1996 Widget Workshop, Inc. All Rights Reserved.
19//
20// Permission to use, copy, modify, and distribute this software
21// and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
22// without fee is hereby granted, provided that this copyright notice is kept
23// intact.
24//
25// WIDGET WORKSHOP MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY
26// OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
27// TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
28// PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WIDGET WORKSHOP SHALL NOT BE LIABLE
29// FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
30// DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
31//
32// THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
33// CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
34// PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
35// NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
36// SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
37// SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
38// PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES"). WIDGET WORKSHOP
39// SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
40// HIGH RISK ACTIVITIES.
41//
42//
43// The rest is:
44//
45// Copyright (C) 1996 by Jef Poskanzer <[email protected]>. All rights reserved.
46//
47// Redistribution and use in source and binary forms, with or without
48// modification, are permitted provided that the following conditions
49// are met:
50// 1. Redistributions of source code must retain the above copyright
51// notice, this list of conditions and the following disclaimer.
52// 2. Redistributions in binary form must reproduce the above copyright
53// notice, this list of conditions and the following disclaimer in the
54// documentation and/or other materials provided with the distribution.
55//
56// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
57// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
58// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
59// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
60// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
61// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
62// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
64// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
65// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
66// SUCH DAMAGE.
67//
68// Visit the ACME Labs Java page for up-to-date versions of this and other
69// fine Java utilities: http://www.acme.com/java/
70
71package mindbright.vnc;
72
73import java.io.*;
74
75/// The DES encryption method.
76// <P>
77// This is surprisingly fast, for pure Java. On a SPARC 20, wrapped
78// in Acme.Crypto.EncryptedOutputStream or Acme.Crypto.EncryptedInputStream,
79// it does around 7000 bytes/second.
80// <P>
81// Most of this code is by Dave Zimmerman <[email protected]>, and is
82// Copyright (c) 1996 Widget Workshop, Inc. See the source file for details.
83// <P>
84// <A HREF="/resources/classes/Acme/Crypto/DesCipher.java">Fetch the software.</A><BR>
85// <A HREF="/resources/classes/Acme.tar.Z">Fetch the entire Acme package.</A>
86// <P>
87// @see Des3Cipher
88// @see EncryptedOutputStream
89// @see EncryptedInputStream
90
91public class DesCipher
92 {
93
94 // Constructor, byte-array key.
95 public DesCipher( byte[] key )
96 {
97 setKey( key );
98 }
99
100 // Key routines.
101
102 private int[] encryptKeys = new int[32];
103 private int[] decryptKeys = new int[32];
104
105 /// Set the key.
106 public void setKey( byte[] key )
107 {
108 deskey( key, true, encryptKeys );
109 deskey( key, false, decryptKeys );
110 }
111
112 // Turn an 8-byte key into internal keys.
113 private void deskey( byte[] keyBlock, boolean encrypting, int[] KnL )
114 {
115 int i, j, l, m, n;
116 int[] pc1m = new int[56];
117 int[] pcr = new int[56];
118 int[] kn = new int[32];
119
120 for ( j = 0; j < 56; ++j )
121 {
122 l = pc1[j];
123 m = l & 07;
124 pc1m[j] = ( (keyBlock[l >>> 3] & bytebit[m]) != 0 )? 1: 0;
125 }
126
127 for ( i = 0; i < 16; ++i )
128 {
129 if ( encrypting )
130 m = i << 1;
131 else
132 m = (15-i) << 1;
133 n = m+1;
134 kn[m] = kn[n] = 0;
135 for ( j = 0; j < 28; ++j )
136 {
137 l = j+totrot[i];
138 if ( l < 28 )
139 pcr[j] = pc1m[l];
140 else
141 pcr[j] = pc1m[l-28];
142 }
143 for ( j=28; j < 56; ++j )
144 {
145 l = j+totrot[i];
146 if ( l < 56 )
147 pcr[j] = pc1m[l];
148 else
149 pcr[j] = pc1m[l-28];
150 }
151 for ( j = 0; j < 24; ++j )
152 {
153 if ( pcr[pc2[j]] != 0 )
154 kn[m] |= bigbyte[j];
155 if ( pcr[pc2[j+24]] != 0 )
156 kn[n] |= bigbyte[j];
157 }
158 }
159 cookey( kn, KnL );
160 }
161
162 private void cookey( int[] raw, int KnL[] )
163 {
164 int raw0, raw1;
165 int rawi, KnLi;
166 int i;
167
168 for ( i = 0, rawi = 0, KnLi = 0; i < 16; ++i )
169 {
170 raw0 = raw[rawi++];
171 raw1 = raw[rawi++];
172 KnL[KnLi] = (raw0 & 0x00fc0000) << 6;
173 KnL[KnLi] |= (raw0 & 0x00000fc0) << 10;
174 KnL[KnLi] |= (raw1 & 0x00fc0000) >>> 10;
175 KnL[KnLi] |= (raw1 & 0x00000fc0) >>> 6;
176 ++KnLi;
177 KnL[KnLi] = (raw0 & 0x0003f000) << 12;
178 KnL[KnLi] |= (raw0 & 0x0000003f) << 16;
179 KnL[KnLi] |= (raw1 & 0x0003f000) >>> 4;
180 KnL[KnLi] |= (raw1 & 0x0000003f);
181 ++KnLi;
182 }
183 }
184
185
186 // Block encryption routines.
187
188 private int[] tempInts = new int[2];
189
190 /// Encrypt a block of eight bytes.
191 public 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 public 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 {
240 work = (right << 28) | (right >>> 4);
241 work ^= keys[keysi++];
242 fval = SP7[ work & 0x0000003f ];
243 fval |= SP5[(work >>> 8) & 0x0000003f ];
244 fval |= SP3[(work >>> 16) & 0x0000003f ];
245 fval |= SP1[(work >>> 24) & 0x0000003f ];
246 work = right ^ keys[keysi++];
247 fval |= SP8[ work & 0x0000003f ];
248 fval |= SP6[(work >>> 8) & 0x0000003f ];
249 fval |= SP4[(work >>> 16) & 0x0000003f ];
250 fval |= SP2[(work >>> 24) & 0x0000003f ];
251 leftt ^= fval;
252 work = (leftt << 28) | (leftt >>> 4);
253 work ^= keys[keysi++];
254 fval = SP7[ work & 0x0000003f ];
255 fval |= SP5[(work >>> 8) & 0x0000003f ];
256 fval |= SP3[(work >>> 16) & 0x0000003f ];
257 fval |= SP1[(work >>> 24) & 0x0000003f ];
258 work = leftt ^ keys[keysi++];
259 fval |= SP8[ work & 0x0000003f ];
260 fval |= SP6[(work >>> 8) & 0x0000003f ];
261 fval |= SP4[(work >>> 16) & 0x0000003f ];
262 fval |= SP2[(work >>> 24) & 0x0000003f ];
263 right ^= fval;
264 }
265
266 right = (right << 31) | (right >>> 1);
267 work = (leftt ^ right) & 0xaaaaaaaa;
268 leftt ^= work;
269 right ^= work;
270 leftt = (leftt << 31) | (leftt >>> 1);
271 work = ((leftt >>> 8) ^ right) & 0x00ff00ff;
272 right ^= work;
273 leftt ^= (work << 8);
274 work = ((leftt >>> 2) ^ right) & 0x33333333;
275 right ^= work;
276 leftt ^= (work << 2);
277 work = ((right >>> 16) ^ leftt) & 0x0000ffff;
278 leftt ^= work;
279 right ^= (work << 16);
280 work = ((right >>> 4) ^ leftt) & 0x0f0f0f0f;
281 leftt ^= work;
282 right ^= (work << 4);
283 outInts[0] = right;
284 outInts[1] = leftt;
285 }
286
287
288 // Tables, permutations, S-boxes, etc.
289
290 private static byte[] bytebit = {
291 (byte)0x01, (byte)0x02, (byte)0x04, (byte)0x08,
292 (byte)0x10, (byte)0x20, (byte)0x40, (byte)0x80
293 };
294 private static int[] bigbyte = {
295 0x800000, 0x400000, 0x200000, 0x100000,
296 0x080000, 0x040000, 0x020000, 0x010000,
297 0x008000, 0x004000, 0x002000, 0x001000,
298 0x000800, 0x000400, 0x000200, 0x000100,
299 0x000080, 0x000040, 0x000020, 0x000010,
300 0x000008, 0x000004, 0x000002, 0x000001
301 };
302 private static byte[] pc1 = {
303 (byte)56, (byte)48, (byte)40, (byte)32, (byte)24, (byte)16, (byte) 8,
304 (byte) 0, (byte)57, (byte)49, (byte)41, (byte)33, (byte)25, (byte)17,
305 (byte) 9, (byte) 1, (byte)58, (byte)50, (byte)42, (byte)34, (byte)26,
306 (byte)18, (byte)10, (byte) 2, (byte)59, (byte)51, (byte)43, (byte)35,
307 (byte)62, (byte)54, (byte)46, (byte)38, (byte)30, (byte)22, (byte)14,
308 (byte) 6, (byte)61, (byte)53, (byte)45, (byte)37, (byte)29, (byte)21,
309 (byte)13, (byte) 5, (byte)60, (byte)52, (byte)44, (byte)36, (byte)28,
310 (byte)20, (byte)12, (byte) 4, (byte)27, (byte)19, (byte)11, (byte)3
311 };
312 private static int[] totrot = {
313 1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28
314 };
315
316 private static byte[] pc2 = {
317 (byte)13, (byte)16, (byte)10, (byte)23, (byte) 0, (byte) 4,
318 (byte) 2, (byte)27, (byte)14, (byte) 5, (byte)20, (byte) 9,
319 (byte)22, (byte)18, (byte)11, (byte)3 , (byte)25, (byte) 7,
320 (byte)15, (byte) 6, (byte)26, (byte)19, (byte)12, (byte) 1,
321 (byte)40, (byte)51, (byte)30, (byte)36, (byte)46, (byte)54,
322 (byte)29, (byte)39, (byte)50, (byte)44, (byte)32, (byte)47,
323 (byte)43, (byte)48, (byte)38, (byte)55, (byte)33, (byte)52,
324 (byte)45, (byte)41, (byte)49, (byte)35, (byte)28, (byte)31,
325 };
326
327 private static int[] SP1 = {
328 0x01010400, 0x00000000, 0x00010000, 0x01010404,
329 0x01010004, 0x00010404, 0x00000004, 0x00010000,
330 0x00000400, 0x01010400, 0x01010404, 0x00000400,
331 0x01000404, 0x01010004, 0x01000000, 0x00000004,
332 0x00000404, 0x01000400, 0x01000400, 0x00010400,
333 0x00010400, 0x01010000, 0x01010000, 0x01000404,
334 0x00010004, 0x01000004, 0x01000004, 0x00010004,
335 0x00000000, 0x00000404, 0x00010404, 0x01000000,
336 0x00010000, 0x01010404, 0x00000004, 0x01010000,
337 0x01010400, 0x01000000, 0x01000000, 0x00000400,
338 0x01010004, 0x00010000, 0x00010400, 0x01000004,
339 0x00000400, 0x00000004, 0x01000404, 0x00010404,
340 0x01010404, 0x00010004, 0x01010000, 0x01000404,
341 0x01000004, 0x00000404, 0x00010404, 0x01010400,
342 0x00000404, 0x01000400, 0x01000400, 0x00000000,
343 0x00010004, 0x00010400, 0x00000000, 0x01010004
344 };
345 private static int[] SP2 = {
346 0x80108020, 0x80008000, 0x00008000, 0x00108020,
347 0x00100000, 0x00000020, 0x80100020, 0x80008020,
348 0x80000020, 0x80108020, 0x80108000, 0x80000000,
349 0x80008000, 0x00100000, 0x00000020, 0x80100020,
350 0x00108000, 0x00100020, 0x80008020, 0x00000000,
351 0x80000000, 0x00008000, 0x00108020, 0x80100000,
352 0x00100020, 0x80000020, 0x00000000, 0x00108000,
353 0x00008020, 0x80108000, 0x80100000, 0x00008020,
354 0x00000000, 0x00108020, 0x80100020, 0x00100000,
355 0x80008020, 0x80100000, 0x80108000, 0x00008000,
356 0x80100000, 0x80008000, 0x00000020, 0x80108020,
357 0x00108020, 0x00000020, 0x00008000, 0x80000000,
358 0x00008020, 0x80108000, 0x00100000, 0x80000020,
359 0x00100020, 0x80008020, 0x80000020, 0x00100020,
360 0x00108000, 0x00000000, 0x80008000, 0x00008020,
361 0x80000000, 0x80100020, 0x80108020, 0x00108000
362 };
363 private static int[] SP3 = {
364 0x00000208, 0x08020200, 0x00000000, 0x08020008,
365 0x08000200, 0x00000000, 0x00020208, 0x08000200,
366 0x00020008, 0x08000008, 0x08000008, 0x00020000,
367 0x08020208, 0x00020008, 0x08020000, 0x00000208,
368 0x08000000, 0x00000008, 0x08020200, 0x00000200,
369 0x00020200, 0x08020000, 0x08020008, 0x00020208,
370 0x08000208, 0x00020200, 0x00020000, 0x08000208,
371 0x00000008, 0x08020208, 0x00000200, 0x08000000,
372 0x08020200, 0x08000000, 0x00020008, 0x00000208,
373 0x00020000, 0x08020200, 0x08000200, 0x00000000,
374 0x00000200, 0x00020008, 0x08020208, 0x08000200,
375 0x08000008, 0x00000200, 0x00000000, 0x08020008,
376 0x08000208, 0x00020000, 0x08000000, 0x08020208,
377 0x00000008, 0x00020208, 0x00020200, 0x08000008,
378 0x08020000, 0x08000208, 0x00000208, 0x08020000,
379 0x00020208, 0x00000008, 0x08020008, 0x00020200
380 };
381 private static int[] SP4 = {
382 0x00802001, 0x00002081, 0x00002081, 0x00000080,
383 0x00802080, 0x00800081, 0x00800001, 0x00002001,
384 0x00000000, 0x00802000, 0x00802000, 0x00802081,
385 0x00000081, 0x00000000, 0x00800080, 0x00800001,
386 0x00000001, 0x00002000, 0x00800000, 0x00802001,
387 0x00000080, 0x00800000, 0x00002001, 0x00002080,
388 0x00800081, 0x00000001, 0x00002080, 0x00800080,
389 0x00002000, 0x00802080, 0x00802081, 0x00000081,
390 0x00800080, 0x00800001, 0x00802000, 0x00802081,
391 0x00000081, 0x00000000, 0x00000000, 0x00802000,
392 0x00002080, 0x00800080, 0x00800081, 0x00000001,
393 0x00802001, 0x00002081, 0x00002081, 0x00000080,
394 0x00802081, 0x00000081, 0x00000001, 0x00002000,
395 0x00800001, 0x00002001, 0x00802080, 0x00800081,
396 0x00002001, 0x00002080, 0x00800000, 0x00802001,
397 0x00000080, 0x00800000, 0x00002000, 0x00802080
398 };
399 private static int[] SP5 = {
400 0x00000100, 0x02080100, 0x02080000, 0x42000100,
401 0x00080000, 0x00000100, 0x40000000, 0x02080000,
402 0x40080100, 0x00080000, 0x02000100, 0x40080100,
403 0x42000100, 0x42080000, 0x00080100, 0x40000000,
404 0x02000000, 0x40080000, 0x40080000, 0x00000000,
405 0x40000100, 0x42080100, 0x42080100, 0x02000100,
406 0x42080000, 0x40000100, 0x00000000, 0x42000000,
407 0x02080100, 0x02000000, 0x42000000, 0x00080100,
408 0x00080000, 0x42000100, 0x00000100, 0x02000000,
409 0x40000000, 0x02080000, 0x42000100, 0x40080100,
410 0x02000100, 0x40000000, 0x42080000, 0x02080100,
411 0x40080100, 0x00000100, 0x02000000, 0x42080000,
412 0x42080100, 0x00080100, 0x42000000, 0x42080100,
413 0x02080000, 0x00000000, 0x40080000, 0x42000000,
414 0x00080100, 0x02000100, 0x40000100, 0x00080000,
415 0x00000000, 0x40080000, 0x02080100, 0x40000100
416 };
417 private static int[] SP6 = {
418 0x20000010, 0x20400000, 0x00004000, 0x20404010,
419 0x20400000, 0x00000010, 0x20404010, 0x00400000,
420 0x20004000, 0x00404010, 0x00400000, 0x20000010,
421 0x00400010, 0x20004000, 0x20000000, 0x00004010,
422 0x00000000, 0x00400010, 0x20004010, 0x00004000,
423 0x00404000, 0x20004010, 0x00000010, 0x20400010,
424 0x20400010, 0x00000000, 0x00404010, 0x20404000,
425 0x00004010, 0x00404000, 0x20404000, 0x20000000,
426 0x20004000, 0x00000010, 0x20400010, 0x00404000,
427 0x20404010, 0x00400000, 0x00004010, 0x20000010,
428 0x00400000, 0x20004000, 0x20000000, 0x00004010,
429 0x20000010, 0x20404010, 0x00404000, 0x20400000,
430 0x00404010, 0x20404000, 0x00000000, 0x20400010,
431 0x00000010, 0x00004000, 0x20400000, 0x00404010,
432 0x00004000, 0x00400010, 0x20004010, 0x00000000,
433 0x20404000, 0x20000000, 0x00400010, 0x20004010
434 };
435 private static int[] SP7 = {
436 0x00200000, 0x04200002, 0x04000802, 0x00000000,
437 0x00000800, 0x04000802, 0x00200802, 0x04200800,
438 0x04200802, 0x00200000, 0x00000000, 0x04000002,
439 0x00000002, 0x04000000, 0x04200002, 0x00000802,
440 0x04000800, 0x00200802, 0x00200002, 0x04000800,
441 0x04000002, 0x04200000, 0x04200800, 0x00200002,
442 0x04200000, 0x00000800, 0x00000802, 0x04200802,
443 0x00200800, 0x00000002, 0x04000000, 0x00200800,
444 0x04000000, 0x00200800, 0x00200000, 0x04000802,
445 0x04000802, 0x04200002, 0x04200002, 0x00000002,
446 0x00200002, 0x04000000, 0x04000800, 0x00200000,
447 0x04200800, 0x00000802, 0x00200802, 0x04200800,
448 0x00000802, 0x04000002, 0x04200802, 0x04200000,
449 0x00200800, 0x00000000, 0x00000002, 0x04200802,
450 0x00000000, 0x00200802, 0x04200000, 0x00000800,
451 0x04000002, 0x04000800, 0x00000800, 0x00200002
452 };
453 private static int[] SP8 = {
454 0x10001040, 0x00001000, 0x00040000, 0x10041040,
455 0x10000000, 0x10001040, 0x00000040, 0x10000000,
456 0x00040040, 0x10040000, 0x10041040, 0x00041000,
457 0x10041000, 0x00041040, 0x00001000, 0x00000040,
458 0x10040000, 0x10000040, 0x10001000, 0x00001040,
459 0x00041000, 0x00040040, 0x10040040, 0x10041000,
460 0x00001040, 0x00000000, 0x00000000, 0x10040040,
461 0x10000040, 0x10001000, 0x00041040, 0x00040000,
462 0x00041040, 0x00040000, 0x10041000, 0x00001000,
463 0x00000040, 0x10040040, 0x00001000, 0x00041040,
464 0x10001000, 0x00000040, 0x10000040, 0x10040000,
465 0x10040040, 0x10000000, 0x00040000, 0x10001040,
466 0x00000000, 0x10041040, 0x00040040, 0x10000040,
467 0x10040000, 0x10001000, 0x10001040, 0x00000000,
468 0x10041040, 0x00041000, 0x00041000, 0x00001040,
469 0x00001040, 0x00040040, 0x10000000, 0x10041000
470 };
471
472 // Routines taken from other parts of the Acme utilities.
473
474 /// Squash bytes down to ints.
475 public static void squashBytesToInts( byte[] inBytes, int inOff, int[] outInts, int outOff, int intLen )
476 {
477 for ( int i = 0; i < intLen; ++i )
478 outInts[outOff + i] =
479 ( ( inBytes[inOff + i * 4 ] & 0xff ) << 24 ) |
480 ( ( inBytes[inOff + i * 4 + 1] & 0xff ) << 16 ) |
481 ( ( inBytes[inOff + i * 4 + 2] & 0xff ) << 8 ) |
482 ( inBytes[inOff + i * 4 + 3] & 0xff );
483 }
484
485 /// Spread ints into bytes.
486 public static void spreadIntsToBytes( int[] inInts, int inOff, byte[] outBytes, int outOff, int intLen )
487 {
488 for ( int i = 0; i < intLen; ++i )
489 {
490 outBytes[outOff + i * 4 ] = (byte) ( inInts[inOff + i] >>> 24 );
491 outBytes[outOff + i * 4 + 1] = (byte) ( inInts[inOff + i] >>> 16 );
492 outBytes[outOff + i * 4 + 2] = (byte) ( inInts[inOff + i] >>> 8 );
493 outBytes[outOff + i * 4 + 3] = (byte) inInts[inOff + i];
494 }
495 }
496 }
Note: See TracBrowser for help on using the repository browser.