des.java

DES算法的JAVA实现源代码

/*
 * This Java version of Eric Young's code created from the
 * original source by Jeremy Allison. <[e-mail]>.
 * Version 1.0.
 */

/* Copyright (C) 1995 Eric Young ([e-mail])
 * All rights reserved.
 *
 * This file is part of an SSL implementation written
 * by Eric Young ([e-mail]).
 * The implementation was written so as to conform with Netscapes SSL
 * specification.  This library and applications are
 * FREE FOR COMMERCIAL AND NON-COMMERCIAL USE
 * as long as the following conditions are aheared to.
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.  If this code is used in a product,
 * Eric Young should be given attribution as the author of the parts used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    This product includes software developed by Eric Young ([e-mail])
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

/**
 * Int32Manipulator class.
 * Provides byte manipulation functions used by the Des and
 * TripleDes code.
 *
 * Written by Jeremy Allison ([e-mail]) based on
 * C code from Eric Young ([e-mail]).
 */
class Int32Manipulator {
  /**
   *
   * Convert 4 bytes from a byte array to a 32-bit int 
   * (read from the array as little-endian format).
   * Returns the 32 bit int.
   * @param b             Byte array to convert from.
   * @param start         offset in byte array to begin.
   *
   */
  public static int bytes_to_int(byte [] b, int start) {
    return (((int)b[start]) & 0xff)|
      ((((int)b[start+1]) & 0xff) << 8) |
      ((((int)b[start+2]) & 0xff) << 16) |
      ((((int)b[start+3]) & 0xff) << 24);
  }

  /**
   *
   * Write a 32-bit int into 4 bytes of a byte array 
   * (write into the array as little-endian format).
   * @param bytes        Byte aray to write into.
   * @param offset       Offset into array to begin.
   * @param val          32-bit int to write.
   *
   */
  public static void set_int(byte [] bytes, int offset, int val) {
    bytes[offset++] = (byte)(val & 0xff);
    bytes[offset++] = (byte)((val >>> 8) & 0xff);
    bytes[offset++] = (byte)((val >>> 16) & 0xff);
    bytes[offset++] = (byte)((val >>> 24) & 0xff);
  }

  /**
   * c2ln. Internal routine used by Des code.
   *
   */
  /*
     #define c2ln(c,l1,l2,n)	{ \
     c+=n; \
     l1=l2=0; \
     switch (n) { \
     case 8: l2 =((DES_LONG)(*(--(c))))<<24L; \
     case 7: l2|=((DES_LONG)(*(--(c))))<<16L; \
     case 6: l2|=((DES_LONG)(*(--(c))))<< 8L; \
     case 5: l2|=((DES_LONG)(*(--(c))));     \
     case 4: l1 =((DES_LONG)(*(--(c))))<<24L; \
     case 3: l1|=((DES_LONG)(*(--(c))))<<16L; \
     case 2: l1|=((DES_LONG)(*(--(c))))<< 8L; \
     case 1: l1|=((DES_LONG)(*(--(c))));     \
     } \
     }
     */

  public static int c2ln(byte [] input, int offset, int length, int [] ref_to_in01) {
    int orig_length = length;
    ref_to_in01[0] = 0;
    ref_to_in01[1] = 0;
    switch (length) {
    case 8:
      ref_to_in01[1] = (((int)input[offset + (--length)]) & 0xff) << 24;
    case 7:
      ref_to_in01[1] |= (((int)input[offset + (--length)]) & 0xff) << 16;
    case 6:
      ref_to_in01[1] |= (((int)input[offset + (--length)]) & 0xff) << 8;
    case 5:
      ref_to_in01[1] |= ((int)input[offset + (--length)]) & 0xff;
    case 4:
      ref_to_in01[0] = (((int)input[offset + (--length)]) & 0xFF) << 24;
    case 3:
      ref_to_in01[0] |= (((int)input[offset + (--length)]) & 0xff) << 16;
    case 2:
      ref_to_in01[0] |= (((int)input[offset + (--length)]) & 0xff) << 8;
    case 1:
      ref_to_in01[0] |= ((int)input[offset + (--length)]) & 0xff;
    }
    return orig_length;
  }

