Spring Boot 安全 API 构建之加密解密功能的实践记录

巩婉仪

目录

• 一、描述
• 1、选择合适的加密算法
• 2、密钥管理
• 3、数据加密
• 4、防止加密漏洞
• 5、安全日志记录
• 6、测试和监控
• 二、RSA加密解密实现步骤
• 第一种写法
• 1. 配置Spring Boot的依赖
• 2. 配置RSA密钥
• 3. 读取配置并初始化密钥
• 4. 使用RSA密钥进行加密和解密
• 5. 测试加密和解密
• 第二种写法
• 1、创建RSA工具类
• 2、创建Spring Boot控制器
• 3、测试RSA加密和解密
• 三、AES加密解密实现步骤
• 1. 创建Spring Boot项目
• 2. 添加AES加密解密工具类
• 3. 创建控制器来处理加密和解密请求
• 4. 启动Spring Boot应用程序
• 5. 测试API
• 注意事项

一、描述

在当前的数字化时代背景下，数据安全已成为企业绝不可忽视的关键领域。为了确保数据传输的牢固安全性，对API接口实施加密处理成为了必不可少的一环。本文将阐述如何在Spring Boot 3.3环境中迅速落实API加密的最佳方案，具体采用RSA非对称加密算法进行说明。

1、选择合适的加密算法

• 对称加密：如 AES（Advanced Encryption Standard），适用于大量数据的快速加密和解密，但需要安全地管理密钥。
• 非对称加密：如 RSA（Rivest-Shamir-Adleman），使用公钥和私钥对，公钥用于加密，私钥用于解密，适合加密少量数据和密钥交换。

2、密钥管理

• 生成强密钥：使用安全的随机数生成器来生成密钥，确保密钥的随机性和强度。
• 安全存储：将密钥存储在安全的地方，如密钥管理系统或加密的配置文件中。避免将密钥硬编码在代码中。
• 密钥更新：定期更新密钥，以降低密钥被破解的风险。

3、数据加密

• 对敏感数据加密：如用户密码、个人信息等，在存储和传输过程中进行加密。
• 端到端加密：如果可能，实现端到端加密，确保数据在整个传输过程中都是加密的，只有发送方和接收方能够解密。
• 加密传输：使用 HTTPS 确保数据在网络传输过程中的安全。Spring Boot 3 可以很容易地配置 HTTPS。

4、防止加密漏洞

• 避免弱加密算法：不要使用已被破解或不安全的加密算法。
• 防止加密错误配置：仔细配置加密库和框架，避免错误的配置导致安全漏洞。
• 输入验证：对加密输入进行严格的验证，防止恶意输入导致加密失败或安全漏洞。

5、安全日志记录

• 记录加密相关事件：如密钥生成、加密和解密操作等，以便进行审计和故障排除。
• 保护日志安全：确保日志文件的安全存储，防止敏感信息泄露。

6、测试和监控

• 安全测试：进行安全测试，包括加密功能的测试，以确保加密的正确性和安全性。
• 监控异常：监控加密相关的异常情况，如加密失败、密钥泄露等，并及时采取措施。

二、RSA加密解密实现步骤

第一种写法

1. 配置Spring Boot的依赖

以下是一个基本的pom.xml文件：

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4. <modelVersion>4.0.0</modelVersion>
5. <groupId>com.example</groupId>
6. <artifactId>spring-boot-rsa</artifactId>
7. <version>0.0.1-SNAPSHOT</version>
8. <packaging>jar</packaging>
9. <name>spring-boot-rsa</name>
10. <description>Demo project for Spring Boot RSA encryption and decryption</description>
11. <parent>
12. <groupId>org.springframework.boot</groupId>
13. <artifactId>spring-boot-starter-parent</artifactId>
14. <version>3.0.0</version>
15. <relativePath/> <!-- lookup parent from repository -->
16. </parent>
17. <dependencies>
18. <dependency>
19. <groupId>org.springframework.boot</groupId>
20. <artifactId>spring-boot-starter-web</artifactId>
21. </dependency>
22. <dependency>
23. <groupId>org.springframework.boot</groupId>
24. <artifactId>spring-boot-starter-test</artifactId>
25. <scope>test</scope>
26. </dependency>
27. <!-- 其他依赖项可以根据需要添加 -->
28. </dependencies>
29. <build>
30. <plugins>
31. <plugin>
32. <groupId>org.springframework.boot</groupId>
33. <artifactId>spring-boot-maven-plugin</artifactId>
34. </plugin>
35. </plugins>
36. </build>
37. </project>

