第10章 Spring Security 的未来趋势与高级话题（2024 最新版）_spring security最新

10.1 云原生安全性趋势

在这个章节，我们将像星际探索者一样，深入探讨云原生安全性的前沿趋势。随着企业和开发者越来越依赖云平台来部署和管理应用，了解如何在这个不断变化的环境中保持安全变得极其重要。

10.1.1 基础知识

在深入云原生安全性趋势的海洋之前，让我们先扩展对云原生安全基础知识的理解。云原生安全不仅仅是将传统安全实践迁移到云环境中，而是需要根据云环境的独特特性重新思考安全策略。

容器安全

• 容器隔离：虽然容器比传统虚拟机更轻量，但它们在默认情况下不提供同等级别的隔离。确保容器运行时和容器网络的安全配置至关重要。
• 不变性：容器镜像在构建时被打包，运行时不应更改。这种不变性有助于减少运行时安全风险，但同时要确保镜像在构建阶段就已经安全。

微服务安全

• 服务间认证和授权：在微服务架构中，各服务需要能够相互认证并控制访问权限。使用诸如 Mutual TLS (mTLS) 和 JSON Web Tokens (JWT) 的技术可以提供这种能力。
• API 安全：微服务通过 API 进行通信，保护这些 API 免受攻击（例如，注入攻击、DDoS 攻击）是必要的。API 网关可以提供额外的安全层，如限流和访问控制。

代码和依赖安全

• 安全编码实践：在云原生应用的开发过程中遵循安全编码实践可以预防许多安全问题。这包括输入验证、避免敏感数据泄露以及及时更新依赖以修复已知漏洞。
• 依赖扫描：自动化工具可以帮助识别和修复已知的安全漏洞。集成这些工具到 CI/CD 流程中可以确保应用在部署前尽可能安全。

数据安全和隐私

• 加密：在云环境中，数据不仅在传输过程中需要加密（使用 TLS），在静态存储时也应加密（使用如 AES 的加密算法）。
• 数据治理和合规性：云原生应用需要遵守地域或行业的数据保护法规。实现数据治理策略和采取合规性措施是确保遵守这些法规的关键。

安全文化和自动化

• 安全为先的文化：在组织内部推广安全为先的文化，确保开发、运维和安全团队之间的紧密合作是提高云原生安全性的关键。
• 安全自动化：通过自动化安全测试、审计和合规性检查，可以在快速迭代的开发过程中持续保持高安全标准。

掌握这些基础知识将为你探索云原生安全性趋势和实践打下坚实的基础，帮助你在云原生的世界中航行时保持课程的正确，确保应用和数据的安全。

10.1.2 重点案例：保护微服务通信

在云原生架构中，微服务之间的安全通信是维护整个系统安全的关键。此案例将引导你通过实际的 Java 示例实现微服务之间的安全通信。

步骤 1：启用 HTTPS

首先，确保所有微服务之间的通信都通过 HTTPS 进行。这需要为每个服务配置 SSL/TLS 证书。

Spring Boot 应用配置示例:

在 application.properties 中为你的微服务配置 HTTPS：

server.port=8443
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=yourKeystorePassword
server.ssl.keyAlias=yourKeyAlias
1
2
3
4

步骤 2：服务间的 Mutual TLS (mTLS)

mTLS 不仅加密通信内容，还确保双向身份验证——即服务不仅验证客户端（通常是另一个服务），客户端也验证服务。这需要在服务和客户端都配置证书。

Spring Security 配置:

在服务端，配置 WebSecurityConfigurerAdapter 以要求客户端证书：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .x509()
            .subjectPrincipalRegex("CN=(.*?)(?:,|$)")
            .userDetailsService(userDetailsService());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在客户端，配置 RestTemplate 以使用客户端证书：

@Bean
public RestTemplate restTemplate() throws Exception {
    SSLContext sslContext = SSLContextBuilder
        .create()
        .loadTrustMaterial(trustStore.getURL(), trustStorePassword.toCharArray())
        .loadKeyMaterial(keyStore.getURL(), keyStorePassword.toCharArray(), keyPassword.toCharArray())
        .build();
        
    HttpClient client = HttpClients.custom()
        .setSSLContext(sslContext)
        .build();
        
    return new RestTemplate(new HttpComponentsClientHttpRequestFactory(client));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

步骤 3：服务发现与安全令牌

在微服务架构中，服务发现允许服务相互查找和通信。安全令牌（如 JWT）可以用于服务间认证。

Spring Cloud Gateway 配置示例:

配置 API 网关，使用 JWT 进行路由转发时的服务间认证：

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("service-a", r -> r.path("/service-a/**")
            .filters(f -> f.filter(new JwtAuthenticationFilter()))
            .uri("https://service-a"))
        .build();
}
1
2
3
4
5
6
7
8

