SpringBoot 如何保证接口安全？老鸟们都是这么玩的

Posted 2023-04-14 qian-fen

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot 如何保证接口安全？老鸟们都是这么玩的相关的知识，希望对你有一定的参考价值。

一.为什么要保证接口安全？

接口安全至关重要，因为在今天的数字时代中，许多系统和应用程序都需要通过网络进行数据交换。如果这些接口存在安全漏洞，黑客或攻击者可能会利用这些漏洞来获取敏感信息或破坏系统。因此，保证接口的安全性是非常重要的。

以下是小岳给大家提供的一个生活案例，可以帮助大家更好地理解接口安全的重要性：

假设你是一家银行的客户，并在网上银行上使用了该银行的API（应用程序接口）来进行转账。如果这个API没有进行适当的安全性检查，攻击者可以轻松地获取您的个人信息并执行未经授权的转账操作。这将对您的资金和信用造成重大损失。

看完上面的解释，大家是不是有点眉目啦，那么现在让我们来看一个基于Java的代码案例，说明如何保证接口的安全性。在这个案例中，我们将使用Spring Security框架来保护一个RESTful API。

首先，我们需要添加Spring Security依赖项到我们的项目中：

<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-web</artifactId>
<version>5.5.0</version>
</dependency>

然后，我们可以创建一个类来配置Spring Security：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter 

@Override
protected void configure(HttpSecurity http) throws Exception 
http.csrf().disable()
.authorizeRequests()
.antMatchers(HttpMethod.POST, "/api/**").authenticated()
.anyRequest().permitAll()
.and()
.httpBasic();


@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception 
auth.inMemoryAuthentication()
.withUser("user")
.password("nooppassword")
.roles("USER");

在这个配置类中，我们禁用了跨站请求伪造（CSRF）保护，只允许经过身份验证的用户访问POST请求的API端点，允许所有其他请求访问。我们还配置了一个内存身份验证，其中我们创建一个用户（用户名为"user"，密码为"password"），并为其分配了一个"USER"角色。

这些步骤可以确保我们的API受到安全保护，只有经过身份验证的用户才能访问受保护的端点。这可以防止未经授权的访问和潜在的攻击。

总之，接口安全是非常重要的，我们应该采取措施来保护我们的接口。通过在Java中使用Spring Security框架，我们可以确保我们的API受到保护并只允许经过身份验证的用户访问。

二.如何保证接口安全？

Spring Boot 可以通过多种方式保证接口安全，以下是一些常用的方法：

1.认证和授权

使用 Spring Security 来实现认证和授权功能。可以配置基于角色或权限的访问控制规则，确保只有授权用户可以访问特定的接口。例如，在一个银行应用程序中，只有经过身份验证并具有特定角色的用户才能访问银行账户的信息。

2.输入验证

通过对请求参数和输入数据的验证，防止非法或恶意数据的注入。例如，在一个电子商务应用程序中，应该验证收到的订单数据是否包含有效的产品 ID，数量和价格。

3.加密和解密

使用加密技术来确保数据在传输过程中的安全性。例如，在一个医疗保健应用程序中，患者的个人和医疗信息应该使用 SSL/TLS 或其他加密技术来传输。

4.安全日志记录

记录所有请求和响应，以便在发生安全事件时进行跟踪和审计。例如，在一个政府应用程序中，所有的数据请求和响应应该被记录下来，以便进行安全审计。

5.案例

下面是一个基于 Spring Security 的简单例子，用来验证用户是否具有 ADMIN 角色，以允许用户访问受保护的接口：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter 

@Override
protected void configure(HttpSecurity http) throws Exception 
http.authorizeRequests()
.antMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
.and()
.formLogin()
.and()
.httpBasic();


@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception 
auth.inMemoryAuthentication()
.withUser("user").password("nooppassword").roles("USER")
.and()
.withUser("admin").password("nooppassword").roles("ADMIN");

该代码使用WebSecurityConfigurerAdapter配置Spring Security。它指定了基于角色的访问控制规则，并使用基本认证和表单认证提供身份验证功能。它还指定了内存身份验证，以便在没有实际用户数据库的情况下进行身份验证。

综上所述，Spring Boot提供了多种方法来保证接口安全，包括认证和授权、输入验证、加密和解密、安全日志记录等。结合不同的应用场景，开发者可以选择适合自己应用的安全策略。

三. 使用认证和授权保证接口安全