复制代码

2. 配置RSA密钥

首先，在

1. application.yml

复制代码

文件中配置RSA公钥和私钥。注意，由于密钥可能很长，你可能需要适当地换行或使用YAML的多行字符串语法。

1. rsa:
2. open: true # 是否开启加密
3. showLog: true # 是否打印加解密日志
4. publicKey: '你的RSA公钥' # RSA公钥，软件生成
5. privateKey: '你的RSA私钥' # RSA私钥，软件生成

复制代码

注意：在实际应用中，请不要将密钥硬编码在配置文件中，特别是私钥。应该使用更安全的方式来管理密钥，比如环境变量、密钥管理服务（KMS）或安全的配置文件存储。

3. 读取配置并初始化密钥

接下来，在Spring Boot应用中读取这些配置，并初始化RSA密钥。

1. import org.springframework.beans.factory.annotation.Value;
2. import org.springframework.context.annotation.Bean;
3. import org.springframework.context.annotation.Configuration;
4. import java.security.KeyFactory;
5. import java.security.PrivateKey;
6. import java.security.PublicKey;
7. import java.security.spec.PKCS8EncodedKeySpec;
8. import java.security.spec.X509EncodedKeySpec;
9. import java.util.Base64;
10. @Configuration
11. public class RsaConfig {
12. @Value("${rsa.publicKey}")
13. private String publicKey;
14. @Value("${rsa.privateKey}")
15. private String privateKey;
16. @Bean
17. public PublicKey rsaPublicKey() throws Exception {
18. byte[] keyBytes = Base64.getDecoder().decode(publicKey.getBytes());
19. X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
20. KeyFactory kf = KeyFactory.getInstance("RSA");
21. return kf.generatePublic(spec);
22. }
23. @Bean
24. public PrivateKey rsaPrivateKey() throws Exception {
25. byte[] keyBytes = Base64.getDecoder().decode(privateKey.getBytes());
26. PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
27. KeyFactory kf = KeyFactory.getInstance("RSA");
28. return kf.generatePrivate(spec);
29. }
30. }

复制代码

4. 使用RSA密钥进行加密和解密

现在，你可以在服务类中使用这些密钥进行加密和解密操作。

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.stereotype.Service;
3. import javax.crypto.Cipher;
4. import java.security.PrivateKey;
5. import java.security.PublicKey;
6. import java.util.Base64;
7. @Service
8. public class RsaService {
9. private final PublicKey publicKey;
10. private final PrivateKey privateKey;
11. @Autowired
12. public RsaService(PublicKey publicKey, PrivateKey privateKey) {
13. this.publicKey = publicKey;
14. this.privateKey = privateKey;
15. }
16. public String encrypt(String data) throws Exception {
17. Cipher cipher = Cipher.getInstance("RSA");
18. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
19. byte[] encryptedBytes = cipher.doFinal(data.getBytes());
20. return Base64.getEncoder().encodeToString(encryptedBytes);
21. }
22. public String decrypt(String encryptedData) throws Exception {
23. Cipher cipher = Cipher.getInstance("RSA");
24. cipher.init(Cipher.DECRYPT_MODE, privateKey);
25. byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
26. return new String(decryptedBytes);
27. }
28. }

复制代码

5. 测试加密和解密

