第7章 Spring Security 的 REST API 与微服务安全（2024 最新版）（上）-阿里云开发者社区

7.1 保护 REST API

在数字化时代，REST API是现代Web应用和微服务架构中数据交互的关键组成部分。然而，随着它们的普及和重要性的增加，保护这些API免受恶意攻击变得尤为重要。本节将探讨保护REST API的基础知识和实用案例。

7.1.1 基础知识详解

在构建和维护REST API时，安全性是一个不容忽视的要素。REST API作为应用程序与外界交互的接口，常常面临着各种安全威胁，包括但不限于身份盗窃、数据泄露、服务拒绝攻击等。因此，采取有效的安全措施保护REST API是至关重要的。以下是保护REST API时需掌握的基础知识。

身份验证 (Authentication)

定义：确定请求者的身份，确保只有合法用户可以访问API。
方法：

基本认证：通过HTTP头传递用户名和密码的简单认证方法，需要使用HTTPS来避免凭证泄露。
令牌认证：如JWT，通过签名的令牌确认用户身份，支持无状态认证。
OAuth/OAuth2：为第三方应用提供限制的访问权限，而无需暴露用户的凭证。

授权 (Authorization)

定义：确定已认证的用户可以执行的操作或访问的数据。
实现方式：

角色基础的访问控制（RBAC）：根据用户的角色来决定其权限。
属性基础的访问控制（ABAC）：根据属性（用户属性、资源属性和环境属性）来动态决定访问权限。

传输安全 (Transport Security)

HTTPS：使用SSL/TLS加密HTTP请求和响应，防止数据在传输过程中被截获或篡改。
HSTS（HTTP Strict Transport Security）：强制客户端（如浏览器）使用HTTPS与服务器建立连接。

数据保护

数据加密：对敏感数据进行加密处理，保护存储在服务器上或传输过程中的数据。
数据脱敏：在公开的响应中避免直接展示敏感数据，如用户ID、电子邮件地址等。

输入验证

目的：防止恶意输入导致的安全漏洞，如SQL注入、XSS攻击。
实践：对所有输入数据进行验证，拒绝不符合预期格式的请求。

错误处理

优雅处理：错误信息应足够通用，避免泄露敏感信息或系统细节。
日志记录：记录错误日志，但避免在日志中记录敏感信息。

限制与节流 (Rate Limiting and Throttling)

目的：防止API滥用，保护后端服务不受恶意攻击或过载。
实现：限制来自单一来源的请求频率，当达到限制时返回适当的HTTP状态码。

通过这些基础知识的详解，我们可以看到保护REST API涉及到多个方面，包括但不限于身份验证、授权、传输安全、数据保护和输入验证等。正确实施这些安全措施，可以有效提高API的安全性，保护用户数据和服务的稳定性。

7.1.2 重点案例：使用 JWT 进行身份验证和授权

JSON Web Token（JWT）是一种开放标准（RFC 7519），用于在双方之间安全地传输信息作为 JSON 对象。由于其紧凑和自包含的特性，JWT 非常适合用于 REST API 的身份验证和授权。以下案例将引导你实现 JWT 在 Spring Boot 应用中的身份验证和授权。

案例 Demo

步骤 1: 引入 JWT 库依赖

首先，在 Spring Boot 项目的pom.xml中添加对 JWT 库的依赖。这里我们使用jjwt库作为示例：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

步骤 2: 创建JWT工具类

创建一个JWT工具类JwtUtil，用于生成和验证 JWT 令牌：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.function.Function;
@Component
public class JwtUtil {
    private String secret = "yourSecretKey"; // 用于签名的密钥
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }
    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }
    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }
    public String generateToken(String username) {
        return Jwts.builder().setSubject(username)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10)) // 10小时有效期
                .signWith(SignatureAlgorithm.HS256, secret).compact();
    }
    public Boolean validateToken(String token, String username) {
        final String tokenUsername = extractUsername(token);
        return (username.equals(tokenUsername) && !isTokenExpired(token));
    }
}

步骤 3: 实现 JWT 请求过滤器