SpringBoot是一个快速开发的Java框架，可以方便地实现认证和授权，保证接口的安全性。下面小岳会结合一个生活案例和Java代码来给朋友们分析如何实现认证和授权。

生活案例：

假设有一个在线购物网站，用户需要登录才能查看自己的订单和个人信息，而管理员则需要登录才能管理商品和订单。为了保证网站的安全性，需要对用户和管理员进行认证和授权。

Java代码实现如下：

1.配置Spring Security依赖

首先在pom.xml文件中添加Spring Security依赖：

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

2.配置Spring Security

在SpringBoot的配置文件application.yml中添加Spring Security的配置。

spring:
security:
user:
name: admin
password: admin123
# 配置不需要认证的url
ignored: /css/**,/js/**

其中，配置了一个管理员账号admin和密码admin123，以及不需要认证的静态资源路径。

3.实现认证和授权

创建一个SecurityConfig类，用于配置Spring Security：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter 

@Override
protected void configure(HttpSecurity http) throws Exception 
http
.authorizeRequests()
.antMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.permitAll()
.and()
.logout()
.permitAll();


@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception 
auth
.inMemoryAuthentication()
.withUser("user").password("user123").roles("USER")
.and()
.withUser("admin").password("admin123").roles("ADMIN");

其中，configure方法用于配置URL的访问权限，这里配置了/admin/**路径需要ADMIN角色才能访问，其他路径需要认证后才能访问。同时，配置了登录页面和注销页面。
configureGlobal方法用于配置用户的认证信息，这里使用inMemoryAuthentication方法将用户的认证信息存储在内存中，分别添加了一个普通用户user和管理员admin。

小结：

通过SpringBoot的Spring Security模块，我们可以轻松地实现认证和授权，保证接口的安全性。

在实际开发中，可以根据需要配置不同的认证和授权方式，如基于数据库的认证和授权、基于Token的认证和授权，当然基于Token的这种方式也深受大家喜爱，所以接下来就给大家带来一个使用JWT的Spring Boot示例：

基于Token的这种认证方式基于JWT（JSON Web Token），可以用于保护REST API接口。JWT是一种安全的JSON格式，可以存储用户身份信息和授权信息，以确保只有合法的用户才能访问API接口。

在Spring Boot中，可以使用Spring Security和JWT来实现基于Token的认证和授权。可以通过以下步骤实现：

导入Spring Security和JWT依赖。
创建一个JWT Token的生成器。
在Spring Security配置文件中添加JWT相关配置。
在控制器中添加JWT认证和授权注解。

代码示例如下：

// 导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>

// 创建JWT Token生成器
public class JwtTokenUtil 
private static final String SECRET_KEY = "mysecretkey";
private static final long EXPIRATION_TIME = 864_000_000; // 10天

public static String generateToken(String username) 
Date now = new Date();
Date expiration = new Date(now.getTime() + EXPIRATION_TIME);

return Jwts.builder()
.setSubject(username)
.setIssuedAt(now)
.setExpiration(expiration)
.signWith(SignatureAlgorithm.HS256, SECRET_KEY)
.compact();


public static String getUsernameFromToken(String token) 
return Jwts.parser()
.setSigningKey(SECRET_KEY)
.parseClaimsJws(token)
.getBody()
.getSubject();



// 添加JWT相关配置到Spring Security配置文件中
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter 
@Override
protected void configure(HttpSecurity http) throws Exception 
http.csrf().disable()
.authorizeRequests()
.antMatchers("/api/**").authenticated()
.and()
.addFilterBefore(new JwtAuthenticationFilter(),
UsernamePasswordAuthenticationFilter.class);


@Bean
public JwtAuthenticationProvider jwtAuthenticationProvider() 
return new JwtAuthenticationProvider();


// 在控制器中添加JWT认证和授权注
@RestController
@RequestMapping("/api")
public class UserController 
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginForm loginForm) 
// 验证用户名和密码
// 生成JWT Token
String token = JwtTokenUtil.generateToken(username);
return ResponseEntity.ok(token);


@GetMapping("/user")
@JwtAuth
public ResponseEntity<?> getUserInfo() 
// 获取用户信息
return ResponseEntity.ok(userInfo);

四. 使用输入验证的方式保证接口安全

Spring Boot 提供了许多内置的验证注解和工具来保证接口的安全性。在处理输入数据时，开发人员可以使用这些注解和工具来验证输入数据的合法性，从而避免可能的安全漏洞。

下面是小岳给大家带来的一个代码分析，大家跟着我一起来看看吧！

假设我们正在开发一个简单的登录接口，需要对用户名和密码进行验证：

@RestController
public class LoginController 

@PostMapping("/login")
public ResponseEntity<String> login(@Valid @RequestBody LoginForm loginForm) 
// 验证成功，返回登录成功信息
return ResponseEntity.ok("Login successful!");



@Data
public class LoginForm 
@NotBlank(message = "用户名不能为空")
private String username;

@NotBlank(message = "密码不能为空")
private String password;

上面的代码中，我们定义了一个LoginForm类来表示用户的登录信息，使用了@NotBlank注解来确保用户名和密码都不为空。在LoginController中的login方法中，我们使用@Valid注解来触发数据验证，并通过ResponseEntity来返回结果。

当请求到达该接口时，Spring Boot会自动检查请求体中的数据是否符合LoginForm的定义，并且检查是否满足@NotBlank的条件。如果任何一个条件未满足，Spring Boot将抛出MethodArgumentNotValidException异常，并将错误信息返回给客户端。

例如，如果我们使用以下请求体进行请求：


"username": "",
"password": ""

Spring Boot 将返回以下响应：


"timestamp": "2023-04-12T00:00:00.000+00:00",
"status": 400,
"error": "Bad Request",
"message": "Validation failed for object=\'loginForm\'. Error count: 2",
"path": "/login",
"errors": [

"field": "username",
"message": "用户名不能为空"
,

"field": "password",
"message": "密码不能为空"

]

这表明用户名和密码都不能为空，因为我们在LoginForm中使用了@NotBlank注解来验证这些字段。

总之，通过使用 Spring Boot 提供的内置验证注解和工具，我们可以轻松地保证输入数据的合法性，并减少安全漏洞的可能性。

五. 使用加密和解密保证接口安全

Spring Boot提供了多种加密和解密的方式来保证接口的安全性，其中最常用的方式是使用对称加密算法和非对称加密算法。对称加密算法指的是发送方和接收方使用相同的密钥来加密和解密数据，常见的对称加密算法有DES、AES等。非对称加密算法指的是发送方和接收方使用不同的密钥来加密和解密数据，常见的非对称加密算法有RSA、DSA等。

下面小岳给大家用一个通俗易懂的例子跟大家解释一番，因为有些同学可能已经看懵了！

假设我们现在要开发一个在线银行系统，需要保证用户的敏感信息如账号、密码等在传输过程中不被黑客截取和窃取。这时我们可以使用AES对称加密算法来加密用户的敏感信息，在服务器端使用相同的密钥来解密信息并进行处理，这样就能够保证数据传输的安全性。

好啦，看上上面的解释，接下来我们就用一个代码案例来带大家具体看一看吧：

使用AES对称加密算法进行加密：

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

public class AESEncryption 
private static final String ALGORITHM = "AES";
private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
private static final String KEY = "mysecretkey12345"; // 密钥，需要保密

public static String encrypt(String data) throws Exception 
SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes("UTF-8"), ALGORITHM);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.ENCRYPT_MODE, keySpec);
byte[] encrypted = cipher.doFinal(data.getBytes());
return Base64.encodeBase64String(encrypted);

使用AES对称加密算法进行解密：

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

public class AESDecryption 
private static final String ALGORITHM = "AES";
private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
private static final String KEY = "mysecretkey12345"; // 密钥，需要保密

public static String decrypt(String encryptedData) throws Exception 
SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes("UTF-8"), ALGORITHM);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.DECRYPT_MODE, keySpec);
byte[] decrypted = cipher.doFinal(Base64.decodeBase64(encryptedData));
return new String(decrypted);

小结：

Spring Boot提供了多种加密和解密的方式来保证接口的安全性，常用的方式有对称加密算法和非对称加密算法。在实际开发中，需要根据具体业务场景选择合适的加密方式，同时需要保证密钥的安全性，避免密钥被黑客窃取导致数据泄露。

六. 使用安全日志记录保证接口安全

Spring Boot提供了一些内置的安全日志记录方式，可以帮助我们保证接口安全。下面介绍两种常见的安全日志记录方式。

1.Spring Security日志记录

Spring Security是Spring Boot中常用的安全框架，它提供了完善的安全认证和授权机制。Spring Security默认集成了日志记录功能，我们可以通过配置日志级别，来控制日志记录的详细程度。

例如，我们可以在application.properties中添加以下配置：

logging.level.org.springframework.security=DEBUG

这样就可以开启Spring Security的DEBUG级别日志记录，查看详细的安全认证和授权过程。

2.Spring Boot Actuator端点日志记录

Spring Boot Actuator是Spring Boot的一个子项目，提供了一系列的监控和管理功能。其中，端点（Endpoint）是Spring Boot Actuator的核心组件之一，它提供了一些RESTful接口，用于获取应用程序的状态信息、健康状况、性能指标等。我们可以通过配置端点的日志级别，来记录访问端点的请求和响应信息。

例如，我们可以在application.properties中添加以下配置：

logging.level.org.springframework.boot.actuate.endpoint=TRACE

这样就可以开启Spring Boot Actuator端点的TRACE级别日志记录，查看详细的请求和响应信息。

在实际应用中，我们可以结合生活案例来说明如何使用安全日志记录方式保证接口安全。例如，我们有一个在线购物网站，用户可以通过注册账号、添加商品到购物车、提交订单等操作来完成购物流程。为了保证购物过程的安全，我们可以记录以下信息。

用户的登录信息，包括用户名、登录时间、IP地址等。
用户的购物行为，包括添加商品到购物车、提交订单等操作。
购物过程中出现的异常情况，如库存不足、支付失败等。

下面小岳给大家带来一个代码案例，演示一番如何使用Spring Security日志记录功能：

@RestController
public class UserController 

@Autowired
private UserService userService;

@PostMapping("/login")
public ResponseEntity<String> login(@RequestBody UserLoginRequest request, HttpServletRequest httpServletRequest) 
String username = request.getUsername();
String password = request.getPassword();
userService.login(username, password);
String ip = httpServletRequest.getRemoteAddr();
String logMessage = String.format("User %s logged in from %s", username, ip);
Logger.getLogger(UserController.class.getName()).log(Level.INFO, logMessage);
return ResponseEntity.ok("Login successful");

在这个例子中，我们在用户登录的接口中，记录了用户的登录信息。具体地，我们通过HttpServletRequest获取用户的IP地址，然后使用Java标准库的Logger记录日志。可以看到，我们使用了Level.INFO级别，表示记录一般信息，如果需要记录更详细的信息，可以使用Level.DEBUG级别。

小结：

使用安全日志记录方式可以帮助我们保证接口的安全不仅可以提高程序的安全性，还可以有效保护敏感信息，但是在使用的时候也需要注意日志过多就会占用存储空间，增加我们系统的负担哦，不过总的来说：Spring Boot使用安全日志记录保证接口安全是一种有效的方法，但需要注意合理配置和管理，避免影响应用程序性能和泄露敏感信息。

七. 总结

至此，SpringBoot如何保证接口的问题就给大家回答完毕啦，大家一定要认真学习哦！
最后，给大家总结一下SpringBoot保证接口安全的好处有哪些吧：

●避免未经授权的用户访问受保护的接口，提高应用程序的安全性。
●防止攻击者注入恶意代码，保护用户数据的安全性。
●防止攻击者通过欺骗用户来执行未经授权的操作，保护用户账户的安全性。
●可以通过Spring Security的身份验证和授权机制来监控和管理用户访问受保护资源的权限，提高了应用程序的可控性和可维护性

Spring BootSpringBoot 如何保证接口安全？老鸟们都是这么玩的！

文章目录

前言
为什么要保证接口安全
防篡改
- 如何解决
防重放
- 基于timestamp的方案
- 基于nonce + timestamp 的方案
代码实现
总结

前言

如何保证接口安全？本文揭晓答案，请看下文。

为什么要保证接口安全

对于互联网来说，只要你系统的接口暴露在外网，就避免不了接口安全问题。如果你的接口在外网裸奔，只要让黑客知道接口的地址和参数就可以调用，那简直就是灾难。

举个例子：你的网站用户注册的时候，需要填写手机号，发送手机验证码，如果这个发送验证码的接口没有经过特殊安全处理，那这个短信接口早就被人盗刷不知道浪费多少钱了。

那如何保证接口安全呢？

一般来说，暴露在外网的api接口需要做到防篡改和防重放才能称之为安全的接口。

防篡改

我们知道http 是一种无状态的协议，服务端并不知道客户端发送的请求是否合法，也并不知道请求中的参数是否正确。

举个例子, 现在有个充值的接口，调用后可以给用户增加对应的余额。

http://localhost/api/user/recharge?user_id=1001&amount=10

如果非法用户通过抓包获取到接口参数后，修改user_id 或 amount的值就可以实现给任意账户添加余额的目的。

如何解决

采用https协议可以将传输的明文进行加密，但是黑客仍然可以截获传输的数据包，进一步伪造请求进行重放攻击。如果黑客使用特殊手段让请求方设备使用了伪造的证书进行通信，那么https加密的内容也会被解密。
一般的做法有2种：

采用https方式把接口的数据进行加密传输，即便是被黑客破解，黑客也花费大量的时间和精力去破解。
接口后台对接口的请求参数进行验证，防止被黑客篡改；

步骤1：客户端使用约定好的秘钥对传输的参数进行加密，得到签名值sign1，并且将签名值也放入请求的参数中，发送请求给服务端
步骤2：服务端接收到客户端的请求，然后使用约定好的秘钥对请求的参数再次进行签名，得到签名值sign2。
步骤3：服务端比对sign1和sign2的值，如果不一致，就认定为被篡改，非法请求。

防重放

防重放也叫防复用。简单来说就是我获取到这个请求的信息之后什么也不改,，直接拿着接口的参数去 重复请求这个充值的接口。此时我的请求是合法的, 因为所有参数都是跟合法请求一模一样的。重放攻击会造成两种后果：

针对插入数据库接口：重放攻击，会出现大量重复数据，甚至垃圾数据会把数据库撑爆。
针对查询的接口：黑客一般是重点攻击慢查询接口，例如一个慢查询接口1s，只要黑客发起重放攻击，就必然造成系统被拖垮，数据库查询被阻塞死。

对于重放攻击一般有两种做法：

基于timestamp的方案

每次HTTP请求，都需要加上timestamp参数，然后把timestamp和其他参数一起进行数字签名。因为一次正常的HTTP请求，从发出到达服务器一般都不会超过60s，所以服务器收到HTTP请求之后，首先判断时间戳参数与当前时间比较，是否超过了60s，如果超过了则认为是非法请求。

一般情况下，黑客从抓包重放请求耗时远远超过了60s，所以此时请求中的timestamp参数已经失效了。如果黑客修改timestamp参数为当前的时间戳，则sign1参数对应的数字签名就会失效，因为黑客不知道签名秘钥，没有办法生成新的数字签名。

但是这种方式的漏洞也是显而易见，如果在60s之内进行重放攻击，那就没办法了，所以这种方式不能保证请求仅一次有效。

老鸟们一般会采取下面这种方案，既可以解决接口重放问题，又可以解决一次请求有效的问题。

基于nonce + timestamp 的方案

nonce的意思是仅一次有效的随机字符串，要求每次请求时该参数要保证不同。实际使用用户信息+时间戳+随机数等信息做个哈希之后，作为nonce参数。
此时服务端的处理流程如下：

去 redis 中查找是否有 key 为 nonce:nonce 的 string
如果没有，则创建这个 key，把这个 key 失效的时间和验证 timestamp 失效的时间一致，比如是 60s。
如果有，说明这个 key 在 60s 内已经被使用了，那么这个请求就可以判断为重放请求。

这种方案nonce和timestamp参数都作为签名的一部分传到后端，基于timestamp方案可以让黑客只能在60s内进行重放攻击，加上nonce随机数以后可以保证接口只能被调用一次，可以很好的解决重放攻击问题。

代码实现

接下来以SpringBoot项目为例看看如何实现接口的防篡改和防重放功能。

1、构建请求头对象

@Data
@Builder
public class RequestHeader 
   private String sign ;
   private Long timestamp ;
   private String nonce;

2、工具类从HttpServletRequest获取请求参数

@Slf4j
@UtilityClass
public class HttpDataUtil 
    /**
     * post请求处理：获取 Body 参数，转换为SortedMap
     *
     * @param request
     */
    public  SortedMap<String, String> getBodyParams(final HttpServletRequest request) throws IOException 
        byte[] requestBody = StreamUtils.copyToByteArray(request.getInputStream());
        String body = new String(requestBody);
        return JsonUtil.json2Object(body, SortedMap.class);
    


    /**
     * get请求处理：将URL请求参数转换成SortedMap
     */
    public static SortedMap<String, String> getUrlParams(HttpServletRequest request) 
        String param = "";
        SortedMap<String, String> result = new TreeMap<>();

        if (StringUtils.isEmpty(request.getQueryString())) 
            return result;
        

        try 
            param = URLDecoder.decode(request.getQueryString(), "utf-8");
         catch (UnsupportedEncodingException e) 
            e.printStackTrace();
        

        String[] params = param.split("&");
        for (String s : params) 
            String[] array=s.split("=");
            result.put(array[0], array[1]);
        
        return result;