最后，你可以编写一个简单的控制器或测试类来验证加密和解密功能是否正常工作。

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.web.bind.annotation.GetMapping;
3. import org.springframework.web.bind.annotation.RequestParam;
4. import org.springframework.web.bind.annotation.RestController;
5. @RestController
6. public class RsaController {
7. private final RsaService rsaService;
8. @Autowired
9. public RsaController(RsaService rsaService) {
10. this.rsaService = rsaService;
11. }
12. @GetMapping("/encrypt")
13. public String encrypt(@RequestParam String data) throws Exception {
14. return rsaService.encrypt(data);
15. }
16. @GetMapping("/decrypt")
17. public String decrypt(@RequestParam String encryptedData) throws Exception {
18. return rsaService.decrypt(encryptedData);
19. }
20. }

复制代码

现在，你可以启动Spring Boot应用，并通过访问

1. /encrypt

复制代码

和

1. /decrypt

复制代码

端点来测试RSA加密和解密功能。请确保在测试过程中使用合适的密钥对，并且不要在生产环境中暴露私钥。

第二种写法

1、创建RSA工具类

创建一个RSA工具类来处理加密和解密操作。这个类将包含生成密钥对、加密和解密的方法。

1. package com.example.springbootrsa.util;
2. import javax.crypto.Cipher;
3. import java.security.KeyFactory;
4. import java.security.KeyPair;
5. import java.security.KeyPairGenerator;
6. import java.security.PrivateKey;
7. import java.security.PublicKey;
8. import java.security.spec.PKCS8EncodedKeySpec;
9. import java.security.spec.X509EncodedKeySpec;
10. import java.util.Base64;
11. public class RSAUtil {
12. // 生成密钥对
13. public static KeyPair generateKeyPair() throws Exception {
14. KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
15. keyGen.initialize(2048);
16. return keyGen.generateKeyPair();
17. }
18. // 公钥加密
19. public static String encrypt(String data, PublicKey publicKey) throws Exception {
20. Cipher cipher = Cipher.getInstance("RSA");
21. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
22. byte[] encryptedBytes = cipher.doFinal(data.getBytes("UTF-8"));
23. return Base64.getEncoder().encodeToString(encryptedBytes);
24. }
25. // 私钥解密
26. public static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {
27. Cipher cipher = Cipher.getInstance("RSA");
28. cipher.init(Cipher.DECRYPT_MODE, privateKey);
29. byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
30. return new String(decryptedBytes, "UTF-8");
31. }
32. // 公钥字符串表示
33. public static String getPublicKeyString(PublicKey publicKey) {
34. return Base64.getEncoder().encodeToString(publicKey.getEncoded());
35. }
36. // 私钥字符串表示
37. public static String getPrivateKeyString(PrivateKey privateKey) {
38. return Base64.getEncoder().encodeToString(privateKey.getEncoded());
39. }
40. // 从字符串重建公钥
41. public static PublicKey getPublicKeyFromString(String key) throws Exception {
42. byte[] keyBytes = Base64.getDecoder().decode(key);
43. X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
44. KeyFactory keyFactory = KeyFactory.getInstance("RSA");
45. return keyFactory.generatePublic(spec);
46. }
47. // 从字符串重建私钥
48. public static PrivateKey getPrivateKeyFromString(String key) throws Exception {
49. byte[] keyBytes = Base64.getDecoder().decode(key);
50. PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
51. KeyFactory keyFactory = KeyFactory.getInstance("RSA");
52. return keyFactory.generatePrivate(spec);
53. }
54. }

复制代码

2、创建Spring Boot控制器

创建一个简单的Spring Boot控制器来演示如何使用RSA加密和解密

