还不会参数加密？快来学学AES加密的方法

已于 2024-04-25 18:22:46 修改
阅读量1.4k 收藏 12
点赞数 1
分类专栏： Java # SpringBoot 文章标签： java idea spring boot
于 2022-09-24 13:43:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HackAzrael/article/details/127022861
版权

AES实现后端参数加解密

前言

原文链接：教你如何使用 AES 加密接口参数

在实际工作中为了安全，会将参数进行密文传输，这里使用的是 AES + ECB + BASE64 对称加密的加密方式，在此记录并学习一下，技术不精望大家谅解。

介绍

AES加密是一种对称加密，有对称加密自然也有非对称加密。

对称加密
对称加密是一种简单快速的加密方式，它在加密和解密的时候使用的密钥是同一个，并且通常不会超过256bit，密钥越小，在加解密的时候耗时越短，但是同样的，对于数据的加密会稍弱一些。本文使用的加密方式正是对称加密

非对称加密
非对称加密提供了一种更为安全的加解密解决方案，它使用了一对密钥，也就是一个公钥和一个私钥。在加密的时候使用公钥加密，且公钥可以发给任何请求的人，而解密的时候则需要使用私钥去解密。但是相应的，加解密的速度会稍慢。

总结来说：
对称加密的速度更快，但密钥传输相对麻烦，且加密稍弱，有泄露风险；
非对称加密的安全性更高，加密方式较强，密钥传输简单，但加密速度较慢，几乎没有泄露风险，适合偶尔传输数据的请求。

Start

引入依赖

使用之前要先引入此依赖

		<dependency>
            <groupId>org.apache.directory.studio</groupId>
            <artifactId>org.apache.commons.codec</artifactId>
            <version>1.8</version>
        </dependency>

编写AES加解密工具类

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.util.JSONPObject;
import org.apache.commons.codec.binary.Base64;

import java.util.HashMap;
import java.util.Map;

public class AesEncryptUtils {
    //密钥 16位 可自定义
    //注意：此处的密钥要与前端一致，否则会导致解密失败
    private static final String KEY = "Mh82Pw93Q0ePaz5";

    //算法名称/加密模式/数据填充方式
    //注意： 加密方式与数据填充方式要与前端对应，否则会加密失败
    //这里使用的是ECB加密方式，数据填充使用的是PKCS5
    private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";

    /**
     * 加密
     * @param content 加密的字符串
     * @param encryptKey key值
     * @return
     * @throws Exception
     */
    public static String encrypt(String content, String encryptKey) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        kgen.init(128);
        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes(), "AES"));
        byte[] b = cipher.doFinal(content.getBytes("utf-8"));
        // 采用base64算法进行转码,避免出现中文乱码
        return Base64.encodeBase64String(b);

    }

    /**
     * 解密
     * @param encryptStr 解密的字符串
     * @param decryptKey 解密的key值
     * @return
     * @throws Exception
     */
    public static String decrypt(String encryptStr, String decryptKey) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        kgen.init(128);
        // 根据算法名称/加密方式/填充方式初始化加密
        Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes(), "AES"));
        // 采用base64算法进行转码,避免出现中文乱码
        byte[] encryptBytes = Base64.decodeBase64(encryptStr);
        byte[] decryptBytes = cipher.doFinal(encryptBytes);
        return new String(decryptBytes);
    }

    public static String encrypt(String content) throws Exception {
        return encrypt(content, KEY);
    }
    public static String decrypt(String encryptStr) throws Exception {
        return decrypt(encryptStr, KEY);
    }
}

以上则是AES用来加解密的工具类，可写个单元测试或写个main方法来测试是否可以正常加解密成功。

自定义注解

该注解可用于方法上，对需要加密的接口进行粒子化控制

import org.springframework.web.bind.annotation.Mapping;
import java.lang.annotation.*;

