SpringBoot + Vue 实现 AES 加密和 AES 工具类总结

白白白鲤鱼

于 2024-06-21 17:05:23 发布

阅读量1.1k

点赞数 23

分类专栏： Java后端文章标签： spring boot 后端 java 安全服务器 vue.js spring

本文链接：https://blog.csdn.net/weixin_49171365/article/details/138168468

版权

Java后端专栏收录该内容

50 篇文章 1 订阅

订阅专栏

一、加密知识回顾

AES加密模式

二、Java 自定义 AES 工具类

三、SpringBoot 实现 AES 加密登陆

一、加密知识回顾

密钥是AES算法实现加密和解密的根本。对称加密算法之所以对称，是因为这类算法对明文的加密和解密需要使用同一个密钥。
AES支持三种长度的密钥: 128位，192位，256位
平时大家所说的AES128，AES192，AES256，实际上就是指的AES算法对不同长度密钥的使用。从安全性来看，AES256 安全性最高。从性能来看，AES128 性能最高。本质原因是它们的加密处理轮数不同。

对称加密与非对称加密有什么区别，敏感数据怎么加解密和传输

AES加密模式

1 : ECB(Electronic Code Book电子密码本)模式
ECB模式是最早采用和最简单的模式，它将加密的数据分成若干组，每组的大小跟加密密钥长度相同，然后每组都用相同的密钥进行加密。

优点：1、简单；2：有利于并行计算；3、误差不会被传送；　
缺点：1、不能隐藏明文的模式；2、可能对明文进行主动攻击；
因此，此模式适于加密小消息。

2 : CBC(Cipher Block Chaining，加密块链)模式
优点：1、不容易主动攻击，安全性好于ECB，适合传输长度长的报文，是SSL、IPSec的标准。
缺点：1、不利于并行计算；2、误差传递；3、需要初始化向量IV

3 : CFB(Cipher FeedBack Mode，加密反馈)模式
优点：1、隐藏了明文模式；2、分组密码转化为流模式；3、可以及时加密传送小于分组的数据；
缺点：1、不利于并行计算；2、误差传送：一个明文单元损坏影响多个单元；3、唯一的IV；

4 : OFB(Output FeedBack，输出反馈)模式
优点：1、隐藏了明文模式；2、分组密码转化为流模式；3、可以及时加密传送小于分组的数据；
缺点：1、不利于并行计算；2、对明文的主动攻击是可能的；3、误差传送：一个明文单元损坏影响多个单元；

ECB 不够安全，只适合于短数据的加密，而 CBC 和 CFB 相较于 ECB 更加安全，因为前一个密文块会影响当前明文块，使攻击者难以预测密文的结构。总的来说，选择 AES 的算法模式需要根据加密需要的安全性和速度来进行选择，通常推荐使用CBC 或 CFB 模式，而不是 ECB 模式。

二、Java 自定义 AES 工具类

AES 算法在 Java 的 javax.crypto 包里有很好的封装，我们来看一下调用的方法:

public class AesSingleUtil {
    private static volatile AesSingleUtil aESUtil;
    private static String encodeRules = "9JLsB1ukY3o4mdTuuE90+Q==";

    private AesSingleUtil() {
    }

    public static AesSingleUtil getSingleton() {
        if (aESUtil == null) {
            Class var0 = AesSingleUtil.class;
            synchronized(AesSingleUtil.class) {
                if (aESUtil == null) {
                    aESUtil = new AesSingleUtil();
                }
            }
        }

        return aESUtil;
    }

    public String AESEncode(String content) throws Exception {
        KeyGenerator keygen = KeyGenerator.getInstance("AES");
        keygen.init(128, new SecureRandom(encodeRules.getBytes()));
        SecretKey original_key = keygen.generateKey();
        byte[] raw = original_key.getEncoded();
        SecretKey key = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(1, key);
        byte[] byte_encode = content.getBytes("utf-8");
        byte[] byte_AES = cipher.doFinal(byte_encode);
        String AES_encode = new String(Base64.getEncoder().encode(byte_AES));
        return AES_encode;
    }