  /**
   * l2cn. Internal routine used by Des Code.
   *
   */
  /*
    #define l2cn(l1,l2,c,n)	{ \
    c+=n; \
    switch (n) { \
    case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \
    case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \
    case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \
    case 5: *(--(c))=(unsigned char)(((l2)     )&0xff); \
    case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \
    case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \
    case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \
    case 1: *(--(c))=(unsigned char)(((l1)     )&0xff); \
    } \
    }
    */
  public static int l2cn(byte [] output, int offset, int length, int out0, int out1) {
    int orig_length = length;
    switch(length) {
    case 8:
      output[offset + (--length)] = (byte)((out1>>>24)&0xff);
    case 7:
      output[offset + (--length)] = (byte)((out1>>>16)&0xff);
    case 6:
      output[offset + (--length)] = (byte)((out1>>>8)&0xff);
    case 5:
      output[offset + (--length)] = (byte)(out1 & 0xff);
    case 4:
      output[offset + (--length)] = (byte)((out0>>>24)&0xff);
    case 3:
      output[offset + (--length)] = (byte)((out0>>>16)&0xff);
    case 2:
      output[offset + (--length)] = (byte)((out0>>>8)&0xff);
    case 1:
      output[offset + (--length)] = (byte)(out0 & 0xff);
    }
    return orig_length;
  }

  /**
   * PERM_OP. Internal routine used by Des code.
   *
   */
  /*
   * Do a PERM_OP. Defined as ..
   *
   #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
   (b)^=(t),\
   (a)^=((t)<<(n)))
   */
  public static void PERM_OP(int [] ref_to_a, int [] ref_to_b, int tmp, int n, int m) {
    int a = ref_to_a[0];
    int b = ref_to_b[0];
    tmp = ((a>>>n)^b)&m;
    b ^= tmp;
    a ^= tmp<<n;
    ref_to_a[0] = a;
    ref_to_b[0] = b;
  }

  /**
   * HPERM_OP. Internal routine used by Des code.
   *
   */

  /*
   * Do a HPERM_OP. Defined as ..
   #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
   (a)=(a)^(t)^(t>>(16-(n))))

   */
  public static void HPERM_OP(int [] ref_to_a, int tmp, int n, int m) {
    int a = ref_to_a[0];
    tmp = ((a<<(16-n))^a)&m;
    a = a^tmp^(tmp>>>(16-n));
    ref_to_a[0] = a;
  }
}

/**
 * Class DesKey.
 * Create a key object used by the Des and TripleDes code.
 * DesKey objects can be created from a String object, or from
 * a byte array containing 8 bytes.
 * An optional check is done for weak keys.
 * 
 * Written by Jeremy Allison ([e-mail]) based on
 * C code from Eric Young ([e-mail]).
 */

class DesKey {

  private byte [] keysced_ = new byte [128];
  /* True if key was weak */
  private boolean is_weak_key_;
  private boolean is_parity_ok_;

  /**
   * Function to return the internal byte representation of
   * the DesKey. Used internally by the Des and TripleDes
   * classes.
   * Returns a byte [].
   */
  public byte [] get_keysced() { return keysced_; }

  /**
   * Function to check if a DesKey is weak.
   * returns a boolean, true if this is a weak key.
   */
  public boolean is_weak_key() { return is_weak_key_; }

  /**
   * Function to check is the DesKey parity is correct.
   * returns a boolean, true if the parity is correct.
   */
  public boolean is_parity_ok() { return is_parity_ok_; }

