Subversion Repositories openrisc

/* DES.java --
   Copyright (C) 2002, 2003, 2006 Free Software Foundation, Inc.
 
This file is a part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
USA
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version.  */
 
 
package gnu.javax.crypto.cipher;
 
import gnu.java.security.Registry;
import gnu.java.security.Properties;
import gnu.java.security.util.Util;
 
import java.security.InvalidKeyException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
 
/**
 * The Data Encryption Standard. DES is a 64-bit block cipher with a 56-bit
 * key, developed by IBM in the 1970's for the standardization process begun by
 * the National Bureau of Standards (now NIST).
 * <p>
 * New applications should not use DES except for compatibility.
 * <p>
 * This version is based upon the description and sample implementation in
 * [1].
 * <p>
 * References:
 * <ol>
 *    <li>Bruce Schneier, <i>Applied Cryptography: Protocols, Algorithms, and
 *    Source Code in C, Second Edition</i>. (1996 John Wiley and Sons) ISBN
 *    0-471-11709-9. Pages 265--301, 623--632.</li>
 * </ol>
 */
public class DES
    extends BaseCipher
{
  /** DES operates on 64 bit blocks. */
  public static final int BLOCK_SIZE = 8;
  /** DES uses 56 bits of a 64 bit parity-adjusted key. */
  public static final int KEY_SIZE = 8;
  // S-Boxes 1 through 8.
  private static final int[] SP1 = new int[] {
      0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404,
      0x00000004, 0x00010000, 0x00000400, 0x01010400, 0x01010404, 0x00000400,
      0x01000404, 0x01010004, 0x01000000, 0x00000004, 0x00000404, 0x01000400,
      0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404,
      0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404,
      0x00010404, 0x01000000, 0x00010000, 0x01010404, 0x00000004, 0x01010000,
      0x01010400, 0x01000000, 0x01000000, 0x00000400, 0x01010004, 0x00010000,
      0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
      0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404,
      0x00010404, 0x01010400, 0x00000404, 0x01000400, 0x01000400, 0x00000000,
      0x00010004, 0x00010400, 0x00000000, 0x01010004 };
  private static final int[] SP2 = new int[] {
      0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020,
      0x80100020, 0x80008020, 0x80000020, 0x80108020, 0x80108000, 0x80000000,
      0x80008000, 0x00100000, 0x00000020, 0x80100020, 0x00108000, 0x00100020,
      0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000,
      0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000,
      0x80100000, 0x00008020, 0x00000000, 0x00108020, 0x80100020, 0x00100000,
      0x80008020, 0x80100000, 0x80108000, 0x00008000, 0x80100000, 0x80008000,
      0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
      0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020,
      0x80000020, 0x00100020, 0x00108000, 0x00000000, 0x80008000, 0x00008020,
      0x80000000, 0x80100020, 0x80108020, 0x00108000 };
  private static final int[] SP3 = new int[] {
      0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000,
      0x00020208, 0x08000200, 0x00020008, 0x08000008, 0x08000008, 0x00020000,
      0x08020208, 0x00020008, 0x08020000, 0x00000208, 0x08000000, 0x00000008,
      0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208,
      0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208,
      0x00000200, 0x08000000, 0x08020200, 0x08000000, 0x00020008, 0x00000208,
      0x00020000, 0x08020200, 0x08000200, 0x00000000, 0x00000200, 0x00020008,
      0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
      0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208,
      0x00020200, 0x08000008, 0x08020000, 0x08000208, 0x00000208, 0x08020000,
      0x00020208, 0x00000008, 0x08020008, 0x00020200 };
  private static final int[] SP4 = new int[] {
      0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081,
      0x00800001, 0x00002001, 0x00000000, 0x00802000, 0x00802000, 0x00802081,
      0x00000081, 0x00000000, 0x00800080, 0x00800001, 0x00000001, 0x00002000,
      0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080,
      0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080,
      0x00802081, 0x00000081, 0x00800080, 0x00800001, 0x00802000, 0x00802081,
      0x00000081, 0x00000000, 0x00000000, 0x00802000, 0x00002080, 0x00800080,
      0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
      0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001,
      0x00802080, 0x00800081, 0x00002001, 0x00002080, 0x00800000, 0x00802001,
      0x00000080, 0x00800000, 0x00002000, 0x00802080 };
  private static final int[] SP5 = new int[] {
      0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100,
      0x40000000, 0x02080000, 0x40080100, 0x00080000, 0x02000100, 0x40080100,
      0x42000100, 0x42080000, 0x00080100, 0x40000000, 0x02000000, 0x40080000,
      0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100,
      0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000,
      0x42000000, 0x00080100, 0x00080000, 0x42000100, 0x00000100, 0x02000000,
      0x40000000, 0x02080000, 0x42000100, 0x40080100, 0x02000100, 0x40000000,
      0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
      0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000,
      0x40080000, 0x42000000, 0x00080100, 0x02000100, 0x40000100, 0x00080000,
      0x00000000, 0x40080000, 0x02080100, 0x40000100 };
  private static final int[] SP6 = new int[] {
      0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010,
      0x20404010, 0x00400000, 0x20004000, 0x00404010, 0x00400000, 0x20000010,
      0x00400010, 0x20004000, 0x20000000, 0x00004010, 0x00000000, 0x00400010,
      0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010,
      0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000,
      0x20404000, 0x20000000, 0x20004000, 0x00000010, 0x20400010, 0x00404000,
      0x20404010, 0x00400000, 0x00004010, 0x20000010, 0x00400000, 0x20004000,
      0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
      0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000,
      0x20400000, 0x00404010, 0x00004000, 0x00400010, 0x20004010, 0x00000000,
      0x20404000, 0x20000000, 0x00400010, 0x20004010 };
  private static final int[] SP7 = new int[] {
      0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802,
      0x00200802, 0x04200800, 0x04200802, 0x00200000, 0x00000000, 0x04000002,
      0x00000002, 0x04000000, 0x04200002, 0x00000802, 0x04000800, 0x00200802,
      0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002,
      0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002,
      0x04000000, 0x00200800, 0x04000000, 0x00200800, 0x00200000, 0x04000802,
      0x04000802, 0x04200002, 0x04200002, 0x00000002, 0x00200002, 0x04000000,
      0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
      0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000,
      0x00000002, 0x04200802, 0x00000000, 0x00200802, 0x04200000, 0x00000800,
      0x04000002, 0x04000800, 0x00000800, 0x00200002 };
  private static final int[] SP8 = new int[] {
      0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040,
      0x00000040, 0x10000000, 0x00040040, 0x10040000, 0x10041040, 0x00041000,
      0x10041000, 0x00041040, 0x00001000, 0x00000040, 0x10040000, 0x10000040,
      0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000,
      0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000,
      0x00041040, 0x00040000, 0x00041040, 0x00040000, 0x10041000, 0x00001000,
      0x00000040, 0x10040040, 0x00001000, 0x00041040, 0x10001000, 0x00000040,
      0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
      0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000,
      0x10001040, 0x00000000, 0x10041040, 0x00041000, 0x00041000, 0x00001040,
      0x00001040, 0x00040040, 0x10000000, 0x10041000 };
  /**
   * Constants that help in determining whether or not a byte array is parity
   * adjusted.
   */
  private static final byte[] PARITY = {
      8, 1, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 2, 8,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 3,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
      8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
      8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      8, 0, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 0, 8,
      0, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      4, 8, 8, 0, 8, 0, 0, 8, 8, 0, 0, 8, 0, 8, 8, 0,
      8, 5, 0, 8, 0, 8, 8, 0, 0, 8, 8, 0, 8, 0, 6, 8 };
  // Key schedule constants.
  private static final byte[] ROTARS = {
      1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28 };
  private static final byte[] PC1 = {
      56, 48, 40, 32, 24, 16,  8,  0, 57, 49, 41, 33, 25, 17,  9,  1,
      58, 50, 42, 34, 26, 18, 10,  2, 59, 51, 43, 35, 62, 54, 46, 38,
      30, 22, 14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 60, 52, 44, 36,
      28, 20, 12,  4, 27, 19, 11,  3 };
  private static final byte[] PC2 = {
      13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9, 22, 18, 11,  3,
      25,  7, 15,  6, 26, 19, 12,  1, 40, 51, 30, 36, 46, 54, 29, 39,
      50, 44, 32, 47, 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };
  /**
   * Weak keys (parity adjusted): If all the bits in each half are either 0
   * or 1, then the key used for any cycle of the algorithm is the same as
   * all other cycles.
   */
  public static final byte[][] WEAK_KEYS = {
      Util.toBytesFromString("0101010101010101"),
      Util.toBytesFromString("01010101FEFEFEFE"),
      Util.toBytesFromString("FEFEFEFE01010101"),
      Util.toBytesFromString("FEFEFEFEFEFEFEFE") };
  /**
   * Semi-weak keys (parity adjusted):  Some pairs of keys encrypt plain text
   * to identical cipher text. In other words, one key in the pair can decrypt
   * messages that were encrypted with the other key. These keys are called
   * semi-weak keys. This occurs because instead of 16 different sub-keys being
   * generated, these semi-weak keys produce only two different sub-keys.
   */
  public static final byte[][] SEMIWEAK_KEYS = {
      Util.toBytesFromString("01FE01FE01FE01FE"),
      Util.toBytesFromString("FE01FE01FE01FE01"),
      Util.toBytesFromString("1FE01FE00EF10EF1"),
      Util.toBytesFromString("E01FE01FF10EF10E"),
      Util.toBytesFromString("01E001E001F101F1"),
      Util.toBytesFromString("E001E001F101F101"),
      Util.toBytesFromString("1FFE1FFE0EFE0EFE"),
      Util.toBytesFromString("FE1FFE1FFE0EFE0E"),
      Util.toBytesFromString("011F011F010E010E"),
      Util.toBytesFromString("1F011F010E010E01"),
      Util.toBytesFromString("E0FEE0FEF1FEF1FE"),
      Util.toBytesFromString("FEE0FEE0FEF1FEF1") };
  /** Possible weak keys (parity adjusted) --produce 4 instead of 16 subkeys. */
  public static final byte[][] POSSIBLE_WEAK_KEYS = {
      Util.toBytesFromString("1F1F01010E0E0101"),
      Util.toBytesFromString("011F1F01010E0E01"),
      Util.toBytesFromString("1F01011F0E01010E"),
      Util.toBytesFromString("01011F1F01010E0E"),
      Util.toBytesFromString("E0E00101F1F10101"),
      Util.toBytesFromString("FEFE0101FEFE0101"),
      Util.toBytesFromString("FEE01F01FEF10E01"),
      Util.toBytesFromString("E0FE1F01F1FE0E01"),
      Util.toBytesFromString("FEE0011FFEF1010E"),
      Util.toBytesFromString("E0FE011FF1FE010E"),
      Util.toBytesFromString("E0E01F1FF1F10E0E"),
      Util.toBytesFromString("FEFE1F1FFEFE0E0E"),
      Util.toBytesFromString("1F1F01010E0E0101"),
      Util.toBytesFromString("011F1F01010E0E01"),
      Util.toBytesFromString("1F01011F0E01010E"),
      Util.toBytesFromString("01011F1F01010E0E"),
      Util.toBytesFromString("01E0E00101F1F101"),
      Util.toBytesFromString("1FFEE0010EFEF001"),
      Util.toBytesFromString("1FE0FE010EF1FE01"),
      Util.toBytesFromString("01FEFE0101FEFE01"),
      Util.toBytesFromString("1FE0E01F0EF1F10E"),
      Util.toBytesFromString("01FEE01F01FEF10E"),
      Util.toBytesFromString("01E0FE1F01F1FE0E"),
      Util.toBytesFromString("1FFEFE1F0EFEFE0E"),
 
      Util.toBytesFromString("E00101E0F10101F1"),
      Util.toBytesFromString("FE1F01E0FE0E0EF1"),
      Util.toBytesFromString("FE011FE0FE010EF1"),
      Util.toBytesFromString("E01F1FE0F10E0EF1"),
      Util.toBytesFromString("FE0101FEFE0101FE"),
      Util.toBytesFromString("E01F01FEF10E01FE"),
      Util.toBytesFromString("E0011FFEF1010EFE"),
      Util.toBytesFromString("FE1F1FFEFE0E0EFE"),
      Util.toBytesFromString("1FFE01E00EFE01F1"),
      Util.toBytesFromString("01FE1FE001FE0EF1"),
      Util.toBytesFromString("1FE001FE0EF101FE"),
      Util.toBytesFromString("01E01FFE01F10EFE"),
      Util.toBytesFromString("0101E0E00101F1F1"),
      Util.toBytesFromString("1F1FE0E00E0EF1F1"),
      Util.toBytesFromString("1F01FEE00E01FEF1"),
      Util.toBytesFromString("011FFEE0010EFEF1"),
      Util.toBytesFromString("1F01E0FE0E01F1FE"),
      Util.toBytesFromString("011FE0FE010EF1FE"),
      Util.toBytesFromString("0101FEFE0001FEFE"),
      Util.toBytesFromString("1F1FFEFE0E0EFEFE"),
      Util.toBytesFromString("FEFEE0E0FEFEF1F1"),
      Util.toBytesFromString("E0FEFEE0F1FEFEF1"),
      Util.toBytesFromString("FEE0E0FEFEF1F1FE"),
      Util.toBytesFromString("E0E0FEFEF1F1FEFE") };
 
  /** Default 0-argument constructor. */
  public DES()
  {
    super(Registry.DES_CIPHER, BLOCK_SIZE, KEY_SIZE);
  }
 
  /**
   * Adjust the parity for a raw key array. This essentially means that each
   * byte in the array will have an odd number of '1' bits (the last bit in
   * each byte is unused.
   *
   * @param kb The key array, to be parity-adjusted.
   * @param offset The starting index into the key bytes.
   */
  public static void adjustParity(byte[] kb, int offset)
  {
    for (int i = offset; i < offset + KEY_SIZE; i++)
      kb[i] ^= (PARITY[kb[i] & 0xff] == 8) ? 1 : 0;
  }
 
  /**
   * Test if a byte array, which must be at least 8 bytes long, is parity
   * adjusted.
   *
   * @param kb The key bytes.
   * @param offset The starting index into the key bytes.
   * @return <code>true</code> if the first 8 bytes of <i>kb</i> have been
   * parity adjusted. <code>false</code> otherwise.
   */
  public static boolean isParityAdjusted(byte[] kb, int offset)
  {
    int w = 0x88888888;
    int n = PARITY[kb[offset + 0] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 1] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 2] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 3] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 4] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 5] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 6] & 0xff];
    n <<= 4;
    n |= PARITY[kb[offset + 7] & 0xff];
    return (n & w) == 0;
  }
 
  /**
   * Test if a key is a weak key.
   *
   * @param kb The key to test.
   * @return <code>true</code> if the key is weak.
   */
  public static boolean isWeak(byte[] kb)
  {
    for (int i = 0; i < WEAK_KEYS.length; i++)
      if (Arrays.equals(WEAK_KEYS[i], kb))
        return true;
    return false;
  }
 
  /**
   * Test if a key is a semi-weak key.
   *
   * @param kb The key to test.
   * @return <code>true</code> if this key is semi-weak.
   */
  public static boolean isSemiWeak(byte[] kb)
  {
    for (int i = 0; i < SEMIWEAK_KEYS.length; i++)
      if (Arrays.equals(SEMIWEAK_KEYS[i], kb))
        return true;
    return false;
  }
 
  /**
   * Test if the designated byte array represents a possibly weak key.
   *
   * @param kb the byte array to test.
   * @return <code>true</code> if <code>kb</code>represents a possibly weak key.
   * Returns <code>false</code> otherwise.
   */
  public static boolean isPossibleWeak(byte[] kb)
  {
    for (int i = 0; i < POSSIBLE_WEAK_KEYS.length; i++)
      if (Arrays.equals(POSSIBLE_WEAK_KEYS[i], kb))
        return true;
    return false;
  }
 
  /**
   * The core DES function. This is used for both encryption and decryption,
   * the only difference being the key.
   *
   * @param in The input bytes.
   * @param i The starting offset into the input bytes.
   * @param out The output bytes.
   * @param o The starting offset into the output bytes.
   * @param key The working key.
   */
  private static void desFunc(byte[] in, int i, byte[] out, int o, int[] key)
  {
    int right, left, work;
    // Load.
    left =  (in[i++] & 0xff) << 24
          | (in[i++] & 0xff) << 16
          | (in[i++] & 0xff) << 8
          |  in[i++] & 0xff;
    right = (in[i++] & 0xff) << 24
          | (in[i++] & 0xff) << 16
          | (in[i++] & 0xff) << 8
          |  in[i  ] & 0xff;
    // Initial permutation.
    work = ((left >>> 4) ^ right) & 0x0F0F0F0F;
    left ^= work << 4;
    right ^= work;
 
    work = ((left >>> 16) ^ right) & 0x0000FFFF;
    left ^= work << 16;
    right ^= work;
 
    work = ((right >>> 2) ^ left) & 0x33333333;
    right ^= work << 2;
    left ^= work;
 
    work = ((right >>> 8) ^ left) & 0x00FF00FF;
    right ^= work << 8;
    left ^= work;
 
    right = ((right << 1) | ((right >>> 31) & 1)) & 0xFFFFFFFF;
    work = (left ^ right) & 0xAAAAAAAA;
    left ^= work;
    right ^= work;
    left = ((left << 1) | ((left >>> 31) & 1)) & 0xFFFFFFFF;
 
    int k = 0, t;
    for (int round = 0; round < 8; round++)
      {
        work = right >>> 4 | right << 28;
        work ^= key[k++];
        t = SP7[work & 0x3F];
        work >>>= 8;
        t |= SP5[work & 0x3F];
        work >>>= 8;
        t |= SP3[work & 0x3F];
        work >>>= 8;
        t |= SP1[work & 0x3F];
        work = right ^ key[k++];
        t |= SP8[work & 0x3F];
        work >>>= 8;
        t |= SP6[work & 0x3F];
        work >>>= 8;
        t |= SP4[work & 0x3F];
        work >>>= 8;
        t |= SP2[work & 0x3F];
        left ^= t;
 
        work = left >>> 4 | left << 28;
        work ^= key[k++];
        t = SP7[work & 0x3F];
        work >>>= 8;
        t |= SP5[work & 0x3F];
        work >>>= 8;
        t |= SP3[work & 0x3F];
        work >>>= 8;
        t |= SP1[work & 0x3F];
        work = left ^ key[k++];
        t |= SP8[work & 0x3F];
        work >>>= 8;
        t |= SP6[work & 0x3F];
        work >>>= 8;
        t |= SP4[work & 0x3F];
        work >>>= 8;
        t |= SP2[work & 0x3F];
        right ^= t;
      }
    // The final permutation.
    right = (right << 31) | (right >>> 1);
    work = (left ^ right) & 0xAAAAAAAA;
    left ^= work;
    right ^= work;
    left = (left << 31) | (left >>> 1);
 
    work = ((left >>> 8) ^ right) & 0x00FF00FF;
    left ^= work << 8;
    right ^= work;
 
    work = ((left >>> 2) ^ right) & 0x33333333;
    left ^= work << 2;
    right ^= work;
 
    work = ((right >>> 16) ^ left) & 0x0000FFFF;
    right ^= work << 16;
    left ^= work;
 
    work = ((right >>> 4) ^ left) & 0x0F0F0F0F;
    right ^= work << 4;
    left ^= work;
 
    out[o++] = (byte)(right >>> 24);
    out[o++] = (byte)(right >>> 16);
    out[o++] = (byte)(right >>> 8);
    out[o++] = (byte) right;
    out[o++] = (byte)(left >>> 24);
    out[o++] = (byte)(left >>> 16);
    out[o++] = (byte)(left >>> 8);
    out[o  ] = (byte) left;
  }
 
  public Object clone()
  {
    return new DES();
  }
 
  public Iterator blockSizes()
  {
    return Collections.singleton(Integer.valueOf(BLOCK_SIZE)).iterator();
  }
 
  public Iterator keySizes()
  {
    return Collections.singleton(Integer.valueOf(KEY_SIZE)).iterator();
  }
 
  public Object makeKey(byte[] kb, int bs) throws InvalidKeyException
  {
    if (kb == null || kb.length != KEY_SIZE)
      throw new InvalidKeyException("DES keys must be 8 bytes long");
 
    if (Properties.checkForWeakKeys()
        && (isWeak(kb) || isSemiWeak(kb) || isPossibleWeak(kb)))
      throw new WeakKeyException();
 
    int i, j, l, m, n;
    long pc1m = 0, pcr = 0;
 
    for (i = 0; i < 56; i++)
      {
        l = PC1[i];
        pc1m |= ((kb[l >>> 3] & (0x80 >>> (l & 7))) != 0) ? (1L << (55 - i))
                                                          : 0;
      }
    Context ctx = new Context();
    // Encryption key first.
    for (i = 0; i < 16; i++)
      {
        pcr = 0;
        m = i << 1;
        n = m + 1;
        for (j = 0; j < 28; j++)
          {
            l = j + ROTARS[i];
            if (l < 28)
              pcr |= ((pc1m & 1L << (55 - l)) != 0) ? (1L << (55 - j)) : 0;
            else
              pcr |= ((pc1m & 1L << (55 - (l - 28))) != 0) ? (1L << (55 - j))
                                                           : 0;
          }
        for (j = 28; j < 56; j++)
          {
            l = j + ROTARS[i];
            if (l < 56)
              pcr |= ((pc1m & 1L << (55 - l)) != 0) ? (1L << (55 - j)) : 0;
            else
              pcr |= ((pc1m & 1L << (55 - (l - 28))) != 0) ? (1L << (55 - j))
                                                           : 0;
          }
        for (j = 0; j < 24; j++)
          {
            if ((pcr & 1L << (55 - PC2[j])) != 0)
              ctx.ek[m] |= 1 << (23 - j);
            if ((pcr & 1L << (55 - PC2[j + 24])) != 0)
              ctx.ek[n] |= 1 << (23 - j);
          }
      }
    // The decryption key is the same, but in reversed order.
    for (i = 0; i < Context.EXPANDED_KEY_SIZE; i += 2)
      {
        ctx.dk[30 - i] = ctx.ek[i];
        ctx.dk[31 - i] = ctx.ek[i + 1];
      }
    // "Cook" the keys.
    for (i = 0; i < 32; i += 2)
      {
        int x, y;
        x = ctx.ek[i];
        y = ctx.ek[i + 1];
        ctx.ek[i    ] = ((x & 0x00FC0000)  <<  6)
                      | ((x & 0x00000FC0)  << 10)
                      | ((y & 0x00FC0000) >>> 10)
                      | ((y & 0x00000FC0) >>>  6);
        ctx.ek[i + 1] = ((x & 0x0003F000)  << 12)
                      | ((x & 0x0000003F)  << 16)
                      | ((y & 0x0003F000) >>>  4)
                      |  (y & 0x0000003F);
        x = ctx.dk[i];
        y = ctx.dk[i + 1];
        ctx.dk[i    ] = ((x & 0x00FC0000)  <<  6)
                      | ((x & 0x00000FC0)  << 10)
                      | ((y & 0x00FC0000) >>> 10)
                      | ((y & 0x00000FC0) >>>  6);
        ctx.dk[i + 1] = ((x & 0x0003F000)  << 12)
                      | ((x & 0x0000003F)  << 16)
                      | ((y & 0x0003F000) >>>  4)
                      |  (y & 0x0000003F);
      }
    return ctx;
  }
 
  public void encrypt(byte[] in, int i, byte[] out, int o, Object K, int bs)
  {
    desFunc(in, i, out, o, ((Context) K).ek);
  }
 
  public void decrypt(byte[] in, int i, byte[] out, int o, Object K, int bs)
  {
    desFunc(in, i, out, o, ((Context) K).dk);
  }
 
  /**
   * Simple wrapper class around the session keys. Package-private so TripleDES
   * can see it.
   */
  final class Context
  {
    private static final int EXPANDED_KEY_SIZE = 32;
 
    /** The encryption key. */
    int[] ek;
 
    /** The decryption key. */
    int[] dk;
 
    /** Default 0-arguments constructor. */
    Context()
    {
      ek = new int[EXPANDED_KEY_SIZE];
      dk = new int[EXPANDED_KEY_SIZE];
    }
 
    byte[] getEncryptionKeyBytes()
    {
      return toByteArray(ek);
    }
 
    byte[] getDecryptionKeyBytes()
    {
      return toByteArray(dk);
    }
 
    byte[] toByteArray(int[] k)
    {
      byte[] result = new byte[4 * k.length];
      for (int i = 0, j = 0; i < k.length; i++)
        {
          result[j++] = (byte)(k[i] >>> 24);
          result[j++] = (byte)(k[i] >>> 16);
          result[j++] = (byte)(k[i] >>> 8);
          result[j++] = (byte) k[i];
        }
      return result;
    }
  }
}