java DES-CBC加解密

DES-CBC 加解密

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.SecureRandom;
import java.util.Arrays;

/**
 * @title: MyDESUtil  DES加密工具类
 * @Author Tan
 * @Date: 2022/4/14 16:33
 * @Version 1.0 
 */
@Component
@Slf4j
public class MyDESUtil {
    @Value("${des-cbc.pwd}")
    private String password;

    @Value("${des-cbc.ivParam}")
    private String ivParam;

    /**
     *  ECB加解密
     * @param encrypt true：加密；false：解密
     * @param desKey 密钥
     * @param data  待加/解密数据
     * @return  加/解密后结果
     */
    private static byte[] encryptOrDecrypt(boolean encrypt, byte[] desKey,
                                           byte[] data) {
        if (data == null || data.length <= 0) {
            return null;
        }

        try {
            Cipher cipher;
            SecureRandom sr = new SecureRandom();
            DESKeySpec dks = new DESKeySpec(desKey);
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey key = keyFactory.generateSecret(dks);
            if (encrypt) {
                cipher = Cipher.getInstance("DES");
                cipher.init(Cipher.ENCRYPT_MODE, key, sr);
            } else {
//				cipher = Cipher.getInstance("DES/ECB/NoPadding");
                cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
                cipher.init(Cipher.DECRYPT_MODE, key, sr);
            }

            return cipher.doFinal(data);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 生成KEY
     * @param password 密码
     * @return 生成的KEY
     * @throws Exception
     */
    private static Key generateKey(String password) throws Exception {
        DESKeySpec dks = new DESKeySpec(password.getBytes("utf-8"));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        return keyFactory.generateSecret(dks);
    }

    /**
     * Byte[]类型数据ECB加密
     * @param data 待加密的Byte类型数据
     * @param desKey 数据加密key
     * @return 加密后的数据
     * @throws Exception 数据加密异常
     */
    public static char[] encrypt(byte[] data, byte[] desKey) throws Exception {
        // return Base64.encode(encryptOrDecrypt(true, desKey, data));
        return new char[0];
    }

    /**
     * Byte[]类型数据ECB解密
     * @param data 待解密Byte类型数据
     * @param desKey 数据解密key
     * @return 解密后的数据
     * @throws Exception 数据解密异常
     */
    public static byte[] decrypt(char[] data, byte[] desKey) throws Exception {
        // TODO:luoshifei data.toString
        return encryptOrDecrypt(
                false,
                desKey,
                Base64.decode(Arrays.toString(data)));
    }

    /**
     * DES ECB加密
     * @param data 待加密的数据
     * @param key 密钥
     * @return 加密后的数据
     * @throws Exception 数据加密异常
     */
    public static String ecbEncrypt(String data, String key, String charset) throws Exception {

        byte[] bytes = encryptOrDecrypt(true,
                key.getBytes(Charset.forName(charset)),
                data.getBytes(Charset.forName(charset)));

        return new BASE64Encoder().encode(bytes);
    }

    /**
     * DES ECB解密
     * @param data 待加密数据
     * @param key 密钥
     * @return 解密后的数据
     * @throws Exception 数据解密异常
     */
    public static String ecbDecrypt(String data, String key, String charset) throws Exception {
        byte[] bytes = encryptOrDecrypt(false,
                key.getBytes(Charset.forName(charset)),
                new BASE64Decoder().decodeBuffer(data));

        return ( new String(bytes,"utf-8") );
    }


    /**
     * DES CBC 加密
     * @param data 待加密字符串
     * @param --password 加密密码，长度不能小于8位
     * @param --ivParam 偏移量
     * @return 加密后内容
     */
    public String cbcEncrypt(String data) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null) {
            return null;
        }
        try {
            Key secretKey = generateKey(password);
            Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            IvParameterSpec iv = new IvParameterSpec(ivParam.getBytes("utf-8"));
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
            byte[] encrypted = cipher.doFinal(data.getBytes("utf-8"));
            return new BASE64Encoder().encode(encrypted); //此处使用BASE64做转码功能，同时能起到2次加密的作用。
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }

    /**
     * DES CBC 解密
     * @param data 待解密字符串
     * @param --password 解密密码，长度不能小于8位
     * @param --ivParam 偏移量
     * @return 解密后内容
     */
    public  String cbcDecrypt(String data) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null) {
            return null;
        }
        try {
            Key secretKey = generateKey(password);
            Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            IvParameterSpec iv = new IvParameterSpec(ivParam.getBytes("utf-8"));
            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
            byte[] encrypted = new BASE64Decoder().decodeBuffer(data);//先用base64解密
            byte[] original = cipher.doFinal(encrypted);
            return  ( new String(original,"utf-8") );
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }


    /**
     * DES CBC 加密
     * @param data 待加密字符串
     * @param --password 加密密码，长度不能小于8位
     * @param --ivParam 偏移量
     * @return 加密后内容
     */
    public static String cbcStaticEncrypt(String data) {
        String pwd = "yj6kgf8h2jhda";
        String ivP = "bjkbkfss";
        if (pwd== null || pwd.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null) {
            return null;
        }
        try {
            Key secretKey = generateKey(pwd);
            Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            IvParameterSpec iv = new IvParameterSpec(ivP.getBytes("utf-8"));
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
            byte[] encrypted = cipher.doFinal(data.getBytes("utf-8"));
            return new BASE64Encoder().encode(encrypted); //此处使用BASE64做转码功能，同时能起到2次加密的作用。
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }

    /**
     * DES CBC 解密
     * @param data 待解密字符串
     * @param --password 解密密码，长度不能小于8位
     * @param --ivParam 偏移量
     * @return 解密后内容
     */
    public static String cbcStaticDecrypt(String data) {
        String pwd = "yj6klh4h2jhda";
        String ivP = "bjkbdffss";
        if (pwd== null || pwd.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null) {
            return null;
        }
        try {
            Key secretKey = generateKey(pwd);
            Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            IvParameterSpec iv = new IvParameterSpec(ivP.getBytes("utf-8"));
            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
            byte[] encrypted = new BASE64Decoder().decodeBuffer(data);//先用base64解密
            byte[] original = cipher.doFinal(encrypted);
            return  ( new String(original,"utf-8") );
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }


    public static void main(String[] args){
        String test = "410223199105418975_周杰伦";
//        String key ="yj6klh4h2jhda";
//        String iv ="bjkbdffss";
//        String ecbEncrypt = null;
//        String ecbDecrypt = null;
        String cbcEncrypt = null;
        String cbcDecrypt = null;
//        try {
//            ecbEncrypt = MyDESUtil.ecbEncrypt(test, key, "UTF-8");
//            ecbDecrypt = MyDESUtil.ecbDecrypt(ecbEncrypt, key, "UTF-8");
//            System.out.println("DES ECB加密结果: " + ecbEncrypt);
//            System.out.println("DES ECB解密结果: " + ecbDecrypt);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
        cbcEncrypt = MyDESUtil.cbcStaticEncrypt(test);
        cbcDecrypt = MyDESUtil.cbcStaticDecrypt(cbcEncrypt);

        System.out.println("DES CBC加密结果: " + cbcEncrypt);
        System.out.println("DES CBC解密结果: " + cbcDecrypt);
    }

}