java进阶：还在用明文传输前后端参数？等保3级认证不过啦？｜前后端参数加解密

已于 2024-12-17 22:33:06 修改
阅读量1.4k 收藏 22
点赞数 33
CC 4.0 BY-SA版权
分类专栏： java进阶之路 技术分享 前端开发 文章标签： java 状态模式 开发语言
于 2024-12-10 20:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24950043/article/details/144109636

文章目录


在这里插入图片描述

0. 引言

前段时间公司老系统做等保三级认证，在前后端参数传输中被检测有重大漏洞，原因是原系统中使用的参数加密是对称加密，而密钥被明晃晃的存储在前端js代码中，相当于明文传输，后续结合非对称加密做了优化，今天特意整理下思路和实现方法，供大家参考。

1. 思路

1.1 对称加密的问题

首先我们来看对称加密的问题，就是加解密密钥相同，前端传输参数到后端时，就需要使用密钥加密，那密钥存储在哪里呢？

第一种就是像我们老系统那样，存储在前端js层中，当然你可以做一些算法处理来给密钥加点伪装，但实际上代码都在前端层，通过获取源码反解析也能破解，所以存储在前端肯定不可取。

第二种是通过接口实时从后端获取，这个获取接口通过token,session等身份认证控制权限，这种方式相对安全一些， 但是依然可以通过截取token来获取到密钥，所以相对安全性有限。

那么如何从根本上解决这个安全性问题呢？

那就是不能把解密密钥放到前端，但没有密钥又怎么加密呢，这就用到非对称加密了。
在这里插入图片描述

1.2 非对称加密的问题

非对称加密是使用一对密钥（即两个密钥）来加解密，这对密钥中包含一个公钥和一个私钥，两者相互绑定，公钥用于加密，私钥用于解密。这样在前后端加解密的过程，就可以将公钥直接放在前端，私钥存储在后端，即使被拦截到加密内容和公钥，因为没有私钥，也无法解密参数，从而解决了加密安全性问题。

在这里插入图片描述

截止到目前为止，好像一切都思路清晰了， 我们直接用非对称加密来加解密参数即可，但实际真的可行吗？

如果对于性能没有要求，实际上是可以满足了， 但我们做前后端参数传输一般要求越快越好，而非对称加密的性能相对对称加密性能更低，也就是加密速度更慢，特别是在参数值越大的情况下。所以考虑上性能的话，非对称的短板又出现了。

怎么解决呢？

答案是综合对称和非对称，对称的问题是密钥泄漏的安全问题，非对称的问题是加解密性能，那么我们是否可以用对称来加解密数据量更大的参数，用非对称来加密对称密钥，而这个密钥每次都随机生成，同时也随着参数一起传输到后端，这样就不用存储这个密钥了，以此实现安全与性能的平衡。 这个做法，也有一个专门的技术名称，就是“数字信封技术”

那么下面，我们就来看看如何实现它。

2. 实现

对称加密和非对称加密都有多种，这里我们使用AES作为对称加密，RSA作为非对称加密，如果需要使用其他算法的，大家可以自己拓展

2.1 java实现对称、非对称加密

1、AES对称加解密，这里我采用的AES加密模式是AES/CBC/ZeroPadding，基于jdk1.8，核心代码如下，完整代码可在文末源码地址下载

 /**
     * AES加密
     *
     * @param content    待加密的内容
     * @param encryptKey 加密密钥
     * @return 加密后的byte[]
     * @throws Exception
     */
    private static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
        Cipher cipher = Cipher.getInstance(AES_MODE);
        int blockSize = cipher.getBlockSize();
        byte[] dataBytes = content.getBytes(StandardCharsets.UTF_8);
        // zeroPadding
        int plaintextLength = dataBytes.length;
        if (plaintextLength % blockSize != 0) {
            plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
        }
        byte[] plaintext = new byte[plaintextLength];
        System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);

        SecretKeySpec keySpec = new SecretKeySpec(encryptKey.getBytes(), MODE);
        IvParameterSpec ivSpec = new IvParameterSpec(encryptKey.getBytes());
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
        return cipher.doFinal(plaintext);
    }
 /**
     * AES解密
     *
     * @param encryptBytes 待解密的byte[]
     * @param decryptKey   解密密钥
     * @return 解密后的String
     * @throws Exception
     */
    private static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {

        Cipher cipher = Cipher.getInstance(AES_MODE);
        SecretKeySpec keySpec = new SecretKeySpec(decryptKey.getBytes(), MODE);
        IvParameterSpec ivSpec = new IvParameterSpec(decryptKey.getBytes());

        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
        byte[] decryptBytes = cipher.doFinal(encryptBytes);
        String result = new String(decryptBytes);
        if (!"".equals(result)) {
            result = result.trim();
        }
        return result;
    }