/**
 * 出入参加解密
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Mapping
@Documented
public @interface AES {

    /**
     * 入参是否解密，默认解密
     */
    boolean inDecode() default true;

    /**
     * 出参是否加密，默认加密
     */
    boolean outEncode() default true;
}

编写请求数据解密 ControllerAdvice

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;

/**
 * 请求数据解密
 */
@ControllerAdvice(basePackages = "com.xxx.controller")
public class DecodeRequestBodyAdvice implements RequestBodyAdvice {

    private static final Logger logger = LoggerFactory.getLogger(DecodeRequestBodyAdvice.class);

    @Override
    public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return body;
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) throws IOException {
        try {
            boolean encode = false;
            if (methodParameter.getMethod().isAnnotationPresent(SecurityParameter.class)) {
                //获取注解配置的包含和去除字段
                SecurityParameter serializedField = methodParameter.getMethodAnnotation(SecurityParameter.class);
                //入参是否需要解密
                encode = serializedField.inDecode();
            }
            if (encode) {
                logger.info("对方法method :【" + methodParameter.getMethod().getName() + "】返回数据进行解密");
                return new MyHttpInputMessage(inputMessage);
            } else {
                return inputMessage;
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("对方法method :【" + methodParameter.getMethod().getName() + "】返回数据进行解密出现异常：" + e.getMessage());
            return inputMessage;
        }
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
        return body;
    }

    class MyHttpInputMessage implements HttpInputMessage {
        private HttpHeaders headers;

        private InputStream body;

        public MyHttpInputMessage(HttpInputMessage inputMessage) throws Exception {
            this.headers = inputMessage.getHeaders();
            String requestData = IOUtils.toString(inputMessage.getBody(), "UTF-8");
            //去除请求数据中的转义字符
            String encryptStr = easpString(requestData).replace("\"", "");
            String decrypt = AesEncryptUtils.decrypt(encryptStr);
            this.body = IOUtils.toInputStream(decrypt, "UTF-8");
        }

        @Override
        public InputStream getBody() throws IOException {
            return body;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }

        /**
         * @param requestData
         * @return
         */
        public String easpString(String requestData) {
            if (requestData != null && !requestData.equals("")) {
                String s = "{\"requestData\":";
                //去除requestData中的转义字符
                String data = requestData.replaceAll("\\s*|\r|\n|\t", "");
                if (!data.startsWith(s)) {
                    throw new RuntimeException("参数【requestData】缺失异常！");
                } else {
                    int closeLen = data.length() - 1;
                    int openLen = "{\"requestData\":".length();
                    String substring = StringUtils.substring(data, openLen, closeLen);
                    return substring;
                }
            }
            return "";
        }
    }
}

编写返回数据加密 ControllerAdvice

import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

/**
 * 返回数据加密
 */
@ControllerAdvice(basePackages = "com.xxx.controller")
public class EncodeResponseBodyAdvice implements ResponseBodyAdvice {

    private final static Logger logger = LoggerFactory.getLogger(EncodeResponseBodyAdvice.class);

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body,
                                  MethodParameter methodParameter,
                                  MediaType mediaType,
                                  Class aClass,
                                  ServerHttpRequest serverHttpRequest,
                                  ServerHttpResponse serverHttpResponse) {
        boolean encode = false;
        if (methodParameter.getMethod().isAnnotationPresent(SecurityParameter.class)) {
            //获取注解配置的包含和去除字段
            SecurityParameter serializedField = methodParameter.getMethodAnnotation(SecurityParameter.class);
            //出参是否需要加密
            encode = serializedField.outEncode();
        }
        if (encode) {
            logger.info("对方法method :【" + methodParameter.getMethod().getName() + "】返回数据进行加密");
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                String result = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(body);
                return AesEncryptUtils.encrypt(result);
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("对方法method :【" + methodParameter.getMethod().getName() + "】返回数据进行解密出现异常：" + e.getMessage());
            }
        }
        return body;
    }
}

测试

此时我们已经编写完所有代码，我们来写一个测试类来测试加解密是否正常