1. package com.example.springbootrsa.controller;
2. import com.example.springbootrsa.util.RSAUtil;
3. import org.springframework.web.bind.annotation.*;
4. import java.security.KeyPair;
5. @RestController
6. @RequestMapping("/api")
7. public class RSAController {
8. private KeyPair keyPair;
9. public RSAController() throws Exception {
10. this.keyPair = RSAUtil.generateKeyPair();
11. }
12. @GetMapping("/encrypt")
13. public String encrypt(@RequestParam String data) throws Exception {
14. return RSAUtil.encrypt(data, keyPair.getPublic());
15. }
16. @GetMapping("/decrypt")
17. public String decrypt(@RequestParam String encryptedData) throws Exception {
18. return RSAUtil.decrypt(encryptedData, keyPair.getPrivate());
19. }
20. @GetMapping("/publicKey")
21. public String getPublicKey() {
22. try {
23. return RSAUtil.getPublicKeyString(keyPair.getPublic());
24. } catch (Exception e) {
25. e.printStackTrace();
26. return null;
27. }
28. }
29. @GetMapping("/privateKey")
30. public String getPrivateKey() {
31. try {
32. return RSAUtil.getPrivateKeyString(keyPair.getPrivate());
33. } catch (Exception e) {
34. e.printStackTrace();
35. return null;
36. }
37. }
38. }

复制代码

3、测试RSA加密和解密

现在，您可以运行Spring Boot应用程序，并通过访问以下端点来测试RSA加密和解密：

• 获取公钥：
  1. GET /api/publicKey

  复制代码
• 获取私钥：
  1. GET /api/privateKey

  复制代码
  （请注意，在生产环境中，私钥应该保密）
• 加密数据：
  1. GET /api/encrypt?data=yourData

  复制代码
• 解密数据：
  1. GET /api/decrypt?encryptedData=yourEncryptedData

  复制代码

三、AES加密解密实现步骤

1. 创建Spring Boot项目

你可以使用Spring Initializr创建一个新的Spring Boot项目，选择以下依赖项：

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4. <modelVersion>4.0.0</modelVersion>
5. <groupId>com.example</groupId>
6. <artifactId>spring-boot-rsa</artifactId>
7. <version>0.0.1-SNAPSHOT</version>
8. <packaging>jar</packaging>
9. <name>spring-boot-rsa</name>
10. <description>Demo project for Spring Boot RSA encryption and decryption</description>
11. <parent>
12. <groupId>org.springframework.boot</groupId>
13. <artifactId>spring-boot-starter-parent</artifactId>
14. <version>3.0.0</version>
15. <relativePath/> <!-- lookup parent from repository -->
16. </parent>
17. <dependencies>
18. <dependency>
19. <groupId>org.springframework.boot</groupId>
20. <artifactId>spring-boot-starter-web</artifactId>
21. </dependency>
22. <dependency>
23. <groupId>org.springframework.boot</groupId>
24. <artifactId>spring-boot-starter-test</artifactId>
25. <scope>test</scope>
26. </dependency>
27. <!-- 其他依赖项可以根据需要添加 -->
28. </dependencies>
29. <build>
30. <plugins>
31. <plugin>
32. <groupId>org.springframework.boot</groupId>
33. <artifactId>spring-boot-maven-plugin</artifactId>
34. </plugin>
35. </plugins>
36. </build>
37. </project>

复制代码

2. 添加AES加密解密工具类

首先，我们需要一个工具类来处理AES加密和解密操作。