创建JwtRequestFilter类，它将在每次请求时检查 JWT 令牌的有效性：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class JwtRequestFilter extends OncePerRequestFilter {
    @Autowired
    private MyUserDetailsService userDetailsService;
    @Autowired
    private JwtUtil jwtUtil;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        
        final String authorizationHeader = request.getHeader("Authorization");
        String username = null;
        String jwt = null;
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            if (jwtUtil.validateToken(jwt, userDetails.getUsername())) {
                UsernamePasswordAuthenticationToken authToken = 
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        chain.doFilter(request, response);
    }
}

步骤 4: 配置 Spring Security

最后，在 Spring Security 配置中注册JwtRequestFilter：

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.http.SessionCreation
Policy;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtRequestFilter jwtRequestFilter;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests().antMatchers("/authenticate").permitAll()
                .anyRequest().authenticated()
                .and().sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

通过这些步骤，你的 Spring Boot 应用现在能够利用 JWT 进行身份验证和授权，从而保护 REST API 免受未授权访问。记得保密你的 JWT 密钥，并定期更新以维护系统安全。

7.1.3 拓展案例 1：API 密钥认证

API 密钥认证是一种简单但有效的安全措施，用于控制对 REST API 的访问。它适用于服务到服务的通信，其中一个服务需要验证另一个服务的请求。以下案例演示了如何在 Spring Boot 应用中实现 API 密钥认证。

案例 Demo

步骤 1: 定义 API 密钥存储

首先，假设我们有一个简单的方式来存储和验证 API 密钥。在实际应用中，这些密钥可能会存储在数据库或配置文件中。这里我们使用一个简单的 Map 模拟。

import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
public class ApiKeyStore {
    private final Map<String, String> apiKeys = new HashMap<>();
    public ApiKeyStore() {
        // 初始化一些API密钥，实际应用中应该从安全的地方加载
        apiKeys.put("service1", "key-123");
        apiKeys.put("service2", "key-456");
    }
    public boolean validateKey(String serviceId, String apiKey) {
        return apiKey.equals(apiKeys.get(serviceId));
    }
}

步骤 2: 实现 API 密钥认证过滤器

创建ApiKeyAuthenticationFilter类，该过滤器负责拦截请求并验证 API 密钥。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class ApiKeyAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private ApiKeyStore apiKeyStore;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        
        String serviceId = request.getHeader("Service-Id");
        String apiKey = request.getHeader("API-Key");
        if (serviceId == null || apiKey == null || !apiKeyStore.validateKey(serviceId, apiKey)) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid API Key");
            return;
        }
        chain.doFilter(request, response);
    }
}

步骤 3: 在Spring Security 配置中注册 API 密钥认证过滤器

接下来，需要在 Spring Security 配置中添加ApiKeyAuthenticationFilter。

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.context.annotation.Bean;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    public ApiKeyAuthenticationFilter apiKeyAuthenticationFilter() {
        return new ApiKeyAuthenticationFilter();
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(apiKeyAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
            .authorizeRequests()
                .anyRequest().authenticated()
            .and()
            .csrf().disable();
    }
}

通过以上步骤，Spring Boot 应用现在能够使用 API 密钥进行简单的身份验证。任何未提供有效 API 密钥的请求都将被拒绝访问。

测试API密钥认证

启动应用并尝试发送请求到受保护的端点，确保在请求头中包含有效的Service-Id和API-Key。如果密钥验证失败，应收到 HTTP 401 Unauthorized 错误。

这种 API 密钥认证方法虽然简单，但在某些场景下非常有效，尤其是在服务对服务的通信中。记得保护好你的 API 密钥，避免泄露。

第7章 Spring Security 的 REST API 与微服务安全（2024 最新版）（中）+https://developer.aliyun.com/article/1487156

第7章 Spring Security 的 REST API 与微服务安全（2024 最新版）（上）

7.1 保护 REST API

7.1.1 基础知识详解

7.1.2 重点案例：使用 JWT 进行身份验证和授权

案例 Demo

7.1.3 拓展案例 1：API 密钥认证

案例 Demo

测试API密钥认证

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

第7章 Spring Security 的 REST API 与微服务安全（2024 最新版）（上）

7.1 保护 REST API

7.1.1 基础知识详解

7.1.2 重点案例：使用 JWT 进行身份验证和授权

案例 Demo

7.1.3 拓展案例 1：API 密钥认证

案例 Demo

测试API密钥认证

热门文章

最新文章

相关课程

相关电子书

相关实验场景