DesCipher.java

   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
  73 import 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
  91 public 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     }