当前位置： 代码网 > it编程>编程语言>Java > SpringBoot实现RSA+AES自动接口解密

SpringBoot实现RSA+AES自动接口解密

2025年10月22日 • Java •我要评论
引言在现代应用开发中，接口安全性变得越来越重要。当敏感数据通过网络传输时，如何确保数据不被窃取或篡改？本文将详细介绍如何在 springboot 应用中实现 rsa+aes 混合加密方案，为接口通信提

引言

在现代应用开发中，接口安全性变得越来越重要。当敏感数据通过网络传输时，如何确保数据不被窃取或篡改？本文将详细介绍如何在 springboot 应用中实现 rsa+aes 混合加密方案，为接口通信提供强大的安全保障。

为什么需要接口加密？

在没有加密的情况下，通过网络传输的数据可以被抓包工具轻松获取。特别是当传输包含用户隐私、支付信息等敏感数据时，这种风险更加不可接受。接口加密能够确保即使数据被截获，攻击者也无法理解其中的内容。

rsa+aes 混合加密方案的优势

我们选择 rsa+aes 混合加密方案是因为它结合了两种算法的优点：

  1. rsa: 非对称加密，安全性高，但加密速度较慢，适合加密少量数据
  2. aes: 对称加密，加密速度快，适合大量数据加密，但密钥分发是个难题

通过混合使用这两种算法，我们用 rsa 来加密 aes 的密钥，然后用 aes 来加密实际传输的数据，既保证了安全性，又兼顾了性能。

实现原理

  1. 客户端与服务端预先约定 rsa 公钥和私钥
  2. 客户端随机生成 aes 密钥，使用 rsa 公钥加密这个 aes 密钥
  3. 使用 aes 密钥加密实际请求数据
  4. 将加密后的 aes 密钥和加密后的数据一起发送给服务端
  5. 服务端先用 rsa 私钥解密得到 aes 密钥，再用 aes 密钥解密数据

下面我们将通过实例代码演示如何在 springboot 中实现这一方案。

项目依赖

首先在 pom.xml 中添加必要的依赖：

<dependencies>
    <dependency>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-web</artifactid>
    </dependency>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupid>com.alibaba</groupid>
        <artifactid>fastjson</artifactid>
        <version>1.2.78</version>
    </dependency>
    <dependency>
        <groupid>org.bouncycastle</groupid>
        <artifactid>bcprov-jdk15on</artifactid>
        <version>1.68</version>
    </dependency>
</dependencies>

加密工具类

下面是我们需要实现的加密工具类：

package com.example.secureapi.utils;

import org.bouncycastle.jce.provider.bouncycastleprovider;

import javax.crypto.cipher;
import javax.crypto.keygenerator;
import javax.crypto.secretkey;
import javax.crypto.spec.ivparameterspec;
import javax.crypto.spec.secretkeyspec;
import java.nio.charset.standardcharsets;
import java.security.*;
import java.security.spec.pkcs8encodedkeyspec;
import java.security.spec.x509encodedkeyspec;
import java.util.base64;

public class encryptionutils {
    // 添加bouncycastle作为安全提供者，提供更强大的加密算法支持
    static {
        security.addprovider(new bouncycastleprovider());
    }

    // aes加密配置
    private static final string aes_algorithm = "aes/cbc/pkcs7padding";  // 使用cbc模式和pkcs7填充
    private static final int aes_key_size = 256;  // 使用256位密钥提供更强的安全性
    
    // rsa加密配置
    private static final string rsa_algorithm = "rsa/ecb/pkcs1padding";  // 使用pkcs1填充
    private static final int rsa_key_size = 2048;  // 使用2048位密钥长度，提供足够的安全强度

    /**
     * 生成rsa密钥对
     * @return 包含公钥和私钥的密钥对
     * @throws exception 生成过程中可能出现的异常
     */
    public static keypair generatersakeypair() throws exception {
        keypairgenerator keypairgenerator = keypairgenerator.getinstance("rsa");
        keypairgenerator.initialize(rsa_key_size);
        return keypairgenerator.generatekeypair();
    }

    /**
     * 将密钥转换为base64编码字符串，便于存储和传输
     * @param key 密钥
     * @return base64编码的密钥字符串
     */
    public static string keytostring(key key) {
        return base64.getencoder().encodetostring(key.getencoded());
    }

