Java DES加密工具类 归档 DESUtil @杨章隐

des对称加密，是一种比较传统的加密方式，其加密运算、解密运算使用的是同样的密钥，信息的发送者和信息的接收者在进行信息的传输与处理时，必须共同持有该密码（称为对称密码），是一种对称加密算法。

数据加密法

数据加密算法（Data Encryption Algorithm，DEA）是一种对称加密算法，很可能是使用最广泛的密钥系统，特别是在保护金融数据的安全中，最初开发的DEA是嵌入硬件中的。通常，自动取款机（Automated Teller Machine，ATM）都使用DEA。它出自IBM的研究工作，IBM也曾对它拥有几年的专利权，但是在1983年已到期后，处于公有范围中，允许在特定条件下可以免除专利使用费而使用。1977年被美国政府正式采纳。

数据加密标准

DES的原始思想可以参照二战德国的恩格玛机，其基本思想大致相同。传统的密码加密都是由古代的循环移位思想而来，恩格玛机在这个基础之上进行了扩散模糊。但是本质原理都是一样的。现代DES在二进制级别做着同样的事：替代模糊，增加分析的难度。 [1]

加密原理

DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行“异或”运算；接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用 16 个循环，使用异或，置换，代换，移位操作四种基本运算。

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import lombok.extern.slf4j.Slf4j;
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: DESUtil  DES加密工具类
 * @Author Zing
 * @Date: 2022/4/14 16:33
 * @Version 1.0
 */
@Component
@Slf4j
public class DESUtil {

    private static String password = "";

    private static 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, String ivP) {
        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 org.apache.tomcat.util.codec.binary.Base64.encodeBase64String(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, String ivP) {
        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;
        }
    }
}

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=baazlu0myf0e