这里的参数放入SortedMap中对其进行字典排序，前端构建签名时同样需要对参数进行字典排序。

3、签名验证工具类

@Slf4j
@UtilityClass
public class SignUtil 
    /**
     * 验证签名
     * 验证算法：把timestamp + JsonUtil.object2Json(SortedMap)合成字符串，然后MD5
     */
    @SneakyThrows
    public  boolean verifySign(SortedMap<String, String> map, RequestHeader requestHeader) 
        String params = requestHeader.getNonce() + requestHeader.getTimestamp() + JsonUtil.object2Json(map);
        return verifySign(params, requestHeader);
    

    /**
     * 验证签名
     */
    public boolean verifySign(String params, RequestHeader requestHeader) 
        log.debug("客户端签名: ", requestHeader.getSign());
        if (StringUtils.isEmpty(params)) 
            return false;
        
        log.info("客户端上传内容: ", params);
        String paramsSign = DigestUtils.md5DigestAsHex(params.getBytes()).toUpperCase();
        log.info("客户端上传内容加密后的签名结果: ", paramsSign);
        return requestHeader.getSign().equals(paramsSign);

4、HttpServletRequest包装类

public class SignRequestWrapper extends HttpServletRequestWrapper 
    //用于将流保存下来
    private byte[] requestBody = null;

    public SignRequestWrapper(HttpServletRequest request) throws IOException 
        super(request);
        requestBody = StreamUtils.copyToByteArray(request.getInputStream());
    

    @Override
    public ServletInputStream getInputStream() throws IOException 
        final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);

        return new ServletInputStream() 
            @Override
            public boolean isFinished() 
                return false;
            

            @Override
            public boolean isReady() 
                return false;
            

            @Override
            public void setReadListener(ReadListener readListener) 

            

            @Override
            public int read() throws IOException 
                return bais.read();
            
        ;

    

    @Override
    public BufferedReader getReader() throws IOException 
        return new BufferedReader(new InputStreamReader(getInputStream()));

