DES ECB加解密的Java实现

String miwen = "C4FC354A83E171F20DC0FCB10172A2DED3428CC8390EEA17"
            + "E8244A0A0C71705BA406FAFB279496D9ADE5BBB62905D8DF" 
            + "BED9CDF5BB33CA4264F36C82ABC4D69D2FE06145C2204902";

byte[] _miwen = hexString2Bytes(miwen);

byte[] decryResult = DES.decrypt(_miwen, password);
/**
     * 解密
     * 
     * @param src      byte[]
     * @param password String
     * @return byte[]
     * @throws Exception
     */
    public static byte[] decrypt(byte[] src, String password) throws Exception {
        // DES算法要求有一个可信任的随机数源
        SecureRandom random = new SecureRandom();
        // 创建一个DESKeySpec对象
        DESKeySpec desKey = new DESKeySpec((password.getBytes()));
        // 创建一个密匙工厂
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
// 将DESKeySpec对象转换成SecretKey对象
        SecretKey securekey = keyFactory.generateSecret(desKey);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        // 真正开始解密操作
        return cipher.doFinal(src);
    }

package com.trq.nengyuan;

import java.security.SecureRandom;

import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.SecretKeyFactory;
import javax.crypto.SecretKey;
import javax.crypto.Cipher;
import java.util.*;

/**
 * 注意：DES加密和解密过程中，密钥长度都必须是8的倍数
 */
public class DES {
    public DES() {
    }

    // 测试
    public static void main(String args[]) {
        // 待加密内容
        //String str = "0123456789";
        String strmingwen = "eb9100481380013800009c4a01000301010804050226c6cf7e0002b7000000000000295cef41711d4b4400000000000000000000000041008ec12d0e560440fc2db000000000ac6e";
        // 密码，长度要是8的倍数
        String password = "12345678";
        // 测试密文，长度要是8的倍数
//        String miwen = "C4FC354A83E171F20DC0FCB10172A2DED3428CC8390EEA17"
//                + "E8244A0A0C71705BA406FAFB279496D9ADE5BBB62905D8DF"
//                + "BED9CDF5BB33CA4264F36C82ABC4D69D2FE06145C2204902";

        // 在解密前，将字符串的密文转换成16进制的字节数组
//        byte[] _miwen = hexString2Bytes(miwen);
        try {
            // 1.明文 DES ECB加密测试
            // 在加密前，将需要加密的明文转换成16进制字节数组
            byte[] _mingwenTest = hexString2Bytes(strmingwen);
            // DES ECB加密
            byte[] encrptResult = DES.encrypt(_mingwenTest, password);
            System.out.println("--------------- DES ECB 加密测试 -----------------");
            System.out.println("加密前：----" + strmingwen);
//            System.out.println("加密后：----" + new String(encrptResult));
            System.out.println("加密后：----" + byteToHex(encrptResult));

            // 2.密文 DES ECB解密测试
            // 测试密文，长度要是8的倍数
            byte[] _miwen = encrptResult;
            System.out.println("--------------- DES ECB 解密测试 -----------------");
            System.out.println("解密前：----" + byteToHex(_miwen));
            // DES ECB解密
            byte[] decryResult = DES.decrypt(_miwen, password);
            // System.out.println("解密后：----" + new String(decryResult));
            System.out.println("解密后：----" + byteToHex(decryResult));
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }

    /**
     * 加密
     *
     * @param datasource byte[]
     * @param password   String
     * @return byte[]
     */
    public static byte[] encrypt(byte[] datasource, String password) {
        try {
            SecureRandom random = new SecureRandom();
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            // 创建一个密匙工厂，然后用它把DESKeySpec转换成
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            // Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
            // 用密匙初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
            // 现在，获取数据并加密
            // 正式执行加密操作
            return cipher.doFinal(addZero(datasource));
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解密
     *
     * @param src      byte[]
     * @param password String
     * @return byte[]
     * @throws Exception
     */
    public static byte[] decrypt(byte[] src, String password) throws Exception {
        // DES算法要求有一个可信任的随机数源
        SecureRandom random = new SecureRandom();
        // 创建一个DESKeySpec对象
        DESKeySpec desKey = new DESKeySpec((password.getBytes()));
        // 创建一个密匙工厂
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        // 将DESKeySpec对象转换成SecretKey对象
        SecretKey securekey = keyFactory.generateSecret(desKey);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        // 真正开始解密操作
        return cipher.doFinal(src);
    }

    public static byte[] getKey(byte[] keyRule) {
        SecretKeySpec key = null;
        byte[] keyByte = keyRule;
        System.out.println(keyByte.length);
        // 创建一个空的八位数组,默认情况下为0
        byte[] byteTemp = new byte[8];
        // 将用户指定的规则转换成八位数组
        int i = 0;
        for (; i < byteTemp.length && i < keyByte.length; i++) {
            byteTemp[i] = keyByte[i];
        }
        key = new SecretKeySpec(byteTemp, "DES");
        return key.getEncoded();
    }

    public static byte[] addZero(byte[] data) {
        byte[] dataByte = data;

        if (data.length % 8 != 0) {
            byte[] temp = new byte[8 - data.length % 8];
            dataByte = byteMerger(data, temp);
        }
        return dataByte;
    }

    // java 合并两个byte数组
    // System.arraycopy()方法
    public static byte[] byteMerger(byte[] bt1, byte[] bt2) {
        byte[] bt3 = new byte[bt1.length + bt2.length];
        System.arraycopy(bt1, 0, bt3, 0, bt1.length);
        System.arraycopy(bt2, 0, bt3, bt1.length, bt2.length);
        return bt3;
    }

    /**
     * byte数组转hex
     * @param bytes
     * @return
     */
    public static String byteToHex(byte[] bytes){
        String strHex = "";
        StringBuilder sb = new StringBuilder("");
        for (int n = 0; n < bytes.length; n++) {
            strHex = Integer.toHexString(bytes[n] & 0xFF);
            sb.append((strHex.length() == 1) ? "0" + strHex : strHex); // 每个字节由两个字符表示，位数不够，高位补0
        }
        return sb.toString().trim();
    }

    /**
     * @Title:hexString2Bytes
     * @Description:16进制字符串转字节数组
     * @param src
     * 16进制字符串
     * @return 字节数组
     * @throws
     */
    public static byte[] hexString2Bytes(String src) {
        int l = src.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            ret[i] = Integer.valueOf(src.substring(i * 2, i * 2 + 2), 16).byteValue();
        }
        return ret;
    }

}