2、RSA加解密核心代码

/**
     * 公钥加密
     * @param data
     * @param publicKeyStr
     * @return
     * @throws Exception
     */
    public static String rsaEncrypt(String data, String publicKeyStr) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try {

            byte[] cache;
            PublicKey publicKey = getPublicKey(publicKeyStr);
            Cipher cipher = Cipher.getInstance(RSA_ALG);
            byte[] dataBytes = data.getBytes(CHARSET);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            int dataLen = dataBytes.length;
            int afterLocal = 0;
            while (dataLen - afterLocal > 0) {
                if (dataLen - afterLocal > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(dataBytes, afterLocal, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(dataBytes, afterLocal, dataLen - afterLocal);
                }
                out.write(cache, 0, cache.length);
                afterLocal = afterLocal + MAX_ENCRYPT_BLOCK;
            }
            byte[] rsaEncrypt = out.toByteArray();
            return Base64.getEncoder().encodeToString(rsaEncrypt);
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("RSA 加密失败");
        }finally {
            out.close();
        }
    }

/**
     * 私钥解密
     * @param data
     * @param privateKeyStr
     * @return
     * @throws Exception
     */
    public static String rsaDecrypt(String data, String privateKeyStr) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try {
            byte[] cache;
            byte[] decode = Base64.getDecoder().decode(data.getBytes(CHARSET));
            PrivateKey privateKey = getPrivateKey(privateKeyStr);
            Cipher cipher = Cipher.getInstance(RSA_ALG);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            int dataLen = decode.length;
            int afterLocal = 0;
            while (dataLen - afterLocal > 0) {
                if (dataLen - afterLocal > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(decode, afterLocal, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(decode, afterLocal, dataLen - afterLocal);
                }
                out.write(cache, 0, cache.length);
                afterLocal = afterLocal + MAX_DECRYPT_BLOCK;
            }
            return out.toString();
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("RSA 解密失败");
        } finally {
            out.close();
        }
    }

3、另外还需要实现一个公私钥生成工具

public static void main(String[] args) throws Exception{
        // Create a key pair generator for RSA
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        // Initialize the key pair generator with a 2048-bit key size
        keyPairGenerator.initialize(1024);
        // Generate a key pair
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // Get the private key
        PrivateKey privateKey = keyPair.getPrivate();
        // Get the public key
        PublicKey publicKey = keyPair.getPublic();
        // Encode the keys using base64
        String privateKeyEncoded = Base64.getEncoder().encodeToString(privateKey.getEncoded());
        String publicKeyEncoded = Base64.getEncoder().encodeToString(publicKey.getEncoded());
        // Print the keys
        System.out.println("Private key:\n" + privateKeyEncoded);
        System.out.println("Public key:\n" + publicKeyEncoded);
    }

2.2 js实现对称、非对称加密

1、AES加解密主要基于crypto-js来实现，这里我使用的版本是v3.1.2，源码地址
https://gitee.com/wuhanxue/wu_study/blob/master/demo/encrypt_demo/src/main/resources/static/js/aes.js

/**
     * 参数加密
     * @param data
     * @param keyStr
     * @returns {string}
     */
    function aesEncrypt(data, keyStr) {
        var key = CryptoJS.enc.Latin1.parse(keyStr);
        var encrypted = CryptoJS.AES.encrypt(data, key, {
            iv: key,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.ZeroPadding
        });
        return encrypted.toString();
    }

2、RSA加密基于jsencrypt.min.js来实现，源码地址:

https://gitee.com/wuhanxue/wu_study/blob/master/demo/encrypt_demo/src/main/resources/static/js/jsencrypt.min.js

 /**
     * 密钥加密
     * @param data
     * @param publicKey
     * @returns {*}
     */
    function rsaEncrypt(data, publicKey) {
        var rsa = new JSEncrypt();
        rsa.setPublicKey(publicKey);
        return rsa.encrypt(data);
    }

2.3 参数加密流程实现

1、我们实现了上述过程的加解密工具包后，即可开始实现流程源码。首先要明确参数加密是在前端发起的，我们这里只演示请求参数加密，响应参数则直接明文传输即可。

/**
     * 生成随机密钥
     * @returns {string}
     */
    function generateRandomKey() {
        var length = 16;
        var result = '';
        var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
        var charactersLength = characters.length;
        for (var i = 0; i < length; i++) {
            result += characters.charAt(Math.floor(Math.random() * charactersLength));
        }
        return result;
    }

调用接口前生成随机密钥，并对参数和密钥进行加密

function encrypt() {
        var param = $("#param").val();

        var data = {
            "userName": $("#param").val()
        };

        // 生成密钥
        var keyStr = generateRandomKey();
        // 加密参数
        var encryptParam = aesEncrypt(param, keyStr);
        $("#aes_param").val(encryptParam);
        // 加密密钥
        var encryptKey = rsaEncrypt(keyStr, publicKey);//加密后的密码

        $("#rsa_param").val(encryptKey);
        // 发起请求
        $.ajax({
            url: "/user/add",
            type: "POST",
            headers: {
                encryptKey: encryptKey
            },
            data: data,
            processData: true,
            contentType: "application/x-www-form-urlencoded", // 告诉jQuery不要去设置Content-Type请求头
            success: function (res) {
                console.log(res);
                $("#rsa_decrypt").val(JSON.stringify(res));
            },
            error: function (res) {
                console.error("系统错误", res)
            }
        });
    }

2、在后端中，可以通过拦截器拦截请求，然后解密参数

通过继承HttpServletRequestWrapper实现参数解密转换类

public class DecryptParamsWrapper extends HttpServletRequestWrapper {

    private final Logger logger = LogManager.getLogger(DecryptParamsWrapper.class);

    public static final String KEY_NAME = "encryptKey";
    /**
     * 参数
     */
    private Map<String, String[]> parameterMap;

    HttpServletRequest request;

    public DecryptParamsWrapper(HttpServletRequest request) {
        super(request);
        this.request = request;
        parameterMap = request.getParameterMap();
    }

    /**
     * 获取所有参数名
     *
     * @return 返回所有参数名
     */
    @Override
    public Enumeration<String> getParameterNames() {
        Vector<String> vector = new Vector<>(parameterMap.keySet());
        return vector.elements();
    }

    /**
     * 获取指定参数名的值，如果有重复的参数名，则返回第一个的值
     *
     * @param name 指定参数名
     * @return 指定参数名的值
     */
    @Override
    public String getParameter(String name) {
        String[] results = parameterMap.get(name);
        if (results == null || results.length <= 0) {
            return null;
        } else if ("rows".equals(name) || "page".equals(name)) {
            return results[0];
        } else {
            return decrypt(results[0]);
        }
    }

    /**
     * 获取指定参数名的所有值的数组
     */
    @Override
    public String[] getParameterValues(String name) {
        String[] results = parameterMap.get(name);
        if (results == null || results.length <= 0) {
            return null;
            // 分页参数过滤
        } else if ("rows".equals(name) || "page".equals(name)) {
            return results;
        } else {
            int length = results.length;
            for (int i = 0; i < length; i++) {
                String temp = decrypt(results[i]);
                results[i] = temp;
            }
            return results;
        }
    }

    private String decrypt(String data) {
        try {
            return AesUtil.aesDecrypt(data, decryptKey());
        } catch (Exception e) {
            logger.error("参数解密失败: ", e);
            throw new RuntimeException(e);
        }
    }

