Springboot集成RSA加密

已于 2023-04-07 10:10:20 修改
阅读量1.8k 收藏 9
点赞数 3
分类专栏： SpringBoot 文章标签： spring boot java 后端
于 2023-03-17 18:13:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38254635/article/details/129623413
版权

Springboot集成RSA加密

1 : RSA加密介绍

RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。
特点：安全性高，运算速度相对较慢。
其余可以搜一下，很多介绍。

2 : RSA依赖

依赖

<!-- poi -->
<dependency>
	<groupId>org.apache.poi</groupId>
	<artifactId>poi</artifactId>
	<version>4.1.2</version>
</dependency>
<dependency>
	<groupId>org.apache.poi</groupId>
	<artifactId>poi-ooxml</artifactId>
	<version>4.1.2</version>
</dependency>

完成pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.5</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.export</groupId>
	<artifactId>export</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>export</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<!-- poi -->
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi</artifactId>
			<version>4.1.2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml</artifactId>
			<version>4.1.2</version>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<mainClass>com.encrypt.EncryptApplication</mainClass>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

3 : RSA加密工具类

Base64Utils.java

package com.encrypt.config.utils;

import org.apache.xmlbeans.impl.util.Base64;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class Base64Utils {
    /**
     * 文件读取缓冲区大小
     */
    private static final int CACHE_SIZE = 1024;

    /**
     * BASE64字符串解码为二进制数据
     */
    public static byte[] decode(String base64) throws Exception {
        return Base64.decode(base64.getBytes());
    }

    /**
     * 二进制数据编码为BASE64字符串
     */
    public static String encode(byte[] bytes){
        return new String(Base64.encode(bytes));
    }

    /**
     * 将文件编码为BASE64字符串，大文件慎用，可能会导致内存溢出
     * @param filePath 文件绝对路径
     */
    public static String encodeFile(String filePath) throws Exception {
        byte[] bytes = fileToByte(filePath);
        return encode(bytes);
    }

    /**
     * BASE64字符串转回文件
     * @param filePath 文件绝对路径
     * @param base64 编码字符串
     */
    public static void decodeToFile(String filePath, String base64) throws Exception {
        byte[] bytes = decode(base64);
        byteArrayToFile(bytes, filePath);
    }

    /**
     * 文件转换为二进制数组
     * @param filePath 文件路径
     */
    public static byte[] fileToByte(String filePath) throws Exception {
        byte[] data = new byte[0];
        File file = new File(filePath);
        if (file.exists()) {
            try ( FileInputStream in = new FileInputStream(file);
                  ByteArrayOutputStream out = new ByteArrayOutputStream(2048);) {
                byte[] cache = new byte[CACHE_SIZE];
                int nRead = 0;
                while ((nRead = in.read(cache)) != -1) {
                    out.write(cache, 0, nRead);
                    out.flush();
                }
                data = out.toByteArray();
            }
        }
        return data;
    }

    /**
     * 二进制数据写文件
     * @param bytes 二进制数据
     * @param filePath 文件生成目录
     */
    public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
        File destFile = new File(filePath);
        try (InputStream in = new ByteArrayInputStream(bytes);
             OutputStream out = new FileOutputStream(destFile);) {
            if (!destFile.getParentFile().exists()) {
                destFile.getParentFile().mkdirs();
            }
            destFile.createNewFile();
            byte[] cache = new byte[CACHE_SIZE];
            int nRead = 0;
            while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            }
        }
    }

}

RSAUtils.java