    /**
     * 从base64编码的字符串恢复rsa公钥
     * @param keystr base64编码的公钥字符串
     * @return rsa公钥对象
     * @throws exception 转换过程中可能出现的异常
     */
    public static publickey stringtorsapublickey(string keystr) throws exception {
        byte[] keybytes = base64.getdecoder().decode(keystr);
        x509encodedkeyspec keyspec = new x509encodedkeyspec(keybytes);
        keyfactory keyfactory = keyfactory.getinstance("rsa");
        return keyfactory.generatepublic(keyspec);
    }

    /**
     * 从base64编码的字符串恢复rsa私钥
     * @param keystr base64编码的私钥字符串
     * @return rsa私钥对象
     * @throws exception 转换过程中可能出现的异常
     */
    public static privatekey stringtorsaprivatekey(string keystr) throws exception {
        byte[] keybytes = base64.getdecoder().decode(keystr);
        pkcs8encodedkeyspec keyspec = new pkcs8encodedkeyspec(keybytes);
        keyfactory keyfactory = keyfactory.getinstance("rsa");
        return keyfactory.generateprivate(keyspec);
    }

    /**
     * 生成随机aes密钥
     * @return aes密钥
     * @throws exception 生成过程中可能出现的异常
     */
    public static secretkey generateaeskey() throws exception {
        keygenerator keygen = keygenerator.getinstance("aes");
        keygen.init(aes_key_size);
        return keygen.generatekey();
    }

    /**
     * 从base64编码的字符串恢复aes密钥
     * @param keystr base64编码的aes密钥字符串
     * @return aes密钥对象
     */
    public static secretkey stringtoaeskey(string keystr) {
        byte[] keybytes = base64.getdecoder().decode(keystr);
        return new secretkeyspec(keybytes, "aes");
    }

    /**
     * 使用rsa公钥加密数据
     * @param data 待加密数据
     * @param publickey rsa公钥
     * @return base64编码的加密数据
     * @throws exception 加密过程中可能出现的异常
     */
    public static string encryptwithrsa(string data, publickey publickey) throws exception {
        cipher cipher = cipher.getinstance(rsa_algorithm);
        cipher.init(cipher.encrypt_mode, publickey);
        byte[] encryptedbytes = cipher.dofinal(data.getbytes(standardcharsets.utf_8));
        return base64.getencoder().encodetostring(encryptedbytes);
    }

    /**
     * 使用rsa私钥解密数据
     * @param encrypteddata base64编码的加密数据
     * @param privatekey rsa私钥
     * @return 解密后的原始数据
     * @throws exception 解密过程中可能出现的异常
     */
    public static string decryptwithrsa(string encrypteddata, privatekey privatekey) throws exception {
        byte[] encryptedbytes = base64.getdecoder().decode(encrypteddata);
        cipher cipher = cipher.getinstance(rsa_algorithm);
        cipher.init(cipher.decrypt_mode, privatekey);
        byte[] decryptedbytes = cipher.dofinal(encryptedbytes);
        return new string(decryptedbytes, standardcharsets.utf_8);
    }

    /**
     * 使用aes密钥加密数据
     * @param data 待加密数据
     * @param secretkey aes密钥
     * @param iv 初始化向量
     * @return base64编码的加密数据
     * @throws exception 加密过程中可能出现的异常
     */
    public static string encryptwithaes(string data, secretkey secretkey, byte[] iv) throws exception {
        cipher cipher = cipher.getinstance(aes_algorithm, "bc");
        ivparameterspec ivspec = new ivparameterspec(iv);
        cipher.init(cipher.encrypt_mode, secretkey, ivspec);
        byte[] encryptedbytes = cipher.dofinal(data.getbytes(standardcharsets.utf_8));
        return base64.getencoder().encodetostring(encryptedbytes);
    }