JwtAuthenticationFilter 示例:

public class JwtAuthenticationFilter implements GatewayFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 从某处获取 JWT
        String jwt = "Bearer your.jwt.token.here";
        
        // 将 JWT 添加到请求头
        exchange.getRequest().mutate().header("Authorization", jwt).build();
        return chain.filter(exchange);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

测试安全通信

确保微服务之间的安全通信正确配置和实现，进行相应的测试是非常重要的。

@SpringBootTest
public class SecureCommunicationTests {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testSecureServiceCommunication() {
        // 使用 TestRestTemplate 调用另一个服务的 HTTPS 端点
        ResponseEntity<String> response = restTemplate
            .withBasicAuth("user", "password")
            .getForEntity("https://service-b/secure-endpoint", String.class);
        
        assertEquals(HttpStatus.OK, response.getStatusCode());
        // 验证响应内容
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

通过这些步骤，你可以确保你的微服务在云原生环境中安全地通信，从而保护你的数据和应用免受中间人攻击和未授权访问的威胁。

10.1.3 拓展案例 1：容器安全最佳实践

容器技术是云原生应用的核心，因此确保容器的安全对维护整个应用的安全至关重要。下面是如何在 Java 应用中实施容器安全最佳实践的具体案例。

步骤 1：使用安全的容器基础镜像

选择一个已经过安全审计的基础镜像是减少容器中安全漏洞的第一步。例如，可以使用官方的、定期更新的 Java 基础镜像作为你的应用的基础。

Dockerfile 示例:

# 使用官方的 Java 基础镜像，标签指定了 Java 版本和操作系统版本
FROM openjdk:11-jre-slim

# 将你的应用 JAR 文件添加到容器中
COPY target/your-application.jar /app/your-application.jar

# 运行你的应用
CMD ["java", "-jar", "/app/your-application.jar"]
1
2
3
4
5
6
7
8

步骤 2：扫描容器镜像中的安全漏洞

在构建镜像的过程中或之后，使用工具扫描你的容器镜像，以发现和修复潜在的安全漏洞。Trivy 是一个简单且全面的容器安全扫描工具。

扫描示例:

在你的 CI/CD 流程中添加一个步骤，使用 Trivy 扫描你的容器镜像。

steps:
  - name: 构建容器镜像
    run: docker build -t your-application .
  - name: 扫描容器镜像
    run: trivy image your-application
1
2
3
4
5

步骤 3：最小化容器运行时权限

确保你的容器以最小权限运行，避免使用 root 用户运行容器内的应用。

Dockerfile 示例:

在 Dockerfile 中添加用户并切换到该用户：

FROM openjdk:11-jre-slim

# 创建一个应用用户
RUN groupadd -r appgroup && useradd -r -g appgroup appuser

# 切换到非 root 用户
USER appuser

COPY target/your-application.jar /app/your-application.jar

CMD ["java", "-jar", "/app/your-application.jar"]
1
2
3
4
5
6
7
8
9
10
11

步骤 4：配置资源限制

为你的容器配置 CPU 和内存限制，以防止恶意行为或程序错误消耗过多的宿主机资源。

Docker Compose 示例:

在 docker-compose.yml 文件中为你的服务配置资源限制：

services:
  your-application:
    image: your-application
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
1
2
3
4
5
6
7
8

测试容器安全配置

确保你的容器安全配置正确并有效，通过实施安全测试和监控容器行为来验证这些配置。

// 示例：编写集成测试来验证应用的安全配置，如检查是否能以非预期的高权限执行操作

@SpringBootTest
public class ContainerSecurityTests {

    @Test
    public void testRunAsNonRootUser() {
        // 模拟一个操作，该操作只有在以 root 用户执行时才能成功
        // 验证操作失败，从而确认应用不是以 root 用户运行
    }

