secretkey_des.java

JAVA语言编写的用于DES/3DES算法加密与解密的程序

package Security_DES;

import java.io.*;
import java.math.*;

//生成子密钥类
public class secretKey_DES{

private char[][] CD;                                            //经PC1压缩转换后的56bit密钥
private char[][] Ci;                              //56bit密钥的左28bit部分
private char[][] Di;                              //56bit密钥的右28bit部分
protected char[][] subKey;                                        //最后生成的48bit子密钥
private final byte[] index = new byte[]{57,49,41,33,25,17, 9, 1,
                                           58,50,42,34,26,18,10, 2,
                                           59,51,43,35,27,19,11, 3,
                                           60,52,44,36,63,55,47,39,
                                           31,23,15, 7,62,54,46,38,
                                           30,22,14, 6,61,53,45,37,
                                           29,21,13, 5,28,20,12, 4 };     //56bit密钥初始置换算法

private final byte[] count = new byte[]{ 1,1,2,2,2,2,2,2,
                                            1,2,2,2,2,2,2,1 };             //16轮左移的移位数
  
private final byte[] keyIndex = new byte[]{14,17,11,24, 1, 5, 3,28,
                                              15, 6,21,10,23,19,12, 4,
                                              26, 8,16, 7,27,20,13, 2,
                                              41,52,31,37,47,55,30,40, 
                                              51,45,33,48,44,49,39,56, 
                                              34,53,46,42,50,36,29,32 };    //生成48bit子密钥算法
private String Algorithm;                                          //加密算法选择: ?DES:3DES
protected int keyNum;                                             //表示有多少个密钥,DES时值为1,3DES时两个密钥值为2、三个密钥值为3
private char[] key56 = new char[56];

//处理密钥输入为字节类型与选择算法
protected secretKey_DES(byte[] key,String Algorithm){
  this.Algorithm = Algorithm;
  binaryHandle(key);
  PC2_Exchange();
}

//处理密钥输入为字节类型与选择算法
protected secretKey_DES(String key,String Algorithm){
  this.Algorithm = Algorithm;
  byte[] b = key.getBytes();
  binaryHandle(b);
  PC2_Exchange();
}

//处理字节类型密钥转换为二进制类型
private void binaryHandle(byte[] key){
  BigInteger bi = new BigInteger(key);      //二进制补码表示形式的 byte 数组转换为 BigInteger
  String str = bi.toString(2);              //二进制的字符串表示形式,表示的形式为二进制补码表示,并且自动去除最前面的0位,必须作补位操作,以满足位数
  //System.out.println(str);
  if(bi.bitLength()<64)               //单个密钥的长度不够64位时,前面补"0"       
  {
     for(int i=0;i<(64-bi.bitLength());i++)
     {
       str="0"+str;
      }
   }
  else if(bi.bitLength()>64&&bi.bitLength()<128)   //两个密钥的长度不够128位时,前面补"0"  
  {
     for(int i=0;i<(128-bi.bitLength());i++)
     {
       str="0"+str;
      }
   }
  else if(bi.bitLength()>128&&bi.bitLength()<192)  //三个密钥的长度不够192位时,前面补"0"  
  {
     for(int i=0;i<(192-bi.bitLength());i++)
     {
       str="0"+str;  
     }
   }
  char[] ch = str.toCharArray();                                       //存取对应于二进制"0"或"1"的字符数组
  PC1_Exchange(ch);
}

//初始置换64位密钥为56位密钥并分解成左28位和右28位两部分
private void PC1_Exchange(char[] cd){
  if(Algorithm.equals("DES")){                 //使用单个DES加密
    keyNum = 1;
    Ci = new char[1][28];
    Di = new char[1][28];
    CD = new char[1][56];                       //一个56位的压缩密钥
    subKey = new char[16][48];                   //16个48位的压缩子密钥
    
    //??以下两个for操作可以合为一个操作
    for(int i=0;i<56;i++){               //将一个64位原始密钥压缩成56位压缩密钥 
      CD[0][i] = cd[index[i]-1];
    }
    for(int k1=0;k1<56;k1++){                   //分解CD为Ci和Di两部分
      if(k1<28){                                  //存取左28位Ci
        Ci[0][k1] = CD[0][k1];
       }
      else{                                        //存取右28位Di
        Di[0][k1-28] = CD[0][k1];
      }
    }
  }
  else if(Algorithm.equals("3DES")){          //使用3DES加密
    if(cd.length == 128){                       // 只使用两个密钥加密
      keyNum = 2;
      Ci = new char[2][28];
      Di = new char[2][28];
      CD = new char[2][56];                       //两个56位的压缩密钥
      subKey = new char[32][48];                   //两个48位的压缩子密钥 
      for(int i=0;i<112;i++){
        if(i<=55){                                   //将前面64位压缩成第一个56位压缩密钥 
          CD[0][i] = cd[index[i]-1];
        }
        else{                                         //将后面64位压缩成第二个56位压缩密钥 
          CD[1][i-56] = cd[index[i-56]+63];
        }
      }
  }
  else if(cd.length == 192){                    //使用三个密钥加密
    keyNum = 3;
    Ci = new char[3][28];
    Di = new char[3][28];
    CD = new char[3][56];                         //三个56位的压缩密钥  
    subKey = new char[48][48];                     //三个48位的压缩子密钥
    for(int i=0;i<168;i++){                        //将前面64位压缩成第一个56位压缩密钥 
      if(i<=55){
        CD[0][i] = cd[index[i]-1];
      }
      else if(i>=112){                               //将后面64位压缩成第二个56位压缩密钥 
        CD[2][i-112] = cd[index[i-112]+127];
      }
      else{                                           //将中间64位压缩成第三个56位压缩密钥 
        CD[1][i-56] = cd[index[i-56]+63];
      }
    }
  }
  for(int t=0;t<CD.length;t++){
    for(int k2=0;k2<56;k2++){                   //分解CD为Ci和Di两部分
      if(k2<=27){                                  //存取左28位Ci
        Ci[t][k2] = CD[t][k2];
      }
      else{                                        //存取右28位Di
        Di[t][k2-28] = CD[t][k2];
      }
    }
  }
  }
}

//压缩置换生成48位子密码
private void PC2_Exchange(){
  char[] src;
  for(int i=0;i<keyNum;i++){
    for(int j=0;j<16;j++){
      src = leftMove(i,j);
      for(int k=0;k<48;k++){
        subKey[i*16+j][k] = src[keyIndex[k]-1];
        }
    }
  }
}

//处理密钥左右两部分的左移操作
private char[] leftMove(int i,int j){
  char c1,c2,d1,d2;
  if(count[j] == 1){
    c1 = Ci[i][0];
    d1 = Di[i][0];
    for(int l=0;l<27;l++){
      Ci[i][l] = Ci[i][l+1];
      Di[i][l] = Di[i][l+1];
    }
    Ci[i][27] = c1;
    Di[i][27] = d1;
  }
  else if(count[j] == 2){
    c1 = Ci[i][0];
    c2 = Ci[i][1];
    d1 = Di[i][0];
    d2 = Di[i][1];
    for(int l=0;l<26;l++){
      Ci[i][l] = Ci[i][l+2];
      Di[i][l] = Di[i][l+2];
    }
    Ci[i][26] = c1;
    Di[i][26] = d1;
    Ci[i][27] = c2;
    Di[i][27] = d2;
  }
  for(int n=0;n<56;n++){
    if(n<28){
      key56[n] = Ci[i][n];
    }
    else{
      key56[n] = Di[i][n-28];
    }
  }
  return key56;
}

}