    /**
     * 使用aes密钥解密数据
     * @param encrypteddata base64编码的加密数据
     * @param secretkey aes密钥
     * @param iv 初始化向量
     * @return 解密后的原始数据
     * @throws exception 解密过程中可能出现的异常
     */
    public static string decryptwithaes(string encrypteddata, secretkey secretkey, byte[] iv) throws exception {
        byte[] encryptedbytes = base64.getdecoder().decode(encrypteddata);
        cipher cipher = cipher.getinstance(aes_algorithm, "bc");
        ivparameterspec ivspec = new ivparameterspec(iv);
        cipher.init(cipher.decrypt_mode, secretkey, ivspec);
        byte[] decryptedbytes = cipher.dofinal(encryptedbytes);
        return new string(decryptedbytes, standardcharsets.utf_8);
    }

    /**
     * 生成随机初始化向量
     * @return 16字节的随机初始化向量
     */
    public static byte[] generateiv() {
        securerandom random = new securerandom();
        byte[] iv = new byte[16];  // aes使用16字节的初始化向量
        random.nextbytes(iv);
        return iv;
    }
}

自定义请求包装类

为了实现加密请求的自动解密，我们需要定义一个请求包装类：

package com.example.secureapi.model;

import lombok.data;

@data
public class encryptedrequest {
    // 使用rsa加密后的aes密钥
    private string encryptedkey;
    
    // 使用base64编码的aes初始化向量
    private string iv;
    
    // 使用aes加密后的业务数据
    private string encrypteddata;

    // 可选：时间戳，用于防重放攻击
    private long timestamp;

    // 可选：签名，用于验证请求完整性
    private string signature;
}

spring boot 解密拦截器

我们接下来实现一个请求解密拦截器，它会在控制器处理请求之前自动解密数据：

package com.example.secureapi.interceptor;

import com.alibaba.fastjson.json;
import com.alibaba.fastjson.jsonobject;
import com.example.secureapi.annotation.decrypt;
import com.example.secureapi.model.encryptedrequest;
import com.example.secureapi.utils.encryptionutils;
import lombok.extern.slf4j.slf4j;
import org.springframework.beans.factory.annotation.value;
import org.springframework.stereotype.component;
import org.springframework.web.method.handlermethod;
import org.springframework.web.servlet.handlerinterceptor;

import javax.crypto.secretkey;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import java.io.bufferedreader;
import java.io.bytearrayinputstream;
import java.io.inputstreamreader;
import java.nio.charset.standardcharsets;
import java.security.privatekey;
import java.util.base64;
import java.util.stream.collectors;

@slf4j
@component
public class decryptinterceptor implements handlerinterceptor {

