source: trunk/packages/invirt-vnc-client/DesCipher.java @ 2108

Last change on this file since 2108 was 1334, checked in by broder, 16 years ago

sipb-xen-vnc-client -> invirt-vnc-client

File size: 18.0 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:
8//  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
9//
10// This software is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13//
14
15// DesCipher - the DES encryption method
16//
17// The meat of this code is by Dave Zimmerman <dzimm@widget.com>, and is:
18//
19// Copyright (c) 1996 Widget Workshop, Inc. All Rights Reserved.
20//
21// Permission to use, copy, modify, and distribute this software
22// and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
23// without fee is hereby granted, provided that this copyright notice is kept
24// intact.
25//
26// WIDGET WORKSHOP MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY
27// OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
28// TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
29// PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WIDGET WORKSHOP SHALL NOT BE LIABLE
30// FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
31// DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
32//
33// THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
34// CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
35// PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
36// NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
37// SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
38// SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
39// PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  WIDGET WORKSHOP
40// SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
41// HIGH RISK ACTIVITIES.
42//
43//
44// The rest is:
45//
46// Copyright (C) 1996 by Jef Poskanzer <jef@acme.com>.  All rights reserved.
47//
48// Redistribution and use in source and binary forms, with or without
49// modification, are permitted provided that the following conditions
50// are met:
51// 1. Redistributions of source code must retain the above copyright
52//    notice, this list of conditions and the following disclaimer.
53// 2. Redistributions in binary form must reproduce the above copyright
54//    notice, this list of conditions and the following disclaimer in the
55//    documentation and/or other materials provided with the distribution.
56//
57// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
58// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
59// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
60// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
61// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
62// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
63// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
64// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
65// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
66// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
67// SUCH DAMAGE.
68//
69// Visit the ACME Labs Java page for up-to-date versions of this and other
70// fine Java utilities: http://www.acme.com/java/
71
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 <dzimm@widget.com>, 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.