DES转

package des;

/**
 * 加密过程：
 *  1.初始置换IP：将明文顺序打乱重新排列，置换输出为64位。
 *  2.将置换输出的64位明文分成左右凉拌，左一半为L0，右一半称为R0，各32位。
 *     3。计算函数的16轮迭代。 
 *      a）第一轮加密迭代：左半边输入L0，右半边输入R0：由轮函数f实现子密钥K1对R0的加密，
 *           结果为32位数据组f(R0,K1), 
 *     b)第二轮加密迭代：左半边输入L1=R0，右半边输入R1=L0⊕f(R0,K1),由轮函数f实现子密钥
 *        K2对R1的加密，结果为32位数据组f(R1，K2)，f(R1,K2)与L1模2相加，得到一个32为数据组 L1⊕f(R1,K2).
 *      c)第3到16轮迭代分别用密钥K3，K4……K16进行。 4.再经过逆初始置换IP-1，将数据打乱重排，生成64位密文。
 * 
 * 子密钥生成过程：
 *     1.将64位的密钥经过PC-1置换生成56位密钥。
 *     2.将56位的密钥分成左右两部分，分别进行移位操作（一共进行16轮），产生16个56位长度的子密钥。
 *     3.将16个56位的子密钥分别进行PC-2置换生成16个48位的子密钥。
 * 
 * 轮函数f的工作过程： 
 *     1.在第i次加密迭代过程中，扩展置换E对32位的Ri-1的各位通过置换表置换为48位的输出。
 *     2.将该48位的输出与子密钥Ki进行异或操作，运算结果经过S盒代换运算，得到一个32位比特的输出。
 *     3。该32位比特输出再经过P置换表进行P运算，将其各位打乱重排，生成32位的输出。
 * 
 * @author Ouyang
 * 
 */
public class Des {
    int[] byteKey;
    
    
    public Des(int[] byteKey) {
        this.byteKey = byteKey;
    }