  private static final byte[] odd_parity_array = {
    (byte)1,  (byte)1,  (byte)2,  (byte)2, (byte)4,  (byte)4,  (byte)7,  (byte)7,
    (byte)8,  (byte)8, (byte)11, (byte)11, (byte)13, (byte)13, (byte)14, (byte)14,
    (byte)16, (byte)16, (byte)19, (byte)19, (byte)21, (byte)21, (byte)22, (byte)22,
    (byte)25, (byte)25, (byte)26, (byte)26, (byte)28, (byte)28, (byte)31, (byte)31,
    (byte)32, (byte)32, (byte)35, (byte)35, (byte)37, (byte)37, (byte)38, (byte)38,
    (byte)41, (byte)41, (byte)42, (byte)42, (byte)44, (byte)44, (byte)47, (byte)47,
    (byte)49, (byte)49, (byte)50, (byte)50, (byte)52, (byte)52, (byte)55, (byte)55,
    (byte)56, (byte)56, (byte)59, (byte)59, (byte)61, (byte)61, (byte)62, (byte)62,
    (byte)64, (byte)64, (byte)67, (byte)67, (byte)69, (byte)69, (byte)70, (byte)70,
    (byte)73, (byte)73, (byte)74, (byte)74, (byte)76, (byte)76, (byte)79, (byte)79,
    (byte)81, (byte)81, (byte)82, (byte)82, (byte)84, (byte)84, (byte)87, (byte)87,
    (byte)88, (byte)88, (byte)91, (byte)91, (byte)93, (byte)93, (byte)94, (byte)94,
    (byte)97, (byte)97, (byte)98, (byte)98,(byte)100,(byte)100,(byte)103,(byte)103,
    (byte)104,(byte)104,(byte)107,(byte)107,(byte)109,(byte)109,(byte)110,(byte)110,
    (byte)112,(byte)112,(byte)115,(byte)115,(byte)117,(byte)117,(byte)118,(byte)118,
    (byte)121,(byte)121,(byte)122,(byte)122,(byte)124,(byte)124,(byte)127,(byte)127,
    (byte)128,(byte)128,(byte)131,(byte)131,(byte)133,(byte)133,(byte)134,(byte)134,
    (byte)137,(byte)137,(byte)138,(byte)138,(byte)140,(byte)140,(byte)143,(byte)143,
    (byte)145,(byte)145,(byte)146,(byte)146,(byte)148,(byte)148,(byte)151,(byte)151,
    (byte)152,(byte)152,(byte)155,(byte)155,(byte)157,(byte)157,(byte)158,(byte)158,
    (byte)161,(byte)161,(byte)162,(byte)162,(byte)164,(byte)164,(byte)167,(byte)167,
    (byte)168,(byte)168,(byte)171,(byte)171,(byte)173,(byte)173,(byte)174,(byte)174,
    (byte)176,(byte)176,(byte)179,(byte)179,(byte)181,(byte)181,(byte)182,(byte)182,
    (byte)185,(byte)185,(byte)186,(byte)186,(byte)188,(byte)188,(byte)191,(byte)191,
    (byte)193,(byte)193,(byte)194,(byte)194,(byte)196,(byte)196,(byte)199,(byte)199,
    (byte)200,(byte)200,(byte)203,(byte)203,(byte)205,(byte)205,(byte)206,(byte)206,
    (byte)208,(byte)208,(byte)211,(byte)211,(byte)213,(byte)213,(byte)214,(byte)214,
    (byte)217,(byte)217,(byte)218,(byte)218,(byte)220,(byte)220,(byte)223,(byte)223,
    (byte)224,(byte)224,(byte)227,(byte)227,(byte)229,(byte)229,(byte)230,(byte)230,
    (byte)233,(byte)233,(byte)234,(byte)234,(byte)236,(byte)236,(byte)239,(byte)239,
    (byte)241,(byte)241,(byte)242,(byte)242,(byte)244,(byte)244,(byte)247,(byte)247,
    (byte)248,(byte)248,(byte)251,(byte)251,(byte)253,(byte)253,(byte)254,(byte)254
  };

  private static final boolean shifts2[] = {
    false, false, true, true,
    true, true, true, true,
    false, true, true, true,
    true, true, true, false
  };