    public String AESDecode(String content) throws Exception {
        KeyGenerator keygen = KeyGenerator.getInstance("AES");
        keygen.init(128, new SecureRandom(encodeRules.getBytes()));
        SecretKey original_key = keygen.generateKey();
        byte[] raw = original_key.getEncoded();
        SecretKey key = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(2, key);
        byte[] byte_content = Base64.getDecoder().decode(content);
        byte[] byte_decode = cipher.doFinal(byte_content);
        String AES_decode = new String(byte_decode, "utf-8");
        return AES_decode;
    }
}

AesSingleUtil 类：这是一个单例类，使用了双重检查锁（double-checked locking）实现按需延迟初始化。在 getSingleton 方法中，通过检查静态变量 aESUtil 是否为 null，来确定是否需要创建新的实例。通过单例模式确保了整个应用程序中只有一个实例存在，节省了资源并避免了不必要的重复创建对象。

encodeRules 变量：存储着用于生成 AES 密钥的编码规则。

AESEncode 方法：接受一个字符串作为参数，使用该字符串作为密钥的种子，生成 AES 密钥，并对输入的内容进行 AES 加密，最终返回 Base64 编码的加密结果。

AESDecode 方法：与 AESEncode 方法相对应，接受一个经过 Base64 编码的加密字符串作为参数，使用同样的密钥规则生成 AES 密钥，并对传入的加密字符串进行 AES 解密，返回解密后的原始字符串。

import com.ss.check.NotNullCheck;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AesWebUtil {
    private static Logger log = LoggerFactory.getLogger(AesWebUtil.class);
    private static String KEY = "kl9o56u98gvjhw9i";
    private static String IV = "grjei564389tj843";

    public AesWebUtil() {
    }

    public String encrypt(String data, String key, String iv) {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            int blockSize = cipher.getBlockSize();
            byte[] dataBytes = data.getBytes("UTF-8");
            int plaintextLength = dataBytes.length;
            if (plaintextLength % blockSize != 0) {
                plaintextLength += blockSize - plaintextLength % blockSize;
            }

            byte[] plaintext = new byte[plaintextLength];
            System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
            cipher.init(1, keyspec, ivspec);
            byte[] encrypted = cipher.doFinal(plaintext);
            return (new Base64()).encodeToString(encrypted);
        } catch (Exception var12) {
            return null;
        }
    }

    public String desEncrypt(String data, String key, String iv) {
        try {
            byte[] encrypted1 = (new Base64()).decode(data.getBytes("UTF-8"));
            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
            cipher.init(2, keyspec, ivspec);
            byte[] original = cipher.doFinal(encrypted1);
            String originalString = new String(original);
            return originalString;
        } catch (Exception var10) {
            return null;
        }
    }

    public static String jiaMi(String data) {
        String mm = "";

        try {
            if (NotNullCheck.str(data)) {
                mm = (new AesWebUtil()).encrypt(data, KEY, IV).trim();
            }
        } catch (Exception var3) {
        }

        return mm;
    }

    public static String jieMi(String data) {
        String mm = "";

        try {
            if (NotNullCheck.str(data)) {
                mm = (new AesWebUtil()).desEncrypt(data, KEY, IV).trim();
            }
        } catch (Exception var3) {
        }

        return mm;
    }

    public static void main(String[] args) throws Exception {
        String jiemi = (new AesWebUtil()).desEncrypt("oLlc7AJnsgl93vaAEYMgGd2/G8zLFX8HrCN9HaBwS9rLJYFT8+RmlReuNHHdX+NacpP6MAByLIdxSeMBQ/9a5HA1oikanQY5I1kTCxpaN639WvA/Rj8I74PicVYemYqiMr/W6dDwpyJt7H5jL7Sofw6bnNmQAtsF9UNQthDS73ddxo19ThLpxOajVE5LF+Mu", KEY, IV).trim();
        System.out.println("解密：" + jiemi);
        new AesWebUtil();
        String jiami = jiaMi("123456");
        System.out.println("加密：" + jiami);
    }
}