package com.encrypt.config.utils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSAUtils {

    //RSA 获取公钥的key
    public static final String RSA_PUBLIC_KEY = "RSA_PublicKey";
    //RSA 获取私钥的key
    public static final String RSA_PRIVATE_KEY = "RSA_PrivateKey";
    // 加密算法RSA
    public static final String KEY_ALGORITHM = "RSA";
    //初始化密钥大小
    public static final Integer INITIALIZE = 1024;
    //RSA最大加密明文大小
    public static final Integer MAX_ENCRYPT_BLOCK = 117;
    //RSA最大解密密文大小
    public static final Integer MAX_DECRYPT_BLOCK = 128;
    //签名算法
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /**
     * 生成密钥对(公钥和私钥)
     */
    public static Map<String, Object> generateRSAKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(INITIALIZE);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        return new HashMap<String, Object>(){{
            put(RSA_PUBLIC_KEY, publicKey);
            put(RSA_PRIVATE_KEY, privateKey);
        }};
    }

    /**
     * 获取公钥
     * @param keyMap 密钥对
     */
    public static String getRSAPublicKey(Map<String, Object> keyMap){
        Key key = (Key) keyMap.get(RSA_PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * 获取私钥
     * @param keyMap 密钥对
     */
    public static String getRSAPrivateKey(Map<String, Object> keyMap){
        Key key = (Key) keyMap.get(RSA_PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * 公钥加密
     * @param data 源数据
     * @param publicKey 公钥(BASE64编码)
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * 私钥解密
     * @param encryptedData 已加密数据
     * @param privateKey 私钥(BASE64编码)
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }


    /**
     * 公钥解密
     * @param encryptedData 已加密数据
     * @param publicKey 公钥(BASE64编码)
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * 私钥加密
     * @param data 源数据
     * @param privateKey 私钥(BASE64编码)
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /**
     * 用私钥对信息生成数字签名
     * @param data 已加密数据
     * @param privateKey 私钥(BASE64编码)
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }

    /**
     * 校验数字签名
     * @param data 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign 数字签名
     *
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }


    public static void main(String[] args) throws Exception{
        System.out.println("********************生成公钥、私钥********************");
        Map<String, Object> map = generateRSAKeyPair();
        System.out.println("RSA公钥：" + getRSAPublicKey(map));
        System.out.println("RSA私钥：" + getRSAPrivateKey(map));
        String publicKey = getRSAPublicKey(map);
        String privateKey = getRSAPrivateKey(map);
        String json = "中文，abc,！@#";

        //公钥加密
        System.out.println("********************公钥加密、生成数字签名、数字签名校验、私钥解密********************");
        System.out.println("字符串：" + json);
        String encryptPublic = Base64Utils.encode(encryptByPublicKey(json.getBytes(), publicKey));
        System.out.println("公钥加密后字符串：" + encryptPublic);

        //生成数字签名
        String signKey = sign(Base64Utils.decode(encryptPublic), privateKey);
        System.out.println("公钥加密后数字签名：" + signKey);
        //校验数字签名
        boolean verify = verify(Base64Utils.decode(encryptPublic), publicKey, signKey);
        System.out.println("公钥加密后数字签名校验：" + verify);

        //私钥解密
        System.out.println("私钥解密后字符串：" + new String(decryptByPrivateKey(Base64Utils.decode(encryptPublic), privateKey)));

        System.out.println("********************私钥加密、公钥解密********************");
        //私钥加密
        System.out.println();
        System.out.println("字符串：" + json);
        String encryptPrivate = Base64Utils.encode(encryptByPrivateKey(json.getBytes(), privateKey));
        System.out.println("私钥加密后字符串：" + encryptPrivate);
        //公钥解密
        System.out.println("公钥解密后字符串：" + new String(decryptByPublicKey(Base64Utils.decode(encryptPrivate), publicKey)));

    }

}

4 : 测试截图

在这里插入图片描述

5 : 相关链接

Springboot项目报文加密（采用AES、RSA动态加密策略）：
https://blog.csdn.net/qq_38254635/article/details/129275971
Springboot集成AES加密：
https://blog.csdn.net/qq_38254635/article/details/129622075

6 : 资源链接

CSDN源项目下载：https://download.csdn.net/download/qq_38254635/87587334
百度网盘下载：https://pan.baidu.com/s/1OZBrTYIuoKmWknIPFvZ8Vw?pwd=nnm8
提取码：nnm8

message丶小和尚
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot项目报文加密（采用AES、RSA动态加密策略）
03-28
Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略） Springboot项目报文加密（采用AES、RSA动态加密策略）
SpringBoot快速实现API加密，一招搞定！
Java精选
11-02 292
在项目中，为了保证数据的安全，我们常常会对传递的数据进行加密。常用的加密算法包括对称加密（AES）和非对称加密（RSA），博主选取码云上最简单的API加密项目进行下面的讲解。项目介绍该项目使用RSA加密方式对API接口返回的数据加密，让API数据更加安全。别人无法对提供的数据进行破解。Spring Boot接口加密，可以对返回值、参数值通过注解的方式自动加解密 。什么是RSA加密首先我们当然是了解...
安全登录--Springboot使用Rsa加密及Ldap源进行登录认证
qq_51785096的博客
10-29 646
注册登录一直都是工程师做系统的必经之路，毕竟这个功能相对与业务较复杂的代码来说是比较简单的。 当然，最简单的事情往往最容易出错，最为普通的注册登录就是将用户名及密码存入数据库，在用户登录时，将两者进行比对来校验是否登录成功。 此篇文档则会介绍非对称加密及Ad域认证两种登录方式。
学习加密(三)spring boot 使用RSA非对称加密,前后端传递参数加解密
攻城狮不是猫
02-28 1796
1.前面一篇是AES对称加密写了一个demo,为了后面的两者结合使用,今天去了解学习了下RSA非对称加密. 2.这是百度百科对(对称加密丶非对称加密)的解释: (1)对称加密算法在加密和解密时使用的是同一个秘钥。 (2)非对称加密算法需要两个密钥来进行加密和解密，这两个秘钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。 大致思路: ...
SpringBoot登录注册使用RSA加密解密
weixin_58287721的博客
11-02 186
保安全。#RSA是一种非对称加密算法，即加密和解密时用到的密钥不同。#加密密钥是公钥，可以公开；解密密钥是私钥，必须保密保存。
Springboot项目报文加密（AES、RSA、Filter动态加密）
qq_38254635的博客
02-06 1187
Springboot项目报文加密（AES、RSA、Filter动态加密）
SpringBoot-RSA加密
weixin_45716754的博客
03-29 2631
最近由于工作业务的需要，需要对指定的字段信息进行非对称加解密；由于需要加密的内容过于庞大；自己执行程序会出现：Data must not be longer than 117 bytes 的异常错误；现在自己将自己的解决方法总结如下；参照：https://www.cnblogs.com/songweipeng/p/16565495.html。二、对配置文件中的rsa-key属性获取。三、RSAUtil工具类的编写。
SpringBoot通过RSA实现用户名和密码的加密和解密
qq_36735969的博客
05-18 7258
RSA加密和解密示例。
Spring-boot如何使用RSA加密
热门推荐
T_Antry
10-20 1万+
RSA加密一、什么是RSA加密？二、如何使用RSA1.生成私钥和公钥2.将生成的秘钥放到application.properties中3.前端请求公钥4.后端随机获取公钥给前端5.前端加密Ajax发送（登录为例）6.后端解密（登录为例） 一、什么是RSA加密？ RSA加密算法是一种非对称加密算法。 由后端生成公钥和私钥，公钥和私钥为一对一的关系。 将公钥传给前端，前端：公钥+value生成密文。 后端拿到密文时，取出私钥：密文 - 私钥 = value 通过这样的形式将传输内容保密。 二、如何使用RSA
java RSA 加密 解密
阿O、不拽
05-30 275
java RSA加密解密 该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar注意：RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常： Exception in thread "main" javax.crypto.Ille...
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
C#RSA加密DEMO
03-25
根据JAVA提供的公钥，进行RSA加密示例
前端 RSA分段加密算法
03-31
RSA非对称加密，前端加解密算法代码。公钥明文，私钥各自保存，公钥加密，私钥解密。 RSA分段加密 适用于加密长度超标，可用于图片base64等大长度内容加密。
unity工具类RSA加密和解密
11-04
unity工具类RSA加密和解密
快速构建Spring boot项目
Fxdll的博客
04-22 601
2、运行4、开发环境热部署查看目前已有的依赖。
# 使用 spring boot 时，@Autowired 注解 自动装配注入时，变量报红解决方法：
最新发布
段子手168的博客
04-29 192
# 使用 spring boot 时，@Autowired 注解 自动装配注入时，变量报红解决方法：
spring boot的项目+nginx,怎么预防点击劫持(clicekJacking)
keyboard专栏
04-23 641
通过这些措施，你可以在Spring Boot和Nginx层面有效防御点击劫持攻击。综合使用这些技术能够确保你的应用不仅安全，还能适应各种不同的部署环境和安全需求。这样的配置不仅增加了安全性，也提高了应用的健壮性。
Spring Boot集成Mybatis Plus快速入门Demo
HBLOG
04-22 891
1.什么事Mybatis Plus？MyBatis-Plus(opens new window)（简称 MP）是一个MyBatis(opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。特性无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作强...
springboot中rsa加密
08-30
在Spring Boot中使用RSA加密的步骤如下： 1. 首先，生成私钥和公钥。可以使用Java内置的KeyPairGenerator类来生成RSA密钥对，分别得到私钥和公钥。 2. 将生成的密钥放到application.properties文件中，可以使用spring-boot-starter-security等相关框架来管理密钥。 3. 前端发送请求时，向后端请求公钥。后端会随机获取公钥并将其返回给前端。 4. 前端使用开源的jsencrypt.js库来对需要加密的数据（例如密码）进行加密。加密完成后，将加密后的数据传输到后端。 5. 后端接收到加密的数据后，使用私钥进行解密操作。 所以，使用RSA加密在Spring Boot中的步骤主要包括生成密钥、传输公钥至前端、前端加密数据传输至后端、后端使用私钥解密。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Springboot项目报文加密（采用AES、RSA动态加密策略）](https://download.csdn.net/download/qq_38254635/87620796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [Spring-boot如何使用RSA加密](https://blog.csdn.net/qq_39150049/article/details/109191120)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [SpringBoot通过RSA实现用户名和密码的加密和解密](https://blog.csdn.net/qq_36735969/article/details/124842616)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值