  private static final int des_skb[][] = {
    {
      /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
      0x00000000,0x00000010,0x20000000,0x20000010,
      0x00010000,0x00010010,0x20010000,0x20010010,
      0x00000800,0x00000810,0x20000800,0x20000810,
      0x00010800,0x00010810,0x20010800,0x20010810,
      0x00000020,0x00000030,0x20000020,0x20000030,
      0x00010020,0x00010030,0x20010020,0x20010030,
      0x00000820,0x00000830,0x20000820,0x20000830,
      0x00010820,0x00010830,0x20010820,0x20010830,
      0x00080000,0x00080010,0x20080000,0x20080010,
      0x00090000,0x00090010,0x20090000,0x20090010,
      0x00080800,0x00080810,0x20080800,0x20080810,
      0x00090800,0x00090810,0x20090800,0x20090810,
      0x00080020,0x00080030,0x20080020,0x20080030,
      0x00090020,0x00090030,0x20090020,0x20090030,
      0x00080820,0x00080830,0x20080820,0x20080830,
      0x00090820,0x00090830,0x20090820,0x20090830,
    },{
      /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
      0x00000000,0x02000000,0x00002000,0x02002000,
      0x00200000,0x02200000,0x00202000,0x02202000,
      0x00000004,0x02000004,0x00002004,0x02002004,
      0x00200004,0x02200004,0x00202004,0x02202004,
      0x00000400,0x02000400,0x00002400,0x02002400,
      0x00200400,0x02200400,0x00202400,0x02202400,
      0x00000404,0x02000404,0x00002404,0x02002404,
      0x00200404,0x02200404,0x00202404,0x02202404,
      0x10000000,0x12000000,0x10002000,0x12002000,
      0x10200000,0x12200000,0x10202000,0x12202000,
      0x10000004,0x12000004,0x10002004,0x12002004,
      0x10200004,0x12200004,0x10202004,0x12202004,
      0x10000400,0x12000400,0x10002400,0x12002400,
      0x10200400,0x12200400,0x10202400,0x12202400,
      0x10000404,0x12000404,0x10002404,0x12002404,
      0x10200404,0x12200404,0x10202404,0x12202404,
    },{
      /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
      0x00000000,0x00000001,0x00040000,0x00040001,
      0x01000000,0x01000001,0x01040000,0x01040001,
      0x00000002,0x00000003,0x00040002,0x00040003,
      0x01000002,0x01000003,0x01040002,0x01040003,
      0x00000200,0x00000201,0x00040200,0x00040201,
      0x01000200,0x01000201,0x01040200,0x01040201,
      0x00000202,0x00000203,0x00040202,0x00040203,
      0x01000202,0x01000203,0x01040202,0x01040203,
      0x08000000,0x08000001,0x08040000,0x08040001,
      0x09000000,0x09000001,0x09040000,0x09040001,
      0x08000002,0x08000003,0x08040002,0x08040003,
      0x09000002,0x09000003,0x09040002,0x09040003,
      0x08000200,0x08000201,0x08040200,0x08040201,
      0x09000200,0x09000201,0x09040200,0x09040201,
      0x08000202,0x08000203,0x08040202,0x08040203,
      0x09000202,0x09000203,0x09040202,0x09040203,
    },{
      /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
      0x00000000,0x00100000,0x00000100,0x00100100,
      0x00000008,0x00100008,0x00000108,0x00100108,
      0x00001000,0x00101000,0x00001100,0x00101100,
      0x00001008,0x00101008,0x00001108,0x00101108,
      0x04000000,0x04100000,0x04000100,0x04100100,
      0x04000008,0x04100008,0x04000108,0x04100108,
      0x04001000,0x04101000,0x04001100,0x04101100,
      0x04001008,0x04101008,0x04001108,0x04101108,
      0x00020000,0x00120000,0x00020100,0x00120100,
      0x00020008,0x00120008,0x00020108,0x00120108,
      0x00021000,0x00121000,0x00021100,0x00121100,
      0x00021008,0x00121008,0x00021108,0x00121108,
      0x04020000,0x04120000,0x04020100,0x04120100,
      0x04020008,0x04120008,0x04020108,0x04120108,
      0x04021000,0x04121000,0x04021100,0x04121100,
      0x04021008,0x04121008,0x04021108,0x04121108,
    },{