1. package com.example.demo.util;
2. import javax.crypto.Cipher;
3. import javax.crypto.KeyGenerator;
4. import javax.crypto.SecretKey;
5. import javax.crypto.spec.SecretKeySpec;
6. import java.util.Base64;
7. public class AESUtil {
8. // 生成AES密钥
9. public static SecretKey generateKey(int n) throws Exception {
10. KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
11. keyGenerator.init(n);
12. SecretKey secretKey = keyGenerator.generateKey();
13. return secretKey;
14. }
15. // 将密钥转换为字符串
16. public static String encodeKey(SecretKey key) {
17. return Base64.getEncoder().encodeToString(key.getEncoded());
18. }
19. // 将字符串转换为密钥
20. public static SecretKey decodeKey(String encodedKey) {
21. byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
22. return new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
23. }
24. // 加密
25. public static String encrypt(String data, SecretKey key) throws Exception {
26. Cipher cipher = Cipher.getInstance("AES");
27. cipher.init(Cipher.ENCRYPT_MODE, key);
28. byte[] encryptedData = cipher.doFinal(data.getBytes("UTF-8"));
29. return Base64.getEncoder().encodeToString(encryptedData);
30. }
31. // 解密
32. public static String decrypt(String encryptedData, SecretKey key) throws Exception {
33. Cipher cipher = Cipher.getInstance("AES");
34. cipher.init(Cipher.DECRYPT_MODE, key);
35. byte[] decodedData = Base64.getDecoder().decode(encryptedData);
36. byte[] decryptedData = cipher.doFinal(decodedData);
37. return new String(decryptedData, "UTF-8");
38. }
39. }

复制代码

3. 创建控制器来处理加密和解密请求

接下来，我们创建一个Spring Boot控制器来处理加密和解密请求。

1. package com.example.demo.controller;
2. import com.example.demo.util.AESUtil;
3. import org.springframework.web.bind.annotation.*;
4. import javax.crypto.SecretKey;
5. import java.util.HashMap;
6. import java.util.Map;
7. @RestController
8. @RequestMapping("/api")
9. public class AESController {
10. // 用于存储密钥的变量（在实际应用中，密钥应该安全存储）
11. private static SecretKey secretKey;
12. static {
13. try {
14. secretKey = AESUtil.generateKey(256); // 256位AES密钥
15. } catch (Exception e) {
16. e.printStackTrace();
17. }
18. }
19. @GetMapping("/encrypt")
20. public Map<String, String> encrypt(@RequestParam String data) {
21. Map<String, String> response = new HashMap<>();
22. try {
23. String encryptedData = AESUtil.encrypt(data, secretKey);
24. response.put("encryptedData", encryptedData);
25. } catch (Exception e) {
26. response.put("error", e.getMessage());
27. }
28. return response;
29. }
30. @GetMapping("/decrypt")
31. public Map<String, String> decrypt(@RequestParam String encryptedData) {
32. Map<String, String> response = new HashMap<>();
33. try {
34. String decryptedData = AESUtil.decrypt(encryptedData, secretKey);
35. response.put("decryptedData", decryptedData);
36. } catch (Exception e) {
37. response.put("error", e.getMessage());
38. }
39. return response;
40. }
41. @GetMapping("/key")
42. public Map<String, String> getKey() {
43. Map<String, String> response = new HashMap<>();
44. try {
45. String encodedKey = AESUtil.encodeKey(secretKey);
46. response.put("encodedKey", encodedKey);
47. } catch (Exception e) {
48. response.put("error", e.getMessage());
49. }
50. return response;
51. }
52. }

复制代码

4. 启动Spring Boot应用程序

确保你的

1. application.properties

复制代码

或

1. application.yml

复制代码

文件配置正确，然后运行Spring Boot应用程序。

5. 测试API

你可以使用浏览器或工具（如Postman）来测试这些API。

• 获取密钥：GET http://localhost:8080/api/key
• 加密数据：GET http://localhost:8080/api/encrypt?data=HelloWorld
• 解密数据：GET http://localhost:8080/api/decrypt?encryptedData=

注意事项

• 密钥管理：在实际应用中，密钥应该安全存储和管理，不要硬编码在代码中。
• 异常处理：在生产代码中，应该有更完善的异常处理机制。
• HTTPS：确保你的API通过HTTPS进行通信，以保护传输中的数据。

到此这篇关于Spring Boot 安全 API 构建：加密解密功能的卓越实践的文章就介绍到这了,更多相关Spring Boot API 加密解密内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

家娅硕

顶顶更健康！！！

般若波罗蜜176

路过，支持一下

国怡月

感谢楼主，顶。