interface-test
我们写了两个接口，getSecret是获取返回内容的密文，getBySecret是解析密文
此时我们使用postman来测试一下接口

getSecret

postman-getSecret
可以看到我们可以正常获取到密文，那我们使用这个密文来调用另外一个接口看是否能正确解析出密文内容

getBySecret

postman-getBySecret
可以看到密文已经被成功解析出来了，同时也是我们加密前的内容。
自此我们的加解密就全部结束啦，如果想要出参加密、入参解密的话直接加上注解，不带属性即可

注意：此处后端使用的是加密名为AES，加密方式为ECB，数据填充格式为PKCS5Padding。前后端一定要完全一致，否则会导致前后端解密失败

图表

为了便于大家理解，在这里做了两个图表参考

时序图

前端 后端 DecodeRequestBodyAdvice 业务处理 EncodeResponseBodyAdvice 发送加密数据 解密 解密后的参数 加密返回信息 返回加密信息 前端 后端 DecodeRequestBodyAdvice 业务处理 EncodeResponseBodyAdvice

流程图

发送加密信息
是
否
解密
是
否
加密
前端
后端
是否开启解密
DecodeRequestBodyAdvice
业务处理
是否开启加密
EncodeResponseBodyAdvice

推荐

关注博客和公众号获取最新文章

Bummon’s Blog ｜ Bummon’s Home ｜ 公众号

