SpringBoot前后端RSA加解密问题

svygh1232024-05-15 15:28

今天的问题：

个人在是使用RSA进行前后端加密传输,前端对整个传输的body进行加密，

后端接口接收的是一个User对象,包含username、password，

个人预期是在aop内将其解密成user对象，然后controller就可以正常接收，但是请求根本发送不出去：Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot construct instance of com.lin.me.entity.User (although at least one Creator exists): no String-argument constructor/factory method to deserialize from String value ('IZlPsCd2qVBL0hGVTzb23owpvyXa5xom1z5YXBCbrdlUXS...................................................

意思是必须要接收一个User对象 请问大家怎么解决

确实，传送明文数据就像把数据暴露给所有人一样，因此为了数据安全，加密是必不可少的。

要实现上面的功能，即在Spring Boot应用中通过AOP（面向切面编程）对前端使用RSA加密的请求体进行解密，然后将解密后的数据自动转换为User对象供Controller方法使用，需要几个步骤来完成。下面是一个简化的示例，帮助您理解如何实现这一流程。

步骤 1: 添加依赖

确保您的项目中包含了Spring AOP和RSA加密相关的依赖。如果是Maven项目，可以在pom.xml中添加如下依赖：

XML 复制代码 
<!-- Spring AOP -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<!-- RSA 加密库，这里以Bouncy Castle为例 -->
<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.70</version>
</dependency>

步骤 2: 定义User类

假设您已有User类定义，大致如下：

java 复制代码 
public class User {
    private String username;
    private String password;

    // getters and setters
}

步骤 3: 实现RSA加解密工具类

创建一个工具类用于RSA的加解密操作。这里简化处理，实际应用中应更安全地管理密钥。

java 复制代码 
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.*;
import javax.crypto.Cipher;

public class RSAUtil {

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

    public static byte[] decrypt(byte[] encryptedData, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(encryptedData);
    }
}

步骤 4: 创建AOP切面进行解密

创建一个AOP切面，用于拦截Controller中的方法，并对加密的请求体进行解密。

java 复制代码 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

@Aspect
@Component
public class DecryptRequestBodyAspect {

    @Around("@annotation(decryptRequestBody)")
    public Object decryptRequestBody(ProceedingJoinPoint joinPoint, DecryptRequestBody decryptRequestBody) throws Throwable {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        String requestBody = readRequestBody(request);
        if (requestBody != null) {
            requestBody = decrypt(requestBody); // 假设decrypt方法实现了从字符串解密到User对象的逻辑
            // 将解密后的请求体设置回请求中（如果需要）
            // request.setAttribute("BODY", requestBody);
        }

        return joinPoint.proceed();
    }

    private String readRequestBody(HttpServletRequest request) throws IOException {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()))) {
            char[] buff = new char[1024];
            int len;
            while ((len = reader.read(buff)) != -1) {
                sb.append(buff, 0, len);
            }
        }
        return sb.toString();
    }

    // 假设的解密方法，实际需要根据加密方式实现
    private String decrypt(String encryptedBody) {
        // 这里需要实现从加密字符串到User对象的具体逻辑
        // 包括从请求中获取或配置中读取私钥等操作
        return ""; // 返回解密后的User对象的JSON字符串或其他形式
    }
}

步骤 5: 自定义注解标记需要解密的方法

创建一个自定义注解，用于标记那些需要解密请求体的方法。

java 复制代码 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DecryptRequestBody {
}

步骤 6: 在Controller中使用

最后，在您的Controller方法上使用这个自定义注解，以指示AOP切面进行解密操作。

java 复制代码 
@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping("/login")
    @DecryptRequestBody
    public ResponseEntity<?> login(@RequestBody User user) {
        // 这时user对象应该是解密后的结果
        // 实现登录逻辑...
    }
}

请注意，这里的实现非常简化，实际应用中还需要考虑加密算法的安全性、异常处理、性能优化（如加密大文本时可能需要分块加密和解密）、私钥的安全存储等问题。同时，直接在请求体中加密整个User对象（特别是密码）可能不是最佳实践，通常密码应该单独加密处理，且不建议明文传输密码。

步骤 7: 前端js加密

在前端使用RSA加密，一个常用的库是jsencrypt，它提供了简单的API来实现RSA公钥加密。以下是如何使用jsencrypt库进行RSA加密的示例代码：

首先，确保你已经在HTML文件中引入了jsencrypt.js库。你可以通过CDN或者下载到本地项目中引用。

javascript 复制代码 
<script src="https://cdn.bootcdn.net/ajax/libs/jsencrypt/3.3.2/jsencrypt.min.js"></script>

然后在JavaScript中使用以下代码进行加密：