    // 其他安全测试...
}
1
2
3
4
5
6
7
8
9
10
11
12
13

通过实施这些容器安全最佳实践，你的应用将在云原生环境中更加安全，减少了遭受攻击和漏洞利用的风险。这些措施为应用的安全防护提供了坚实的基础，使得你可以更加自信地在云环境中部署和运行你的服务。

10.1.4 拓展案例 2：自动化安全审计和合规性检查

在快速发展的云原生生态中，自动化安全审计和合规性检查不仅可以提高效率，还能确保在持续集成/持续部署（CI/CD）过程中不断地维护安全和合规性标准。以下是如何实现这些自动化流程的具体案例。

步骤 1：集成静态代码分析工具

静态代码分析（SAST）工具可以在代码提交到版本控制系统时自动检测潜在的安全问题和漏洞。

集成 SonarQube 示例:

在你的 CI/CD 流程（如 Jenkins、GitHub Actions 等）中，添加一个步骤来运行 SonarQube 扫描。

# GitHub Actions 示例
name: CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up JDK 11
      uses: actions/setup-java@v2
      with:
        java-version: '11'
        distribution: 'adopt'
    - name: SonarQube Scan
      uses: SonarSource/sonarqube-scan-action@master
      with:
        args: >
          -Dsonar.projectKey=your_project_key
          -Dsonar.host.url=https://your_sonarqube_server
          -Dsonar.login=$SONAR_TOKEN
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

确保在 CI/CD 环境变量中设置了 SONAR_TOKEN。

步骤 2：自动化依赖扫描

使用依赖扫描工具（如 OWASP Dependency-Check）自动检测项目依赖中的已知安全漏洞。

集成 OWASP Dependency-Check 示例:

在 Maven 或 Gradle 构建文件中，添加 OWASP Dependency-Check 插件。

<!-- Maven 示例 -->
<plugin>
    <groupId>org.owasp</groupId>
    <artifactId>dependency-check-maven</artifactId>
    <version>6.1.6</version>
    <executions>
        <execution>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>
1
2
3
4
5
6
7
8
9
10
11
12
13

在 CI/CD 流程中，添加一个步骤来执行依赖检查。

步骤 3：合规性策略即代码

使用 Open Policy Agent（OPA）等工具，将合规性策略定义为代码，并自动化执行这些策略的检查。

定义 OPA 策略示例:

创建一个简单的 OPA 策略，确保 Kubernetes 部署不使用默认命名空间。

package k8s.admission

deny[msg] {
    input.request.kind.kind == "Deployment"
    input.request.namespace == "default"
    msg := "Deployments should not use the default namespace"
}
1
2
3
4
5
6
7

在 CI/CD 流程中，集成 OPA 检查，确保所有 Kubernetes 资源配置都符合策略要求。

测试自动化安全审计和合规性检查

通过编写测试用例，验证安全审计和合规性检查流程能够正确识别违规和潜在的安全问题。

// 示例：编写集成测试来验证安全和合规性检查是否生效
// 注意：具体实现将取决于你使用的工具和策略

@SpringBootTest
public class SecurityAuditTests {

    @Test
    public void testSecurityPolicies() {
        // 模拟违反安全策略的行为，验证安全审计工具能够检测到
    }