防篡改和防重放我们会通过SpringBoot Filter来实现，而编写的filter过滤器需要读取request数据流，但是request数据流只能读取一次，需要自己实现HttpServletRequestWrapper对数据流包装，目的是将request流保存下来。

5、创建过滤器实现安全校验

@Configuration
public class SignFilterConfiguration 
    @Value("$sign.maxTime")
    private String signMaxTime;

    //filter中的初始化参数
    private Map<String, String> initParametersMap =  new HashMap<>();

    @Bean
    public FilterRegistrationBean contextFilterRegistrationBean() 
        initParametersMap.put("signMaxTime",signMaxTime);
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(signFilter());
        registration.setInitParameters(initParametersMap);
        registration.addUrlPatterns("/sign/*");
        registration.setName("SignFilter");
        // 设置过滤器被调用的顺序
        registration.setOrder(1);
        return registration;
    

    @Bean
    public Filter signFilter() 
        return new SignFilter();

@Slf4j
public class SignFilter implements Filter 
    @Resource
    private RedisUtil redisUtil;

    //从fitler配置中获取sign过期时间
    private Long signMaxTime;

    private static final String NONCE_KEY = "x-nonce-";

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException 
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;

        log.info("过滤URL:", httpRequest.getRequestURI());

        HttpServletRequestWrapper requestWrapper = new SignRequestWrapper(httpRequest);
        //构建请求头
        RequestHeader requestHeader = RequestHeader.builder()
                .nonce(httpRequest.getHeader("x-Nonce"))
                .timestamp(Long.parseLong(httpRequest.getHeader("X-Time")))
                .sign(httpRequest.getHeader("X-Sign"))
                .build();

        //验证请求头是否存在
        if(StringUtils.isEmpty(requestHeader.getSign()) || ObjectUtils.isEmpty(requestHeader.getTimestamp()) || StringUtils.isEmpty(requestHeader.getNonce()))
            responseFail(httpResponse, ReturnCode.ILLEGAL_HEADER);
            return;
        

        /*
         * 1.重放验证
         * 判断timestamp时间戳与当前时间是否操过60s（过期时间根据业务情况设置）,如果超过了就提示签名过期。
         */
        long now = System.currentTimeMillis() / 1000;

        if (now - requestHeader.getTimestamp() > signMaxTime) 
            responseFail(httpResponse,ReturnCode.REPLAY_ERROR);
            return;
        

        //2. 判断nonce
        boolean nonceExists = redisUtil.hasKey(NONCE_KEY + requestHeader.getNonce());
        if(nonceExists)
            //请求重复
            responseFail(httpResponse,ReturnCode.REPLAY_ERROR);
            return;
        else 
            redisUtil.set(NONCE_KEY+requestHeader.getNonce(), requestHeader.getNonce(), signMaxTime);
        


        boolean accept;
        SortedMap<String, String> paramMap;
        switch (httpRequest.getMethod())
            case "GET":
                paramMap = HttpDataUtil.getUrlParams(requestWrapper);
                accept = SignUtil.verifySign(paramMap, requestHeader);
                break;
            case "POST":
                paramMap = HttpDataUtil.getBodyParams(requestWrapper);
                accept = SignUtil.verifySign(paramMap, requestHeader);
                break;
            default:
                accept = true;
                break;
        
        if (accept) 
            filterChain.doFilter(requestWrapper, servletResponse);
         else 
            responseFail(httpResponse,ReturnCode.ARGUMENT_ERROR);
            return;
        

    

    private void responseFail(HttpServletResponse httpResponse, ReturnCode returnCode)  
        ResultData<Object> resultData = ResultData.fail(returnCode.getCode(), returnCode.getMessage());
        WebUtils.writeJson(httpResponse,resultData);
    

    @Override
    public void init(FilterConfig filterConfig) throws ServletException 
        String signTime = filterConfig.getInitParameter("signMaxTime");
        signMaxTime = Long.parseLong(signTime);

