对称加解密算法AES+加解密模式CBC+填充模式PKCS5

目录

参考文本

前言

AES简介

前端代码

后台代码

后台加密解密工具类代码

后台接收参数接口代码

---

参考文本

前端参考：

https://blog.csdn.net/z834410038/article/details/70231668

后端参考：

https://blog.csdn.net/aigoV/article/details/90374838

https://blog.csdn.net/huangxiaoguo1/article/details/78043169

前言

前段时间项目经常被攻击，有一种是请求被抓包并且修改了请求参数，为了解决这种问题，决定对请求参数进行加密，加密采用AES的CBC模式。对于加密之前没大接触过，AES的CBC模式是什么鬼？赶紧百度。下面是对AES加密的一点理解，直接复制来的。

AES简介

1、AES（Advanced Encryption Standard 高级加密标准）算法：

这是一种对称加密算法，强迫症一定要知道清楚啥对称加密，对称加密的意思是指，加密者和解密者用的是同一串秘钥。

2、128位加解密

这是在约定秘钥的长度，128位即128bit，AES的秘钥长度一般有：128bit、192bit、256bit。java 中，秘钥里的一个字符是一个字节（1byte），1byte=8bit。一个128位的秘钥，即由16个字符组成，如："aigov1266aba186k".

3、加解密模式CBC

AES有四种加解密模式：CBC、EBC、CFB、OFB ，我这次被要求用CBC模式，所以大概了解一下CBC。其他几个，咱也不懂，咱也不敢说。CBC模式下，加密时，是对明文进行分组加密的，每组大小一致，到最后一组时，可能长度不够，这个时候就需要填充到一样长度，就有了下面的填充模式。

4、填充模式

有两种填充模式：PKCS5Padding、PKCS7Padding 。这两种填充模式填充规则一样，区别在于，分组时，每组约定大小不一样。PKCS5Padding要求块（block）的大小是8位，PKCS7Padding则没有明确，范围在1-255之间。

5、Base64编码

Base64编码就是将数据编码成只用大小写字母，0-9数字，以及符号 + /等64个字符的String字符串，一般我们在网络中传输较长的数据时，会选中这种编码方式。

明文在经过加密后后变成一个无规则的二进制（二进制文件）byte数组，如：

 ajax无法接收二进制流文件，此时为了展示和传输，我们一般会约定使用Base64编码进行编码。将二进制byte数组进行base64编码后，就得到如下形式字符串：

项目采用的是将流转换为16进制的String字符串进行传递，直接贴代码

前端代码

前端引入crypto-js.js和aes.js

crypto-js.js下载链接：https://gitee.com/zhangfanhao/CSDN/blob/master/crypto-js.js

aes.js下载链接：https://gitee.com/zhangfanhao/CSDN/blob/master/aes.js

function supper() {

	var miyaokey = '后台代码加密解密类中main方法中将秘钥key转换为byte[],再转换为16进制的字符串的值';

	miyaokey = CryptoJS.enc.Hex.parse(miyaokey)

	iv = CryptoJS.enc.Hex.parse("后台代码加密解密类中main方法中将iv转换为byte[],再转换为16进制的字符串的值");

	var src = JSON.stringify({
		"accessToken": "",
		"obj": {
			"keyWord":$(".commodity-seek-inp").val(),
			"sortType": "2",//排序方式按佣金高低倒序
			"withCoupon": "true",//只查有优惠劵的
			"isBrandGoods": "false",//只查品牌商品
			"optId":""//商品的分类Id
		},
		"page": page,
		"pageSize": "",
		"msg": ""
	});

	var enc = CryptoJS.AES.encrypt(src, miyaokey, {

		iv: iv,

		mode: CryptoJS.mode.CBC,

		padding: CryptoJS.pad.Pkcs7

	})

	enced = enc.ciphertext.toString();

	$.ajax({

		type: "POST",

		url: "请求地址",

		dataType: "json", //表示返回值类型，不必须

		data: enced,

		success: function(res) {

		},

	});
}

后台代码

后台加密解密工具类代码

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class AES {

    private static String iv = "0123456789ABCDEF";//当模式是CBC的时候必须设置偏移量,偏移量字符串:自己随意定义，必须是16位 。
    private static String Algorithm = "AES";
    private static String AlgorithmProvider = "AES/CBC/PKCS5Padding"; //算法/模式/补码方式
	private static String jiaMiKey = "1234567890ABCDEF1234567890ABCDEf"; //加密解密的秘钥key:自己随意定义。长度为n/8。 n代表的是多少bit

    public static IvParameterSpec getIv() throws UnsupportedEncodingException {
        IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes("utf-8"));
        return ivParameterSpec;
    }

    public static byte[] encrypt(String src, byte[] key) throws NoSuchAlgorithmException, NoSuchPaddingException,
            InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
        SecretKey secretKey = new SecretKeySpec(key, Algorithm);
        IvParameterSpec ivParameterSpec = getIv();
        Cipher cipher = Cipher.getInstance(AlgorithmProvider);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
        byte[] cipherBytes = cipher.doFinal(src.getBytes(Charset.forName("utf-8")));
        return cipherBytes;
    }

    public static byte[] decrypt(String src, byte[] key) throws Exception {
        SecretKey secretKey = new SecretKeySpec(key, Algorithm);

        IvParameterSpec ivParameterSpec = getIv();
        Cipher cipher = Cipher.getInstance(AlgorithmProvider);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
        byte[] hexBytes = hexStringToBytes(src);
        byte[] plainBytes = cipher.doFinal(hexBytes);
        return plainBytes;
    }
    public static String toKeyCode(String src) {
        byte key[] = new byte[0];
        String to = null;
        try {
            key = jiaMiKey.getBytes("utf-8");
            to = new String(decrypt(src, key), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return to;
    }

    public static String deKeyCode(String src) {
        byte key[] = new byte[0];
        String to = null;
        try {
            key = jiaMiKey.getBytes("utf-8");
            to = byteToHexString(encrypt(src, key));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return to;
    }


    /**
     * 将byte转换为16进制字符串
     * @param src
     * @return
     */
    public static String byteToHexString(byte[] src) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xff;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                sb.append("0");
            }
            sb.append(hv);
        }
        return sb.toString();
    }

    /**
     * 将16进制字符串装换为byte数组
     * @param hexString
     * @return
     */
    public static byte[] hexStringToBytes(String hexString) {
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] b = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            b[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return b;
    }
    private static byte charToByte(char c) {
        return (byte) iv.indexOf(c);
    }

    public static void main(String[] args) {
        try {
            byte key[] = jiaMiKey.getBytes("utf-8");
            System.out.println(byteToHexString(key));//给前端的加密key
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        try {
            byte[] vi = iv.getBytes("utf-8");
            System.out.println(byteToHexString(vi));//给前端的iv
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

后台接收参数接口代码

@PostMapping("/searchGoods")
public ResultObjVO searchDuoDuoJinBaoGoods(HttpServletRequest req) throws IOException {
	String param = AES.toKeyCode(IOUtils.toString(req.getInputStream(), "UTF-8"));//IOUtils.toString(req.getInputStream(), "UTF-8")返回的是前端传过来加密的参数。
}