    private String decryptKey(){
        String keyEncrypt = this.request.getHeader(KEY_NAME);
        String key = null;
        try {
            key = RsaUtil.rsaDecrypt(keyEncrypt, RsaUtil.PRIVATE_KEY);
            return key;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("密钥解密失败");
        }
    }
}

然后声明拦截器，在拦截器中调用解密转换类

@Component
@WebFilter(filterName = "decryptFilter", urlPatterns = "/*")
public class DecryptParamsFilter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 过滤url
//        String requestURI = httpRequest.getRequestURI();
//        if(requestURI != null && requestURI.contains("xx/xx")){
//            chain.doFilter(request, response);
//            return;
//        }
        String keyEncrypt = httpRequest.getHeader(DecryptParamsWrapper.KEY_NAME);
        if(keyEncrypt == null || keyEncrypt.length() == 0){
            chain.doFilter(request, response);
            return;
        }
        DecryptParamsWrapper wrapper = new DecryptParamsWrapper(httpRequest);
        chain.doFilter(wrapper, response);
    }
}

2.4 测试

这里我编写了一个测试demo, 源码见下文，增加一个后端接口，用于测试

@RestController
@RequestMapping("user")
public class UserController {

    @PostMapping("add")
    public R addUser(String userName, HttpServletRequest request){
        // 模拟操作成功, 将解密的参数返回
        try {
            return R.success(userName);
        } catch (Exception e) {
            e.printStackTrace();
            return R.fail("解密失败");
        }
    }
}

通过浏览器控制台可以看到调用时入参是加密的
在这里插入图片描述
每次的对称密钥存放在header中
在这里插入图片描述

后端接口的逻辑是将入参获取后再返回，可以看到已经通过拦截器自动解密了
在这里插入图片描述
测试通过！

3. 项目源码

https://gitee.com/wuhanxue/wu_study/blob/master/demo/encrypt_demo

4. 总结

如上我们通过对称加密实现参数值加密，对称密钥每次都随机生成，通过非对称加密实现密钥的加密，在高安全性和性能之间实现平衡。常规的前后端加解密足够使用。

如果对参数完整性还有校验要求的话，可以增加一个sign签名验证，源码中已经实现部分代码，但还未验证测试，大家可以参考实现。