    @Test
    public void testCompliancePolicies() {
        // 模拟违反合规性策略的配置，验证合规性检查工具能够识别并报告
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

通过这些步骤的实现，你的云原生应用不仅能够自动识别和修复安全漏洞，还能确保持续遵守相关的合规性要求。这种自动化的安全审计和合规性检查流程是构建安全、可靠且合规的云原生应用的关键。

通过深入探索这些案例，你将能够更好地理解和应用云原生安全性的最佳实践。这不仅能够保护你的应用和数据，还能提高开发和运维的效率，使你的应用在云的天空中更加自由地翱翔。

10.2 反应式编程与 Spring Security

在这个章节中，我们将探索如何在反应式编程模型下使用 Spring Security 来构建响应式应用的安全架构。反应式编程是一种基于数据流和变化传播的编程范式，它非常适合处理高并发和大数据量的应用程序。Spring WebFlux 是 Spring 5 引入的用于构建响应式应用的框架，与 Spring Security 结合使用时，可以提供强大的安全保障。

10.2.1 基础知识

在深入探索反应式编程与 Spring Security 的结合之前，让我们先扩充一下相关的基础知识，确保我们有坚实的基础来构建安全的响应式应用。

反应式编程基础

反应式编程是一种面向数据流和变更传播的编程范式，旨在构建响应用户和系统互动的应用。它通过异步数据流来处理异步数据，使得可以轻松地编写非阻塞和高性能的应用。

• 核心概念：主要包括观察者模式、迭代器模式和函数式编程。通过这些概念，反应式编程能够实现数据流的传递和变更通知。
• 主要组件：反应式编程的主要组件包括 Publisher（发布者）、Subscriber（订阅者）、Subscription（订阅）和 Processor（处理器）。

Spring WebFlux

Spring WebFlux 是 Spring Framework 5 中引入的，用于构建响应式 Web 应用的框架。它提供了一套完整的响应式编程模型，可以运行在支持 Servlet 3.1+ 的容器上，也可以运行在非阻塞的运行时环境上，如 Netty 和 Undertow。

• 与 Spring MVC 的区别：Spring WebFlux 是 Spring MVC 的响应式非阻塞替代品。它不是替代 Spring MVC，而是提供了一种不同的方式来处理并发性较高的场景。
• 核心特性：支持响应式编程模型，提供函数式和注解驱动的编程模式，支持反应式数据存储的访问。

Spring Security 支持

Spring Security 提供了对 Spring WebFlux 应用的支持，使得开发者可以以响应式的方式配置安全策略。

• 安全配置：与 Spring MVC 应用类似，Spring Security 在 WebFlux 应用中的配置也是通过一个或多个 SecurityWebFilterChain 实例来完成的。
• 认证和授权：Spring Security 支持响应式的认证和授权处理，包括基于表单的登录、基于 JWT 的认证等。
• 方法级安全：通过启用响应式方法级安全，可以在响应式应用中对方法调用应用安全规则，如 @PreAuthorize。

通过深入理解这些基础知识，你将能够更好地掌握在构建响应式 Web 应用时如何利用 Spring Security 提供的强大安全特性，确保应用既能快速响应用户请求，又能保障数据和系统的安全。

10.2.2 重点案例：基于角色的访问控制

在响应式 Spring 应用中实现基于角色的访问控制，是确保只有具备特定权限的用户可以访问应用中敏感部分的关键。以下是通过 Spring Security 和 Spring WebFlux 实现此安全策略的详细步骤和代码示例。

步骤 1：配置 Spring Security

首先，配置 Spring Security 以支持基于角色的访问控制。这包括定义 SecurityWebFilterChain，在其中指定不同角色可以访问的路由。

SecurityConfig.java 示例:

@EnableWebFluxSecurity
public class SecurityConfig {

    @Bean
    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
        http
            .authorizeExchange()
            .pathMatchers("/admin/**").hasAuthority("ROLE_ADMIN") // 只有 ADMIN 角色的用户可以访问 /admin/**
            .pathMatchers("/user/**").hasAuthority("ROLE_USER") // 只有 USER 角色的用户可以访问 /user/**
            .anyExchange().authenticated() // 其他所有路由都需要认证
            .and().httpBasic() // 使用 HTTP Basic 认证
            .and().formLogin(); // 启用表单登录
        return http.build();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

步骤 2：创建用户详情服务

实现 ReactiveUserDetailsService 接口，提供用户认证信息。在这个服务中，可以定义用户的用户名、密码和角色。

InMemoryUserDetailsManager 示例:

@Bean
public ReactiveUserDetailsService userDetailsService() {
    UserDetails user = User
            .withUsername("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER")
            .build();
    UserDetails admin = User
            .withUsername("admin")
            .password(passwordEncoder().encode("admin"))
            .roles("ADMIN")
            .build();
    return new MapReactiveUserDetailsService(user, admin);
}

@Bean
public PasswordEncoder passwordEncoder() {
    return PasswordEncoderFactories.createDelegatingPasswordEncoder();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

步骤 3：定义响应式控制器

创建响应式控制器来处理 HTTP 请求，并根据用户的角色返回相应的响应。

AdminController.java 示例:

@RestController
@RequestMapping("/admin")
public class AdminController {

    @GetMapping("/dashboard")
    public Mono<String> dashboard() {
        return Mono.just("Admin Dashboard - Only for Admins!");
    }
}
1
2
3
4
5
6
7
8
9

UserController.java 示例:

@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/profile")
    public Mono<String> profile() {
        return Mono.just("User Profile - Accessible by any User.");
    }
}
1
2
3
4
5
6
7
8
9

测试基于角色的访问控制

编写测试用例来验证基于角色的访问控制是否按预期工作。

@WebFluxTest
@Import(SecurityConfig.class)
public class RoleBasedAccessControlTests {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    public void adminAccessAdminPage() {
        webTestClient
            .mutateWith(mockUser().username("admin").roles("ADMIN"))
            .get().uri("/admin/dashboard")
            .exchange()
            .expectStatus().isOk()
            .expectBody(String.class).isEqualTo("Admin Dashboard - Only for Admins!");
    }

    @Test
    public void userCannotAccessAdminPage() {
        webTestClient
            .mutateWith(mockUser().username("user").roles("USER"))
            .get().uri("/admin/dashboard")
            .exchange()
            .expectStatus().isForbidden();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

通过这个案例，你可以看到在响应式 Spring 应用中实现基于角色的访问控制是直接且高效的。利用 Spring Security 的强大功能和 Spring WebFlux 的响应式编程模型，你可以构建既安全又高性能的应用。

10.2.3 拓展案例 1：响应式 JWT 认证

在响应式 Spring 应用中集成 JWT 认证，可以为你的应用提供一种无状态的、基于令牌的安全机制，特别适用于微服务架构。这里是如何实现响应式 JWT 认证的详细步骤和代码示例。

步骤 1：引入依赖

首先，确保你的项目中引入了JWT支持所需的依赖。

build.gradle 示例:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'org.springframework.boot:spring-boot-starter-webflux'
    implementation 'io.jsonwebtoken:jjwt-api:0.11.2'
    runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.2'
    runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.2'
}
1
2
3
4
5
6
7

步骤 2：创建 JWT 工具类

创建一个 JWT 工具类，用于生成和解析 JWT 令牌。这个类将负责令牌的创建、签名和验证。

JwtUtil.java 示例:

@Component
public class JwtUtil {

    private String secretKey = "yourSecretKey"; // 应从配置文件中读取
    private long validityInMilliseconds = 3600000; // 1h

    public String createToken(String username, List<String> roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);

        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);

        return Jwts.builder()
            .setClaims(claims)
            .setIssuedAt(now)
            .setExpiration(validity)
            .signWith(SignatureAlgorithm.HS256, secretKey)
            .compact();
    }

    public Authentication getAuthentication(String token) {
        UserDetails userDetails = new User(getUsername(token), "", getRoles(token));
        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }

    public String getUsername(String token) {
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();
    }

    @SuppressWarnings("unchecked")
    public List<String> getRoles(String token) {
        List<String> roles = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().get("roles", List.class);
        return roles.stream().map(role -> "ROLE_" + role).collect(Collectors.toList());
    }

    public boolean validateToken(String token) {
        try {
            Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return !claims.getBody().getExpiration().before(new Date());
        } catch (JwtException | IllegalArgumentException e) {
            throw new IllegalStateException("Expired or invalid JWT token");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

步骤 3：创建响应式 JWT 认证过滤器

创建一个响应式的 JWT 认证过滤器，该过滤器将检查 HTTP 请求中的 JWT 令牌，并进行认证。

JwtTokenAuthenticationFilter.java 示例:

public class JwtTokenAuthenticationFilter implements WebFilter {

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String token = resolveToken(exchange.getRequest());
        if (token != null && jwtUtil.validateToken(token)) {
            Authentication auth = jwtUtil.getAuthentication(token);
            return chain.filter(exchange).contextWrite(ReactiveSecurityContextHolder.withAuthentication(auth));
        }
        return chain.filter(exchange);
    }

    private String resolveToken(ServerHttpRequest request) {
        String bearerToken = request.getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

步骤 4：配置安全过滤链

在 Spring Security 配置中添加 JWT 认证过滤器。

SecurityConfig.java 示例:

@EnableWebFluxSecurity
public class SecurityConfig {

    @Bean
    public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
        http
            .authorizeExchange()
            .pathMatchers("/api/**").authenticated()
            .anyExchange().permitAll()
            .and().

csrf().disable()
            .addFilterAt(jwtTokenAuthenticationFilter(), SecurityWebFiltersOrder.AUTHENTICATION);
        return http.build();
    }

    @Bean
    public JwtTokenAuthenticationFilter jwtTokenAuthenticationFilter() {
        return new JwtTokenAuthenticationFilter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

测试 JWT 认证

编写集成测试以验证 JWT 认证机制是否正常工作。

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
public class JwtAuthenticationTests {

    @Autowired
    private WebTestClient webTestClient;

    @Autowired
    private JwtUtil jwtUtil;

    @Test
    public void testJwtAuthentication() {
        String token = jwtUtil.createToken("user", Arrays.asList("USER"));

        webTestClient.get().uri("/api/user")
            .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
            .exchange()
            .expectStatus().isOk();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

通过这个案例，你将能够在响应式 Spring 应用中实现 JWT 认证，为你的应用提供一种灵活且安全的认证机制。这不仅增强了应用的安全性，也提高了其性能和可伸缩性。

10.2.4 拓展案例 2：响应式方法级安全

在响应式应用中实现方法级安全可以让你精细控制对服务层方法的访问权限，Spring Security 提供了对响应式方法安全的支持，让开发者能够以声明式的方式控制方法的访问权限。以下是如何在响应式 Spring 应用中实现方法级安全的详细步骤和代码示例。

步骤 1：启用响应式方法级安全

首先，确保在你的配置类中启用了响应式方法级安全。这可以通过在配置类上添加 @EnableReactiveMethodSecurity 注解来实现。

MethodSecurityConfig.java 示例:

@Configuration
@EnableReactiveMethodSecurity
public class MethodSecurityConfig {
    // 这个配置类可能不需要包含其他配置，除非你需要自定义方法安全行为
}
1
2
3
4
5

步骤 2：使用安全注解保护服务方法

然后，在你的服务类中，使用 Spring Security 提供的安全注解（如 @PreAuthorize）来声明方法的访问控制规则。

UserService.java 示例:

@Service
public class UserService {

    @PreAuthorize("hasRole('ADMIN')")
    public Mono<User> findUser(String id) {
        // 模拟查找用户的逻辑
        return Mono.just(new User(id, "username"));
    }
}
1
2
3
4
5
6
7
8
9

这个例子中，findUser 方法被配置为只有拥有 ADMIN 角色的用户才能调用。

步骤 3：配置自定义权限评估逻辑

如果你需要更复杂的权限逻辑，可以实现 ReactivePermissionEvaluator 接口，并在配置中注册你的自定义权限评估器。

CustomPermissionEvaluator.java 示例:

public class CustomPermissionEvaluator implements ReactivePermissionEvaluator {

    @Override
    public Mono<Boolean> hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        // 实现自定义的权限评估逻辑
        return Mono.just(true); // 示例逻辑，应根据实际情况进行判断
    }

    @Override
    public Mono<Boolean> hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        // 实现自定义的权限评估逻辑
        return Mono.just(false); // 示例逻辑，应根据实际情况进行判断
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在配置中注册自定义权限评估器:

@Configuration
@EnableReactiveMethodSecurity
public class MethodSecurityConfig {

    @Bean
    public CustomPermissionEvaluator customPermissionEvaluator() {
        return new CustomPermissionEvaluator();
    }
}
1
2
3
4
5
6
7
8
9

测试方法级安全配置

最后，编写测试用例以验证方法级安全配置是否按预期工作。

@SpringBootTest
public class UserServiceTests {

    @Autowired
    private UserService userService;

    @Test
    @WithMockUser(roles = "ADMIN")
    public void testFindUserWithAdminRole() {
        StepVerifier.create(userService.findUser("1"))
            .expectNextMatches(user -> "username".equals(user.getUsername()))
            .verifyComplete();
    }

    @Test
    @WithMockUser(roles = "USER")
    public void testFindUserWithUserRole() {
        StepVerifier.create(userService.findUser("1"))
            .expectError(AccessDeniedException.class)
            .verify();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

通过实施这些步骤，你的响应式 Spring 应用将能够利用方法级安全来精细控制对服务方法的访问权限，确保只有具备适当权限的用户才能执行敏感操作。这种方式提高了应用的安全性，同时保持了代码的清晰和易于管理。

通过这个案例，你可以看到在响应式应用中使用 Spring Security 不仅能够保持应用的反应式特性，还能提供强大的安全保障。无论是基于角色的访问控制、JWT 认证，还是方法级安全，Spring Security 都能以响应式的方式完美支持，确保你的应用既快速响应又安全可靠。

10.3 扩展 Spring Security

在这个章节中，我们将深入探讨如何扩展 Spring Security，以适应更复杂和特定的安全需求。Spring Security 的可扩展性是其强大功能的核心之一，让开发者能够定制和增强框架的默认行为。

10.3.1 基础知识

在深入探讨如何扩展 Spring Security 之前，了解一些核心概念和技术将帮助我们更好地理解和应用这些高级特性。Spring Security 是一个强大的安全框架，它提供了全面的安全解决方案，但有时候我们需要根据特定的业务需求来定制和扩展它的功能。

自定义用户认证

• UserDetailsService: Spring Security 中用于加载用户特定数据的核心接口。如果你的用户信息存储在非标准的来源，如数据库、LDAP 或远程服务，你可以实现这个接口来定义加载用户信息的逻辑。
• PasswordEncoder: 用于密码的加密和匹配。在定义自己的 UserDetailsService 时，通常也需要提供一个密码加密器来保证安全性。

自定义认证逻辑

• AuthenticationProvider: 定义认证的逻辑。当你需要支持新的认证方式（如短信验证码、生物识别等）时，实现这个接口可以让你完全控制认证过程。
• AuthenticationToken: 认证过程中使用的令牌，存储了认证信息，如用户名、密码、权限等。定义新的 AuthenticationToken 类型，可以支持不同的认证信息和逻辑。

安全过滤器定制

• WebSecurityConfigurerAdapter: 配置安全过滤器链的基本类。通过重写这个类的方法，你可以添加或移除特定的过滤器，改变安全配置的行为。
• OncePerRequestFilter: 用于创建自定义过滤器的便捷基类。当需要在请求处理过程中执行特定的安全检查或逻辑时，可以扩展这个类。

访问控制和权限评估

• AccessDecisionManager: 决定是否允许对某个资源的访问。你可以定义自己的访问决策管理器来实现复杂的访问控制策略。
• PermissionEvaluator: 用于方法级安全的接口，允许基于方法调用的上下文评估权限。实现这个接口可以支持更细粒度的权限控制，如基于用户属性或资源状态的动态权限检查。

了解这些基础知识和组件后，我们就可以开始探索如何通过扩展这些组件和实现自定义逻辑来满足特定的安全需求了。这种灵活性和可扩展性是 Spring Security 成为企业级应用首选安全框架的重要原因之一。

10.3.2 重点案例：自定义用户认证流程

在这个案例中，我们将通过实现一个基于短信验证码的认证流程来展示如何自定义用户认证流程。这种认证方式在移动应用或需要二次验证的场景中非常有用。

步骤 1：定义短信验证码认证令牌

首先，定义一个代表短信验证码认证信息的 AuthenticationToken。这个令牌将在认证过程中使用，以携带用户的手机号和短信验证码。

public class SmsAuthenticationToken extends AbstractAuthenticationToken {
    private final Object principal;
    private final Object credentials;

    public SmsAuthenticationToken(String mobile, String code) {
        super(Collections.emptyList());
        this.principal = mobile;
        this.credentials = code;
        setAuthenticated(false); // 初始化时未认证
    }

    @Override
    public Object getCredentials() {
        return credentials;
    }

    @Override
    public Object getPrincipal() {
        return principal;
    }

    // 认证成功后，设置用户权限并标记为已认证
    void setAuthorities(Collection<? extends GrantedAuthority> authorities) {
        super.setAuthenticated(true); // 必须在设置权限前调用
        super.setAuthorities(authorities);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

步骤 2：实现短信验证码认证提供者

接着，创建一个 AuthenticationProvider 实现，用于处理 SmsAuthenticationToken 的认证逻辑。

@Component
public class SmsAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private SmsCodeService smsCodeService; // 假设这是你的服务，用于验证短信验证码

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        SmsAuthenticationToken authRequest = (SmsAuthenticationToken) authentication;
        String mobile = (String) authRequest.getPrincipal();
        String code = (String) authRequest.getCredentials();

        // 调用短信验证码服务验证验证码
        if (!smsCodeService.validateCode(mobile, code)) {
            throw new BadCredentialsException("Invalid SMS verification code.");
        }

        // 验证码正确，加载用户详情
        UserDetails userDetails = userDetailsService.loadUserByUsername(mobile);
        // 创建已认证的令牌，包含用户详情和权限
        SmsAuthenticationToken authResult = new SmsAuthenticationToken(userDetails, null);
        authResult.setAuthorities(userDetails.getAuthorities());
        return authResult;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return SmsAuthenticationToken.class.isAssignableFrom(authentication);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

步骤 3：配置自定义认证提供者

在 Spring Security 配置中注册你的自定义认证提供者。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private SmsAuthenticationProvider smsAuthenticationProvider;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) {
        auth.authenticationProvider(smsAuthenticationProvider);
    }

    // 配置其他安全细节...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

步骤 4：创建接收短信验证码的控制器

最后，创建一个控制器来接收短信验证码认证请求。

@RestController
public class SmsAuthenticationController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @PostMapping("/login/sms")
    public String login(@RequestParam String mobile, @RequestParam String code) {
        SmsAuthenticationToken authRequest = new SmsAuthenticationToken(mobile, code);
        Authentication authResult = authenticationManager.authenticate(authRequest);

        // 假设有一个方法来为认证用户生成JWT令牌
        String token = jwtTokenService.generateToken(authResult);
        return token;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

通过这个案例，你可以看到在 Spring Security 中自定义认证流程是完全可行的。这种方式为应用提供了极大的灵活性，允许你根据具体的业务需求实现各种认证机制。

10.3.3 拓展案例 1：自定义权限验证

自定义权限验证允许你实现更复杂的安全需求，比如基于用户属性或请求上下文的动态权限检查。以下案例展示了如何在 Spring Security 中实现属性基访问控制（ABAC）。

步骤 1：定义自定义权限评估逻辑

首先，创建一个实现了 PermissionEvaluator 接口的类，以提供自定义的权限评估逻辑。

@Component
public class CustomPermissionEvaluator implements PermissionEvaluator {

    @Autowired
    private UserRepository userRepository; // 假设这是你的用户仓库

    @Override
    public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        if ((authentication == null) || (targetDomainObject == null) || !(permission instanceof String)) {
            return false;
        }
        String targetType = targetDomainObject.getClass().getSimpleName().toUpperCase();
        
        return hasPrivilege(authentication, targetType, permission.toString().toUpperCase());
    }

    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        if ((authentication == null) || (targetType == null) || !(permission instanceof String)) {
            return false;
        }
        
        return hasPrivilege(authentication, targetType.toUpperCase(), permission.toString().toUpperCase());
    }

    private boolean hasPrivilege(Authentication authentication, String targetType, String permission) {
        String username = authentication.getName();
        User user = userRepository.findByUsername(username);
        
        // 示例：基于用户属性和目标类型进行权限验证
        if ("SOME_RESOURCE".equals(targetType)) {
            return user.getDepartment().equals("IT") && permission.equals("READ");
        }
        
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

步骤 2：注册自定义权限评估逻辑

接着，在你的 Spring Security 配置中注册这个自定义的 PermissionEvaluator。

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {

    @Autowired
    private CustomPermissionEvaluator customPermissionEvaluator;

    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler();
        expressionHandler.setPermissionEvaluator(customPermissionEvaluator);
        return expressionHandler;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

步骤 3：使用自定义权限验证

现在，你可以在你的服务或控制器方法上使用 @PreAuthorize 或 @PostAuthorize 注解，利用自定义的权限评估逻辑来控制访问权限。

@RestController
public class SomeResourceController {

    @GetMapping("/some-resource/{id}")
    @PreAuthorize("hasPermission(#id, 'SOME_RESOURCE', 'READ')")
    public ResponseEntity<SomeResource> getSomeResource(@PathVariable Long id) {
        // 查询并返回资源
        return ResponseEntity.ok(new SomeResource());
    }
}
1
2
3
4
5
6
7
8
9
10

这个案例展示了如何通过实现 PermissionEvaluator 接口来扩展 Spring Security，实现基于属性的访问控制（ABAC）。这种方式使得权限验证更加灵活和强大，能够满足更复杂的业务需求。

10.3.4 拓展案例 2：自定义安全事件监听器

监听和响应安全相关事件，如登录成功、登录失败或访问被拒绝等，对于安全审计、实时监控或触发某些业务逻辑非常重要。以下是如何在 Spring Security 中实现自定义安全事件监听器的详细步骤和代码示例。

步骤 1：创建自定义安全事件监听器

首先，定义一个或多个事件监听器来处理你感兴趣的安全事件。Spring Security 发布了多种类型的事件，包括认证成功、认证失败、以及访问决策事件等。

@Component
public class CustomSecurityEventListener {

    private static final Logger log = LoggerFactory.getLogger(CustomSecurityEventListener.class);

    @EventListener
    public void handleAuthenticationSuccess(AuthenticationSuccessEvent event) {
        String username = ((User) event.getAuthentication().getPrincipal()).getUsername();
        log.info("Authentication success for user: {}", username);
        // 这里可以添加更多的业务逻辑，如更新用户的登录时间、记录登录日志等
    }

    @EventListener
    public void handleAuthenticationFailure(AbstractAuthenticationFailureEvent event) {
        String username = event.getAuthentication().getName();
        log.error("Authentication failed for user: {} due to: {}", username, event.getException().getMessage());
        // 这里可以添加更多的业务逻辑，如记录失败尝试、发送警报等
    }

    @EventListener
    public void handleAccessDenied(AuthorizationFailureEvent event) {
        Authentication authentication = event.getAuthentication();
        String username = authentication != null ? authentication.getName() : "anonymous";
        log.warn("Access denied for user: {}. Target object: {}. Required authority: {}", username, event.getSource(), event.getAccessDeniedException().getMessage());
        // 这里可以添加更多的业务逻辑，如记录访问拒绝事件、发送通知等
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

步骤 2：配置 Spring Security 以发布事件

确保 Spring Security 能够发布你感兴趣的事件。大多数标准事件（如认证成功和失败）默认已经启用，但某些事件可能需要额外的配置。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // 配置安全规则
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin().successHandler((request, response, authentication) -> {
                // 如果需要，这里可以显式地发布事件
            })
            .failureHandler((request, response, exception) -> {
                // 如果需要，这里也可以显式地发布事件
            });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

步骤 3：测试自定义安全事件监听器

最后，编写测试来验证自定义事件监听器是否按预期工作。

@SpringBootTest
@AutoConfigureMockMvc
public class SecurityEventListenerTests {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testAuthenticationSuccessEvent() throws Exception {
        // 使用 MockMvc 发起一个认证成功的请求
        mockMvc.perform(formLogin("/login").user("user").password("password"))
            .andExpect(authenticated());
        // 验证 handleAuthenticationSuccess 方法被调用
    }

    @Test
    public void testAuthenticationFailureEvent() throws Exception {
        // 使用 MockMvc 发起一个认证失败的请求
        mockMvc.perform(formLogin("/login").user("user").password("wrongpassword"))
            .andExpect(unauthenticated());
        // 验证 handleAuthenticationFailure 方法被调用
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

通过这个案例，你可以看到如何在 Spring Security 中实现自定义事件监听器，以便在发生安全相关事件时执行自定义逻辑。这使得你的应用能够响应各种安全事件，从而提高安全性、促进审计和监控，并根据业务需求触发相应的操作。

通过这些案例，你可以看到扩展 Spring Security 并不复杂，只需要了解框架提供的扩展点并实现相应的接口或类即可。这种灵活性和可扩展性使得 Spring Security 成为构建安全 Java 应用的强大工具。