6、Redis工具类

@Component
public class RedisUtil 
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) 
        try 
            return Boolean.TRUE.equals(redisTemplate.hasKey(key));
         catch (Exception e) 
            e.printStackTrace();
            return false;
        
    


    /**
     * 普通缓存放入并设置时间
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) 
        try 
            if (time > 0) 
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
             else 
                set(key, value);
            
            return true;
         catch (Exception e) 
            e.printStackTrace();
            return false;
        
    

    /**
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) 
        try 
            redisTemplate.opsForValue().set(key, value);
            return true;
         catch (Exception e) 
            e.printStackTrace();
            return false;

总结

一般来说，暴露在外网的api接口需要做到防篡改和防重放才能称之为安全的接口。希望对大家有帮助~欢迎评论区交流！

以上是关于SpringBoot 如何保证接口安全？老鸟们都是这么玩的的主要内容，如果未能解决你的问题，请参考以下文章

SpringBoot 如何保证接口安全？老鸟们都是这么玩的！

Spring BootSpringBoot 如何保证接口安全？老鸟们都是这么玩的！

SpringBoot 如何异步编程，老鸟们都这么玩的

SpringBoot 如何生成接口文档，老鸟们都这么玩的！

SpringBoot 如何保证接口安全？老鸟们都是这么玩的

一.为什么要保证接口安全？

二.如何保证接口安全？

1.认证和授权

2.输入验证

3.加密和解密

4.安全日志记录

5.案例

三. 使用认证和授权保证接口安全

生活案例：

Java代码实现如下：

小结：

四. 使用输入验证的方式保证接口安全

五. 使用加密和解密保证接口安全

使用AES对称加密算法进行加密：

小结：

六. 使用安全日志记录保证接口安全

1.Spring Security日志记录

2.Spring Boot Actuator端点日志记录

小结：

七. 总结

Spring BootSpringBoot 如何保证接口安全？老鸟们都是这么玩的！

文章目录

前言

为什么要保证接口安全

防篡改

如何解决

防重放

基于timestamp的方案

基于nonce + timestamp 的方案

代码实现

1、 构建请求头对象

2、工具类从HttpServletRequest获取请求参数

3、签名验证工具类

4、HttpServletRequest包装类

5、创建过滤器实现安全校验

6、Redis工具类

总结

1、构建请求头对象