    // 从配置文件注入rsa私钥，用于解密aes密钥
    @value("${security.rsa.private-key}")
    private string rsaprivatekeystr;

    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
        // 只处理带有@decrypt注解的控制器方法
        if (handler instanceof handlermethod) {
            handlermethod handlermethod = (handlermethod) handler;
            
            // 检查方法或类是否有@decrypt注解
            decrypt decryptannotation = handlermethod.getmethodannotation(decrypt.class);
            if (decryptannotation == null) {
                decryptannotation = handlermethod.getbeantype().getannotation(decrypt.class);
            }
            
            // 如果有@decrypt注解，进行解密处理
            if (decryptannotation != null) {
                // 读取请求体内容
                string requestbody = request.getreader().lines().collect(collectors.joining());
                
                // 解析加密的请求对象
                encryptedrequest encryptedrequest = json.parseobject(requestbody, encryptedrequest.class);
                
                // 获取rsa私钥
                privatekey rsaprivatekey = encryptionutils.stringtorsaprivatekey(rsaprivatekeystr);
                
                // 解密aes密钥
                string aeskeystr = encryptionutils.decryptwithrsa(encryptedrequest.getencryptedkey(), rsaprivatekey);
                secretkey aeskey = encryptionutils.stringtoaeskey(aeskeystr);
                
                // 获取初始化向量
                byte[] iv = base64.getdecoder().decode(encryptedrequest.getiv());
                
                // 使用aes密钥解密实际数据
                string decrypteddata = encryptionutils.decryptwithaes(encryptedrequest.getencrypteddata(), aeskey, iv);
                
                // 防重放攻击检查（可选）
                if (encryptedrequest.gettimestamp() != null) {
                    long currenttime = system.currenttimemillis();
                    // 如果请求时间戳与当前时间相差超过5分钟，则拒绝请求
                    if (math.abs(currenttime - encryptedrequest.gettimestamp()) > 300000) {
                        response.setstatus(httpservletresponse.sc_forbidden);
                        response.getwriter().write("{"code":403,"message":"请求已过期"}");
                        return false;
                    }
                }
                
                log.debug("解密后的数据: {}", decrypteddata);
                
                // 创建一个包含解密数据的新bufferedreader，替换原有的请求reader
                request.setattribute("decrypted_data", decrypteddata);
                
                // 包装请求，使控制器能够读取解密后的数据
                return wraprequest(request, decrypteddata);
            }
        }
        return true;
    }
    
    /**
     * 包装httpservletrequest，替换请求体内容为解密后的数据
     * @param request 原始请求
     * @param decrypteddata 解密后的数据
     * @return 是否成功包装请求
     */
    private boolean wraprequest(httpservletrequest request, string decrypteddata) {
        try {
            // 创建包装后的请求对象
            decryptedrequestwrapper wrapper = new decryptedrequestwrapper(request, decrypteddata);
            // 替换当前请求
            request.setattribute("org.springframework.web.util.webutils.error_exception_attribute", wrapper);
            return true;
        } catch (exception e) {
            log.error("包装请求失败", e);
            return false;
        }
    }
    
    /**
     * 自定义请求包装类，用于替换请求体内容
     */
    private static class decryptedrequestwrapper extends httpservletrequestwrapper {
        private final string decrypteddata;
        
        public decryptedrequestwrapper(httpservletrequest request, string decrypteddata) {
            super(request);
            this.decrypteddata = decrypteddata;
        }
        
        @override
        public bufferedreader getreader() {
            return new bufferedreader(new inputstreamreader(
                new bytearrayinputstream(decrypteddata.getbytes(standardcharsets.utf_8))));
        }
        
        @override
        public servletinputstream getinputstream() {
            final bytearrayinputstream bytearrayinputstream = new bytearrayinputstream(
                decrypteddata.getbytes(standardcharsets.utf_8));
            
            return new servletinputstream() {
                @override
                public boolean isfinished() {
                    return bytearrayinputstream.available() == 0;
                }
                
                @override
                public boolean isready() {
                    return true;
                }
                
                @override
                public void setreadlistener(readlistener readlistener) {
                    throw new unsupportedoperationexception();
                }
                
                @override
                public int read() {
                    return bytearrayinputstream.read();
                }
            };
        }
    }
}

现在还需要补充缺少的导入包，以及添加解密注解：

package com.example.secureapi.annotation;

import java.lang.annotation.*;

/**
 * 标记需要解密处理的控制器或方法
 * 可以应用于类或方法级别
 */
@target({elementtype.method, elementtype.type})
@retention(retentionpolicy.runtime)
@documented
public @interface decrypt {
    // 可以添加额外配置参数，例如是否检查时间戳、是否验证签名等
    boolean checktimestamp() default true;
    boolean verifysignature() default false;
}

最后，我们还需要在 spring boot 配置中注册这个拦截器：

package com.example.secureapi.config;

import com.example.secureapi.interceptor.decryptinterceptor;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.configuration;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;

@configuration
public class webmvcconfig implements webmvcconfigurer {

    @autowired
    private decryptinterceptor decryptinterceptor;

    @override
    public void addinterceptors(interceptorregistry registry) {
        // 添加解密拦截器，应用到所有api请求路径
        registry.addinterceptor(decryptinterceptor)
                .addpathpatterns("/api/**");
    }
}

总结

这篇文章详细介绍了如何在 springboot 应用中实现 rsa+aes 混合加密方案，为接口通信提供安全保障。文章首先解释了接口加密的必要性，指出未加密的网络数据容易被抓包工具获取，特别是当传输敏感信息时风险更大。

到此这篇关于springboot实现rsa+aes自动接口解密的文章就介绍到这了,更多相关springboot rsa+aes自动解密内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

赞 (0)

相关文章:

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。

发表评论

验证码：
最近更新的文章
推荐阅读
大家感兴趣的文章
Copyright © 2017-2025  代码网 保留所有权利. 粤ICP备2024248653号
站长QQ:2386932994 | 联系邮箱：2386932994@qq.com