前后端分离加密通讯（AES）

前后端分离，使用加密算法传递敏感数据。前端使用js加解密，后端使用java加解密。

JAVA

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Objects;

/**
 * @author xiyanqiulvgui
 * @version 1.0.0
 * @date 2022/1/18 21:10
 * @Description 加解密工具
 */
public class CryptUtils {

    private final static String AES = "AES";
    private final static String ALG = "AES/ECB/PKCS5Padding";
    private final static String DEFAULT_KEY = "1234567890ABCDEF";
    private final static int DEFAULT_LENGTH = 16;

    /**
     * 加密算法
     *
     * @param content 加密内容
     * @param pw      盐值
     * @return 加密内容
     */
    public static String encrypt(String content, String pw) {
        return encrypt(content, pw, DEFAULT_LENGTH);
    }

    /**
     * 加密算法
     *
     * @param content 加密内容
     * @param pw      盐值
     * @param n       盐值长度
     * @return 加密内容
     */
    public static String encrypt(String content, String pw, int n) {
        pw = check(pw, n);
        try {
            KeyGenerator kgon = KeyGenerator.getInstance(AES);
            kgon.init(128);
            // 密码器
            Cipher cipher = Cipher.getInstance(ALG);
            // 初始化
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(pw.getBytes(), AES));
            byte[] bytes = cipher.doFinal(content.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解密
     *
     * @param encryptStr 需要解密的数据
     * @param key        解密需要的key
     * @return 解密后的数据
     */
    public static String decrypt(String encryptStr, String key) {
        return decrypt(encryptStr, key, DEFAULT_LENGTH);
    }

    /**
     * 解密
     *
     * @param encryptStr 需要解密的数据
     * @param key        解密需要的key
     * @param n          加密数据
     * @return 解密后的数据
     */
    public static String decrypt(String encryptStr, String key, int n) {
        key = check(key, n);
        try {
            Cipher cipher = Cipher.getInstance(ALG);
            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes(), AES));
            return new String(cipher.doFinal(Base64.getDecoder().decode(encryptStr)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 加密使用的盐主力
     *
     * @param key 加密盐值
     * @return 标准长度盐值
     */
    private static String chech(String key) {
        return check(key, DEFAULT_LENGTH);
    }

    /**
     * 加密使用的盐主力
     *
     * @param key 加密盐值
     * @param n   盐的长度，不能大于32
     * @return 标准长度盐值
     */
    private static String check(String key, int n) {
        if (Objects.isNull(key)) {
            return DEFAULT_KEY;
        } else if (key.length() > n) {
            return key.substring(0, n);
        } else if (key.length() < n) {
            while (key.length() < n) {
                key += key;
            }
            return key.substring(0, n);
        }
        return key;
    }

}

前端

下载js

npm install crypto-js

import CryptoJs from 'crypto-js'

export default {
  encrypt ( word,  key , n=16){
    key = check(key, n)
    var k=CryptJS.enc.Utf8.parse(key)
    var srcs = CryptoJS.enc.Utf8.paes(word)
    var enc = CryptoJS.AES.encrypt(srcs, k, {
      mode: CryptoJS.mode.ECB,
      padding: CryptoJS.pad.Pkcs7
      })
    return enc.toString()
}
}

decrypt(word, key, n){
key = check(key, n)
var k = CryptoJS.enc.Utf8.parse(key)
var dec = CryptoJS.AES.decrypt( word, k, {
m
}
}