    private static final int[] IP = { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52,
            44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48,
            40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35,
            27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31,
            23, 15, 7 }; // 64
    private static final int[] IP_1 = { 40, 8, 48, 16, 56, 24, 64, 32, 39, 7,
            47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45,
            13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11,
            51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49,
            17, 57, 25 }; // 64
    private static final int[] PC_1 = { 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 }; // 56
    private static final int[] PC_2 = { 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 }; // 48
    private static final int[] E = { 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9,
            10, 11, 12, 13, 12, 13, 14, 15, 16, 17, 16, 17, 18, 19, 20, 21, 20,
            21, 22, 23, 24, 25, 24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1 }; // 48
    private static final int[] P = { 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23,
            26, 5, 18, 31, 10, 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22,
            11, 4, 25 }; // 32
    private static final int[][][] S_Box = {// S-盒
            {// S_Box[1]
            { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
                    { 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
                    { 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
                    { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 } },
            { // S_Box[2]
            { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
                    { 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
                    { 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
                    { 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 } },
            { // S_Box[3]
            { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
                    { 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
                    { 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
                    { 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 } },
            { // S_Box[4]
            { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
                    { 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },
                    { 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
                    { 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 } },
            { // S_Box[5]
            { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
                    { 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
                    { 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
                    { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 } },
            { // S_Box[6]
            { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
                    { 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
                    { 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
                    { 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 } },
            { // S_Box[7]
            { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
                    { 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
                    { 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
                    { 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 } },
            { // S_Box[8]
            { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
                    { 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
                    { 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
                    { 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } } };
    private static final int[] LeftMove = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2,
            2, 2, 2, 1 };

    /**
     * 对64位明文进行IP置换处理，
     * @param data 需要经过初始IP置换的明文
     * @return 64位经过置换处理的明文
     */
    public int[] IpReplace(int[] data){
        int[] ipMingWen = new int[64];
        for (int i = 0; i < ipMingWen.length; i++) {
            ipMingWen[i] = data[IP[i]-1];
        }
        return ipMingWen;
    }
    
    public static int[] StringToBits(String data){
        byte[] test = data.getBytes();
        int[] IntVa = new int[64];
        int[] IntDa = new int[8];
        for (int i = 0; i < 8; i++) {
            IntDa[i] = test[i];
            if (IntDa[i] < 0) {
                IntDa[i] += 256;
                IntDa[i] %= 256;
            }
        }
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                IntVa[((i * 8) + 7) - j] = IntDa[i] % 2;
                IntDa[i] = IntDa[i] / 2;
            }
        }
        return IntVa;
    }
    
    /**
     * 功能：对给定的数组按照offset指定的位数进行循环左移，输出经过左移后的数组
     * 作用：将经过pc-1置换处理后的56位密钥先分成左右各28位，然后根据左移表要求对密钥进行左移
     * @param key 经过pc-1处理后的56位密钥
     * @return 单个56位的子密钥（初步，未经过pc2置换）
     */
    public int[] LeftMove(int[] key,int offset){
        int[] subKey = new int[56];
        int[] C0 = new int[28];
        int[] D0 = new int[28];
        int[] C1 = new int[28];
        int[] D1 = new int[28];
        for (int i = 0; i < 28; i++) {
            C0[i] = key[i];
            D0[i] = key[i+28];
        }
        if(offset == 1){
            for(int i = 0; i < 27;i++){
                C1[i] = C0[i+1];
                D1[i] = D0[i+1];
            }
            C1[27] = C0[0];
            D1[27] = D0[0];
        }else if(offset == 2){
            for (int i = 0; i < 26; i++) {
                C1[i] = C0[i+2];
                D1[i] = D0[i+2];
            }
            C1[26] = C0[0];
            D1[26] = D0[0];
            C1[27] = C0[1];
            D1[27] = D0[1];
        }
        for (int i = 0; i < 28; i++) {
            subKey[i] = C1[i];
            subKey[i+28] = D1[i];
        }
        return subKey;
    }
    
    /**
     * 根据经过PC-1置换后的56位密钥生成16个56位的子密钥。再经过PC-2置换生成16个48位的子密钥
     * @param key 经过pc-1置换后的56位密钥
     * @return 处理完全的16个48位子密钥(以二维数组的形式存储)
     */
    public int[][] SubKeyGenerate(int[] key){
        int[][] subKeyArrayTemp = new int[16][56];
        int[][] subKey = new int[16][48];
        int[] K0 = new int[56];// 特别注意：xxx[IP[i]-1]等类似变换
        
        //对64位的密钥进行pc-1置换变成56位的密钥
        for (int i = 0; i < 56; i++) {
            K0[i] = key[PC_1[i] - 1]; // 密钥进行PC-1变换
        }
        
    
        //由经过pc-1置换生成的56位密钥经过16轮左移，pc-2置换等操作生成16个48位的子密钥
        for (int i = 0; i < 16; i++) {
            subKeyArrayTemp[i] = LeftMove(K0,LeftMove[i]);
            System.arraycopy(subKeyArrayTemp[i],0 , K0, 0, 56);
        }
        for (int i = 0; i < 16; i++) {
            for (int j = 0; j < 48; j++) {
                subKey[i][j] = subKeyArrayTemp[i][PC_2[j]-1];
            }
            
        }
        return subKey;
    }

    /**
     * 对64位明文右半部分（32位）进行扩展，以进行与子密钥异或的操作
     * @param data    32位的经过处理的明文
     * @return    扩展后的48位明文
     */
    public int[] EExpend(int[] data){
        int[] dataExpend = new int[48];
        for (int i = 0; i < dataExpend.length; i++) {
            dataExpend[i] = data[E[i]-1];
        }
        return dataExpend;
    }
    
    /**
     * 对输入的数据进行按位异或操作后输出，主要用在为明文右半部分（48位）和子密钥（48）异或，
     * 经过S盒代换后的f函数输出（32位）与明文左半部分（32位）的异或操作
     * @param data 48位的明文部分
     * @param key 48位的子密钥
     * @return 48位进过异或操作的输出
     */
    public int[] XOR(int[] data1,int[] data2){
        int[] XORResult = new int[data1.length];
        for (int i = 0; i < data1.length; i++) {
            XORResult[i] = data1[i]+data2[i];
            if(XORResult[i] == 2){
                XORResult[i] = 0;
            }
        }
        return XORResult;
    }
    
    /**
     * 将48位的经过异或处理的明密文进行S盒代换，然后对产生的32位中间结果进行P代换
     * @param temp 48位的经过异或处理的中间结果
     * @return 32位的经过S盒代换和P置换后的中间结果
     */
    public static int[] SBoxReplace(int[] temp){
        int[] sBoxResult = new int[32];//存储经过S盒代换的32位二进制处理中间结果
        int[] pReplaceResult = new int[32];//存储经过S盒代换和P代换的32位的F函数处理结果
        int[][] tempArray = new int[8][6];
        int[] tempRowTemp = new int[8];
        int roundCount = temp.length/6;
        //将48位的经过异或处理的中间结果以6个为一组（共分成8组）存储在二维数组中
        for (int i = 0; i < roundCount; i++) {
            for (int j = 0; j < 6; j++) {
                tempArray[i][j] = temp[(i*6)+j];
            }
            //将分成的8组（每组6个）数据根据S盒代换规则对每组6个数据进行拆分并进行S盒代换
            tempRowTemp[i]=S_Box[i][(tempArray[i][0]<<1)+(tempArray[i][5])]
                    [(tempArray[i][1]<<3)+(tempArray[i][2]<<2)+(tempArray[i][3]<<1)+(tempArray[i][4])];
        
            //将生成的8个数（每个都是经过S盒代换后的十进制数）转换成二进制数，并按顺序存储到结果数组中
            for (int j = 0; j < 4; j++) {
                sBoxResult[(i*4+3)-j]=tempRowTemp[i]%2;
                tempRowTemp[i] = tempRowTemp[i]/2;
            }
        }
        for (int i = 0; i < 32; i++) {
            pReplaceResult[i] = sBoxResult[P[i]-1];
        }
        return pReplaceResult;
    }
    
    public int[] Ip1Replace(int[] data){
        int[] ipMingWen = new int[64];
        for (int i = 0; i < ipMingWen.length; i++) {
            ipMingWen[i] = data[IP_1[i]-1];
        }
        return ipMingWen;
    }
    /**
     * 实现加密和解密工作
     * 
     * @param data
     * @param key2
     * @param flag
     * @return
     */
    public int[] EnAndDecrypt(int[] data, int flag) {
        int[] mingwen = IpReplace(data);
        int[] mingwenTemp = new int[64];
        int[] miwen = IpReplace(data);
        int[] miwenTemp = new int[64];
        int[][] keyArray = SubKeyGenerate(byteKey);
        int[] temp = new int[48];
        int[] tempSBox = new int[32];
        int[] L0 = new int[32];
        int[] R0 = new int[32];
        int[] L1 = new int[32];
        int[] R1 = new int[32];
        int[] ER0 = new int[48];
        if(1 == flag){
            System.arraycopy(mingwen, 0, L0, 0, 32);
            System.arraycopy(mingwen, 32, R0, 0, 32);
        
            for (int i = 0; i < 16; i++) {
                System.arraycopy(R0, 0, L1, 0, 32);
                ER0 = EExpend(R0);
                temp = XOR(ER0,keyArray[i]);
                tempSBox = SBoxReplace(temp);
                R1 = XOR(L0,tempSBox);
                System.arraycopy(L1, 0, L0, 0, 32);
                System.arraycopy(R1, 0, R0, 0, 32);
            }
            for (int i = 0; i < 32; i++) {
                mingwenTemp[i] = R1[i];
                mingwenTemp[i+32] = L1[i];
            }
            mingwen = Ip1Replace(mingwenTemp);
        }else if(0 == flag){
            System.arraycopy(mingwen, 0, L0, 0, 32);
            System.arraycopy(mingwen, 32, R0, 0, 32);
            for (int i = 0; i < 16; i++) {
                System.arraycopy(R0, 0, L1, 0, 32);
                ER0 = EExpend(R0);
                temp = XOR(ER0,keyArray[15 - i]);
                tempSBox = SBoxReplace(temp);
                R1 = XOR(L0,tempSBox);
                System.arraycopy(L1, 0, L0, 0, 32);
                System.arraycopy(R1, 0, R0, 0, 32);
            }
            for (int i = 0; i < 32; i++) {
                miwenTemp[i] = R1[i];
                miwenTemp[i+32] = L1[i];
            }
            miwen = Ip1Replace(miwenTemp);
        }
        
        return (flag==1) ? mingwen : miwen;

    }

    public static void main(String[] args) {
        String dataString = "10101001";
        System.out.println("明文为："+dataString);
        int[] data = StringToBits(dataString);
        //测试用
//        int[] data = {0,0,0,0,0,0,0,1,
//                      0,0,1,0,0,0,1,1,
//                      0,1,0,0,0,1,0,1,
//                      0,1,1,0,0,1,1,1,
//                      1,0,0,0,1,0,0,1,
//                      1,0,1,0,1,0,1,1,
//                      1,1,0,0,1,1,0,1,
//                      1,1,1,0,1,1,1,1};
        System.out.println("明文的二进制表示为：");
        for (int i = 0; i < 64; i++) {
            System.out.print(data[i]);
        }
        System.out.println();
        String keyString = "10101010";
        System.out.println("密钥为："+keyString);
        int[] key = StringToBits(dataString);
        //测试用
//        int[] key = {0,0,0,1,0,0,1,1,
//                     0,0,1,1,0,1,0,0,
//                     0,1,0,1,0,1,1,1,
//                     0,1,1,1,1,0,0,1,
//                     1,0,0,1,1,0,1,1,
//                     1,0,1,1,1,1,0,0,
//                     1,1,0,1,1,1,1,1,
//                     1,1,1,1,0,0,0,1};
        System.out.println("密钥的二进制表示为：");
        for (int i = 0; i < 64; i++) {
            System.out.print(key[i]);
        }
        System.out.println();
        Des des = new Des(key);
        int[] result = des.EnAndDecrypt(data, 1);
        System.out.print("加密后的密文的二进制为：");
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i]);
        }
        System.out.println();
        
        int[] testResult = des.EnAndDecrypt(result, 0);
        System.out.print("还原为明文为：");
        for (int i = 0; i < testResult.length; i++) {
            System.out.print(testResult[i]);
        }

    }
}