Java 使用 RSA算法 进行前后端加密解密
m0_61341973的博客
05-16 3589
ts前端使用forge的RSA算法対密码进行加密,Java后端进行解密 .forge还支持ED25519 RSA,RSA-KEM,X.509,PKCS#5,PKCS#7等多种算法的加密解密。
14-SpringSecurity：前后端分离项目中用户名与密码通过RSA加密传输
F1520080的博客
04-22 459
1.12/**RSA公钥加密@param str 待加密字符串@param publicKey 公钥@return 密文*/try {//base64编码的公钥//RSA加密/**RSA私钥解密@param str 已加密字符串@param privateKey 私钥@return 明文*/try {//64位解码加密后的字符串//base64编码的私钥//RSA解密。
Java实现http接口参数和返回值加密
热门推荐
站在墙头上的博客
12-05 1万+
Java实现接口参数和返回值加解密
2025年三级等保实施全攻略：从合规到实战的深度解析
最新发布
2403_86962125的博客
05-21 1694
2025年，随着《网络安全法》的深化实施和等保2.0补充要求的落地，三级等保已成为金融、医疗、政务等关键行业的强制性安全标准。：对照GB/T 22239-2019标准，重点检查物理安全（如机房防火、防水）、网络安全（边界防护、入侵检测）及数据安全（加密、备份）的合规性。：划分安全区域，部署防火墙、IDS/IPS系统，并启用网络流量加密。网络安全合规顾问，主导多个省级政务云、金融平台三级等保项目，擅长等保2.0扩展场景落地。：通过等保2.0扩展要求，明确云服务商与用户责任边界，并通过区块链记录审计日志。
前后端参数加解密方案
weixin_34128839的博客
01-16 2512
简介 HTTP信息传输总会遇到参数被劫持进行二次传输的尴尬境地,为了避免这种情况,建议在前端请求的时候对上行参数进行加密传输,后端再进行解密,防止信息被盗取 知识点 前端: 框架采用VUE.JS,加密可以选用方案较为完善的CryptoJS 本文采用CryptoJS其中的aes加密方案为例 后端: 也采用对应的aes加密进行参数解析 准备 前端 用npm进行安装 npm install c...
前后端分离的参数加解密
YSOLA4的专栏
07-01 1273
前后端分离, 加解密参数请求
Spring Boot 使用AES前后端传递参数加解密
雨陆聪辰的博客
10-08 2849
Spring Boot 使用AES前后端传递参数加解密
【理正软件参数应用进阶】：深入解析参数配置的高级策略
![【理正软件参数应用进阶】：深入解析参数配置的高级策略](https://vip.kingdee.com/download/010105d20d6cbbce49338e0bcf1d7a129859.png) ...在进阶应用实例章节中，本文探讨了参数配置在企业级应用、微服务
【Java加密技术进阶】：JSSE与Java加密框架的完美协同
![【Java加密技术进阶】：JSSE与Java加密框架的完美协同]...在实践应用章节中，详细说明了如何利用JSSE进行网络通信加密，以及如何整合Java加密框架进行数据传输和存储加密。
C# RSA加密DEMO进阶：揭秘密钥安全存储与管理
!... # 摘要 本文详细探讨了RSA加密算法在C#环境下的实现原理及应用。首先介绍了RSA加密的基础...第三章详细阐述了RSA算法在数据传输、签名验证和代码保护中的实际应用，展示了如何结合对称加密技术提高安全性。第四章则着
java前后端通讯AES加密及解密样例
06-12
本案例使用springboot进行快速构建项目，AES进行对称加密及解密
Java RSA加密前后端实现
01-25
本资源实现前端加密、Java后端加密。本资源出自他人整合。
Java加密解密最佳实践：Bouncy Castle等库安全应用详解
![Java加密解密最佳实践：Bouncy ...本章旨在为读者提供Java加密解密的基础知识，为后续章节中Bouncy Castle库的具体应用以及加密解密进阶实践打下坚实的基础。 ## 1.1 加密解密概述 加密是将信息（明文）转换为不
前后端数据加解密
qq_15901351的博客
01-03 3446
数据在http请求传输过程中，存在安全性隐患，故此，出现一些加密手段，这里介绍aes对称加密。。。 AES加密介绍：https://blog.csdn.net/qq_28205153/article/details/55798628 RSA:https://blog.csdn.net/qq_25680531/article/details/90407430 废话不多说，直接上代码。。。 h...
java前后端参数和返回加密解密AES+CBC+BASE64
weixin_37530941的博客
04-27 1万+
java 前后端加密解密， java +vue aes+cbc参数返回值加密解密
java前后台加解密
Li_789的博客
03-14 595
以上是对Java中进行前后台加解密的简单示例。在实际项目中，需要根据具体的需求和安全要求选择合适的加密算法和实现方式，并注意安全性和性能方面的考虑。● 非对称加密使用一对密钥，分别是公钥和私钥。● 在Java中，可以使用javax.crypto包提供的Cipher类来进行对称加密和解密操作。● 在Java中，可以使用java.security包提供的相关类来进行非对称加密和解密操作。● 对称加密使用相同的密钥进行加密和解密。在Java中进行前后台加解密通常使用的是对称加密和非对称加密算法。
学习加密(三)spring boot 使用RSA非对称加密,前后端传递参数加解密
攻城狮不是猫
02-28 4220
1.前面一篇是AES对称加密写了一个demo,为了后面的两者结合使用,今天去了解学习了下RSA非对称加密. 2.这是百度百科对(对称加密丶非对称加密)的解释: (1)对称加密算法在加密和解密时使用的是同一个秘钥。 (2)非对称加密算法需要两个密钥来进行加密和解密，这两个秘钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。 大致思路: ...
前后端加解密交互
lazysetting的博客
08-31 1320
前后端交互加解密 前言 加解密作用 为保护用户个人隐私，加密算法必不可少。一套成熟的加解密算法，可以防止用户个人信息泄漏、丢失等一系列问题，加固网络传输安全。 此项目用到的加解密 sm3、sm4、2进制流 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wu@55555

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

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

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

打赏作者

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

抵扣说明：

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

余额充值