Bummon.
关注
专栏目录
24丨想学华为？不妨先学学都江堰
06-08
24丨想学华为？不妨先学学都江堰
学习加密(二)Spring Boot 使用AES对称加密,前后端传递参数加解密
街角有人祝福,巷口有人哭~
10-25 3万+
前言: 1.最近要做一个安全性稍微高一点的项目,首先就想到了要对参数加密,和采用https协议. 2.以前对加密这块不了解,查阅了很多资料,加密方式很多种,但是大概区分两种,一个就是对称加密(DES,3DES,AES,IDEA等),另外一个就是非对称加密(RSA,Elgamal,背包算法,Rabin,D-H等) 3.这两种区别还是有的,粗浅的说: (1)对称加密方式效率高,但是有泄露风险 ...
AES加密
m0_74422124的博客
03-17 2996
AES属于分组加密算法，，每组长度相等，每次加密一组数据，直到加密完整个明文，明文长度固定为128位，密钥长度可以是128（10轮循环）、192（12轮循环）、256位（14轮循环）。明文P需要分组，称为状态，状态用以字节为元素的矩阵阵列表示，16字节明文按照此顺序放入矩阵，规则为：从上到下，从左到右，依次进行。密钥K也需要分组，原理与明文P相同。（1）明文P：没有经过加密的数据。（2）密钥K：用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。
AES 加密算法原理详解及实现
兴趣是最好的老师，勤能补拙
06-16 1万+
随着互联网的发展，越来越多的数据需要在网络中进行传输。为了保证数据的安全性，在进行网络传输时，需要对数据进行加密操作，使得数据在传输过程中不被窃取或篡改。AES（Advanced Encryption Standard）就是一种经典的加密算法。AES 算法源于比利时密码学家 Joan Daemen 和 Vincent Rijmen，它是一种对称加密算法，通过使用相同的密钥对数据进行加密和解密操作。AES 算法中，加密和解密操作是相反的过程，因此需要使用相同的密钥作为加密和解密的关键参数。
AES加密——AES加密原理与C++实现AES加密
知来者逆的博客
03-09 8174
AES-256 密钥长度为 256 位，提供了极高的安全性。由于其密钥长度更长，因此具有更大的密钥空间，从而增加了破解的难度，即使是通过蛮力攻击也是很不好破解。
aes加密算法简单说明
tusong86的博客
09-28 7594
里面简要介绍了aes的补齐规则和ecb,cbc模式
AES加密算法介绍（附AES在线工具）
最新发布
迷失蒲公英
05-16 6520
，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。现在，高级加密标准已然成为对称密钥加密中最流行的算法之一。AES是一种对称密钥算法，意味着加密和解密使用相同的密钥。这种算法非常高效，可以在处理大量数据时提供快速的加密和解密操作。
学学Python_36类_02 类的方法
11-10
方法定义在类的内部，并通过在函数定义前加上`def`关键字，然后在其参数列表中添加第一个参数`self`来创建。`self`是一个指向调用该方法的对象的引用，它允许我们在方法内部访问和操作对象的属性。 例如： ```...
学学Python_字符串04_字符串方法01
09-14
不过，Python提供了丰富的字符串方法来处理和操作字符串，这些方法通常在`str`类中定义。 1. **字符串操作方法**： - `len(str)`: 返回字符串的长度，即其中字符的数量。 - `str.lower()`: 将字符串中的所有字符...
学学Python_字符串11_字典的方法04 get方法
10-01
在本主题“学学Python_字符串11_字典的方法04 get方法”中，我们将深入探讨字典的get()方法。get()方法是字典的一个便捷功能，允许我们安全地从字典中获取值，同时提供了默认值处理，避免了KeyError的发生。 **字典...
学学Python_字符串04_字符串方法02
09-15
它通过指定的分隔符来切分字符串。例如，如果你有一个字符串`"Hello, World! How are you?"`，你可以用空格作为分隔符，调用 `split()` 方法将其分割为单词列表： ```python s = "Hello, World! How are you?" ...
AES加密(1)：AES基础知识和计算过程
主要分享硬件、嵌入式软件部分知识
08-10 6302
AES加密算法(也称为Rijndael算法)是一种对称分块密码算法，以块为单位对数据进行加密，一个块的大小为128位。而AES的密钥则可以为128、192和256位。不同的密钥长度对应着不同的加密轮数：128位为10轮、192位为12轮、256位为14轮。AES基于替代-置换网络，也称为SP网络。它由一系列链接操作组成，包括将输入替换为特定的输出(替代)以及涉及位排序(置换)的其他操作。SP网络：与DES算法中的Feistel密码结构不同，它采用了SP网络结构。
AES加密算法详解
leekay123的博客
02-19 1万+
前言 AES算法是当前最流行的对称加密算法，也是一种分组加密算法，分组密码就是把明文分为固定长度的一组一组，每次加密一组数据，直到加密完整个明文数据。AES算法根据分组长度可以分为AES128, AES192，AES256，其所要求的秘钥长度和加密轮数也各不相同。鉴于这三种模式的算...
全面了解AES加密：入门指南
你若盛开，清风自来
06-13 4751
加密是指将信息通过某些特定的算法处理，使其变得不易被其他人理解或阅读，以保护其信息安全性的过程。加密将原始信息转换为加密文本，这样只有授权人员在拥有访问权限的情况下才能够将此信息转换回来，使其变为可读状态。加密可以在多个领域使用，包括通信、银行业务、计算机安全等，目的是防止未经授权的访问、窃取或破坏数据、信息和资产。通常，加密方式是通过给原始数据添加一个随机的密钥来进行的，这个密钥拥有者可以安全地存储和管理，以确保数据不被非法获取。这样的加密方法被称为对称加密，还有一种加密方法称为。
aes加密
u014527136的专栏
06-25 1374
aes加密模式及填充算法
AES加密算法原理的详细介绍与实现
热门推荐
qq_28205153的博客
02-19 83万+
AES简介高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义： 明文P 没有经过加密的数据。密钥K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生
SpringMVC实现AES请求参数加密时遇到的问题（原创）
sadasdyy的博客
08-08 163
SpringMVC实现AES请求参数加密时遇到的问题
从零开始：一步步教你破解WEP无线网络加密
"这篇文章主要介绍了无线网络中的WEP（有线等效保密）加密的破解过程，以及如何通过设置安全措施来防范此类攻击。" 在无线网络领域，WEP（有线等效保密）最初被引入作为无线网络安全的保护者。WEP的主要目标是为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bummon.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值