javascript 复制代码 
// 假设后端已经提供了公钥，并且你已将其存储在变量publicKey中
const publicKey = "-----BEGIN PUBLIC KEY-----\nYOUR_PUBLIC_KEY_HERE\n-----END PUBLIC KEY-----";

// 创建JSEncrypt实例
const encryptor = new JSEncrypt();

// 设置公钥
encryptor.setPublicKey(publicKey);

// 需要加密的数据，例如用户密码
const plaintext = "your_plain_text_here";

// 执行加密操作
const ciphertext = encryptor.encrypt(plaintext);

console.log("Encrypted Text:", ciphertext);

请将YOUR_PUBLIC_KEY_HERE替换为实际的公钥字符串。这段代码会使用公钥对plaintext中的数据进行加密，并将加密后的结果输出到控制台。

请知悉，RSA加密适合加密小块数据，如密码或一些敏感信息的摘要，因为加密大量数据可能会导致性能问题。对于大块数据，可以考虑结合对称加密算法（如AES）和RSA来加密数据和密钥。

后端公钥和私钥生成类GenerateRSAKeys：

java 复制代码 
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class GenerateRSAKeys {

    public static void main(String[] args) throws Exception {
        // 获取KeyPairGenerator实例
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        
        // 初始化密钥对生成器，可以指定密钥长度，例如2048位
        keyPairGenerator.initialize(2048);
        
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        
        // 获取公钥和私钥
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        
        // 打印公钥和私钥（这里为了演示，简单打印其Base64编码形式）
        System.out.println("Public Key: " + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        System.out.println("Private Key: " + Base64.getEncoder().encodeToString(privateKey.getEncoded()));
    }
}

后端加解密工具类RSAUtil：

java 复制代码 
package com.example.default_setting.util;

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;

public class RSAUtil {
	// 示例RSA密钥，实际使用时请从安全的地方加载
	private static final String PUBLIC_KEY = "YOUR_PUBLIC_KEY";
	private static final String PRIVATE_KEY = "YOUR_PRIVATE_KEY";

	// 初始化RSA密钥对
	private static PublicKey publicKey = null;
	private static PrivateKey privateKey = null;

	static {
		Security.addProvider(new BouncyCastleProvider());
		init();
	}
	
	public static void init() {
		try {
	        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
	        publicKey = keyFactory.generatePublic(new X509EncodedKeySpec(Base64.getDecoder().decode(PUBLIC_KEY)));
	        privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(Base64.getDecoder().decode(PRIVATE_KEY)));
	    } catch (Exception e) {
	        throw new RuntimeException("Failed to initialize RSA keys", e);
	    }
	}

    public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

    public static byte[] decrypt(byte[] encryptedData, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(encryptedData);
    }
    
    public static byte[] decrypt(byte[] encryptedData) throws Exception {
    	Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
    	cipher.init(Cipher.DECRYPT_MODE, privateKey);
    	return cipher.doFinal(encryptedData);
    }
 	
 	public static void main(String[] args) {
		System.out.println(1);
	}
}

但是还是不能整体加密后给后端使用，可能的解决办法如下：

1.局部加密

2.后端全部用String接收

3.后端实体增加一个字段接收，然后再在aop界面填充

如果大家还发现更好的办法，可以评论区说一下，感谢阅读！

相关推荐
秋意钟9 分钟前
Spring新版本
java·后端·spring
椰椰椰耶11 分钟前
【文档搜索引擎】缓冲区优化和索引模块小结
java·spring·搜索引擎
mubeibeinv13 分钟前
项目搭建+图片(添加+图片)
java·服务器·前端
青莳吖14 分钟前
Java通过Map实现与SQL中的group by相同的逻辑
java·开发语言·sql
Buleall21 分钟前
期末考学C
java·开发语言
重生之绝世牛码23 分钟前
Java设计模式 —— 【结构型模式】外观模式详解
java·大数据·开发语言·设计模式·设计原则·外观模式
小蜗牛慢慢爬行29 分钟前
有关异步场景的 10 大 Spring Boot 面试问题
java·开发语言·网络·spring boot·后端·spring·面试
Allen Bright36 分钟前
Spring Boot 整合 RabbitMQ：手动 ACK 与 QoS 配置详解
spring boot·rabbitmq·java-rabbitmq
A小白59081 小时前
Docker部署实践：构建可扩展的AI图像/视频分析平台 (脱敏版)
后端
新手小袁_J1 小时前
JDK11下载安装和配置超详细过程
java·spring cloud·jdk·maven·mybatis·jdk11
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04解决java读取EXCEL数据变成科学计数法的问题05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明106个主流的工业3D管道设计软件