Spring Security OAuth2：微服务认证与授权

Spring Security OAuth2：微服务认证与授权，一场代码世界的“通行证”革命

各位看官，欢迎来到“程序员茶馆”，今天咱们要聊聊微服务架构下，如何用Spring Security OAuth2来搞定认证与授权这件大事儿。这玩意儿，说白了，就像你进出各种场合的“通行证”，没它，寸步难行！

在单体应用时代，用户认证授权往往是个“一锤子买卖”，所有服务都挤在一个大房子里，共享一套用户信息。但到了微服务时代，各个服务都成了独立的小别墅，用户信息的管理变得复杂起来，安全风险也随之增加。想象一下，你住在不同小区的房子，每次进小区都要重新登记身份，是不是很麻烦？

这时候，OAuth2就像一个“身份共享中心”，它允许用户授权第三方应用访问自己的资源，而无需将用户名和密码直接交给这些应用。这就像你给快递小哥一个“临时钥匙”，让他可以把包裹放到你家门口，但不能随意进你房间。

所以，OAuth2在微服务架构中扮演着至关重要的角色，它能够：

• 简化用户管理： 用户只需在一个地方管理自己的身份，无需在每个微服务中注册和登录。
• 提高安全性： 避免了密码泄露的风险，降低了安全攻击面。
• 增强用户体验： 用户可以方便地授权第三方应用访问自己的数据，无需重复输入用户名和密码。
• 促进服务解耦： 各个微服务可以独立地处理认证和授权，降低了服务之间的依赖性。

OAuth2核心概念：搞清楚这些，才能玩得转！

在深入代码之前，咱们先来认识一下OAuth2中的几个核心概念，就像玩游戏之前要先了解游戏规则一样：

概念	解释	比喻
Resource Owner	资源所有者，通常是用户，拥有访问受保护资源的权限。	你，拥有你的个人信息的控制权。
Client	客户端，代表需要访问受保护资源的第三方应用。	微信，它需要访问你的头像和昵称。
Resource Server	资源服务器，存储受保护资源，并验证访问请求的授权令牌。	微信服务器，存储你的头像和昵称，并且验证访问请求是否合法。
Authorization Server	授权服务器，负责验证用户的身份，并颁发授权令牌。	银行，负责验证你的身份，并发放信用卡（授权令牌）。
Authorization Grant	授权许可，客户端获取授权令牌的方式，例如：授权码模式、密码模式、客户端模式、简化模式。	你向银行申请信用卡的方式，例如：通过在线申请、柜台申请等。
Access Token	访问令牌，客户端使用它来访问受保护资源，具有一定的有效期。	信用卡，你可以用它来消费，但有一定的有效期。
Refresh Token	刷新令牌，客户端可以使用它来获取新的访问令牌，而无需再次获得用户的授权。	信用卡到期后，你可以用它来申请新的信用卡。
Scope	权限范围，定义了客户端可以访问哪些资源。	信用卡的使用范围，例如：只能在国内消费，不能在国外消费。

Spring Security OAuth2：我们的“瑞士军刀”

Spring Security OAuth2为我们提供了强大的支持，它就像一把“瑞士军刀”，集成了各种OAuth2的实现，让我们能够轻松地构建安全的认证和授权系统。

接下来，咱们就用代码来实战一下，看看如何用Spring Security OAuth2来保护我们的微服务。

1. 添加依赖

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>

2. 配置Authorization Server (授权服务器)

我们需要一个授权服务器来处理用户的认证和授权请求。 这里我们使用Spring Authorization Server，它是Spring官方维护的OAuth2授权服务器实现。

@Configuration
@Import(OAuth2AuthorizationServerConfiguration.class)
public class AuthorizationServerConfig {

    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("client-id")
                .clientSecret("{noop}client-secret") // Never use noop in production!
                .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
                .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
                .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS) // Add client_credentials
                .redirectUri("http://127.0.0.1:8080/login/oauth2/code/messaging-client")
                .scope(OidcScopes.OPENID)
                .scope("message.read")
                .scope("message.write")
                .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build())
                .tokenSettings(TokenSettings.builder()
                        .accessTokenTimeToLive(Duration.ofMinutes(30))
                        .refreshTokenTimeToLive(Duration.ofDays(1))
                        .build())
                .build();

        return new InMemoryRegisteredClientRepository(registeredClient);
    }

    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
                .privateKey(privateKey)
                .keyID(UUID.randomUUID().toString())
                .build();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return new ImmutableJWKSet<>(jwkSet);
    }

    private static KeyPair generateRsaKey() {
        KeyPair keyPair;
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            keyPair = keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
        return keyPair;
    }

    @Bean
    public ProviderSettings providerSettings() {
        return ProviderSettings.builder().issuer("http://auth-server:9000").build(); // Use proper URL
    }

    @Bean
    public UserDetailsService users() {
        UserDetails user = User.withDefaultPasswordEncoder()
                .username("user")
                .password("password")
                .roles("USER")
                .build();
        return new InMemoryUserDetailsManager(user);
    }
}

解释：

• @Configuration：表示这是一个配置类。
• @Import(OAuth2AuthorizationServerConfiguration.class): 导入Spring Authorization Server的配置。
• registeredClientRepository()：配置客户端信息，包括客户端ID、客户端密钥、授权类型、重定向URI等。
  • clientId("client-id"): 客户端ID，客户端用来标识自己。
  • clientSecret("{noop}client-secret"): 客户端密钥，客户端用来验证自己的身份。 注意： {noop} 表示不加密，在生产环境中一定要使用加密的密钥。
  • clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC): 客户端认证方式，这里使用基于HTTP Basic Authentication的方式。
  • authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE): 授权类型，这里使用授权码模式。
  • authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN): 授权类型，支持刷新令牌。
  • authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS): 授权类型，支持客户端模式。
  • redirectUri("http://127.0.0.1:8080/login/oauth2/code/messaging-client"): 重定向URI，授权服务器在授权成功后将用户重定向到这个URI。
  • scope(OidcScopes.OPENID): 权限范围，这里使用OpenID Connect的OPENID权限，用于获取用户的基本信息。
  • scope("message.read"): 自定义权限范围，表示客户端可以读取消息。
  • scope("message.write"): 自定义权限范围，表示客户端可以写入消息。
  • clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build()): 客户端设置，这里要求用户必须同意授权。
  • tokenSettings(TokenSettings.builder() ... build()): 令牌设置，包括访问令牌的有效期和刷新令牌的有效期。
• jwkSource()：配置JWK Source，用于生成和管理JSON Web Key (JWK)，用于签名和验证JWT。
• providerSettings()：配置授权服务器的Provider Settings，包括Issuer URI。
• users()：配置用户信息，这里使用内存中的用户信息，用于演示。

3. 配置Resource Server (资源服务器)

现在，我们需要配置资源服务器来保护我们的微服务。

@Configuration
@EnableWebSecurity
public class ResourceServerConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/messages/**").hasAuthority("SCOPE_message.read")
                        .anyRequest().authenticated()
                )
                .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()));
        return http.build();
    }
}

解释：

• @Configuration：表示这是一个配置类。
• @EnableWebSecurity: 启用Spring Security。
• filterChain(HttpSecurity http)：配置HttpSecurity，用于定义安全策略。
  • authorizeHttpRequests(authorize -> ...): 配置授权规则。
    • requestMatchers("/messages/**").hasAuthority("SCOPE_message.read"): 表示/messages/**路径下的请求需要message.read权限。 注意： Spring Security会自动在权限前面加上SCOPE_前缀。
    • anyRequest().authenticated(): 表示所有其他的请求都需要认证。
  • oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults())): 配置OAuth2资源服务器，使用JWT进行身份验证。

4. 创建Controller

接下来，我们创建一个Controller来测试我们的资源服务器。

@RestController
public class MessageController {

    @GetMapping("/messages")
    public String getMessages() {
        return "Hello, world!";
    }

    @PostMapping("/messages")
    public String postMessage() {
        return "Message posted!";
    }
}

5. 配置application.yml

在application.yml文件中添加如下配置：

server:
  port: 8080

spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: http://auth-server:9000

解释：

• server.port: 配置服务器端口。
• spring.security.oauth2.resourceserver.jwt.issuer-uri: 配置JWT的Issuer URI，指向我们的授权服务器。

6. 测试

现在，我们可以启动我们的授权服务器和资源服务器，然后使用Postman或者curl来测试我们的API。

a. 获取Access Token

我们可以使用client_credentials授权类型来获取Access Token：

curl -X POST 
  -H "Content-Type: application/x-www-form-urlencoded" 
  -H "Authorization: Basic Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=" 
  http://auth-server:9000/oauth2/token 
  -d "grant_type=client_credentials&scope=message.read message.write"

解释：

• -H "Content-Type: application/x-www-form-urlencoded": 设置Content-Type为application/x-www-form-urlencoded。
• -H "Authorization: Basic Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=": 设置Authorization Header，使用Basic Authentication，其中Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=是client-id:client-secret的Base64编码。
• http://auth-server:9000/oauth2/token: 授权服务器的Token Endpoint。
• -d "grant_type=client_credentials&scope=message.read message.write": 请求参数，包括授权类型和权限范围。

b. 访问受保护的资源

获取到Access Token后，我们可以使用它来访问受保护的资源：

curl -X GET 
  -H "Authorization: Bearer <your_access_token>" 
  http://localhost:8080/messages

解释：

• -H "Authorization: Bearer <your_access_token>": 设置Authorization Header，使用Bearer Authentication，其中<your_access_token>是获取到的Access Token。
• http://localhost:8080/messages: 资源服务器的API Endpoint。

如果你没有message.read权限，你将会收到403 Forbidden的错误。

授权码模式 (Authorization Code Grant)

授权码模式是最常用的授权模式，它安全性较高，适用于Web应用。

流程如下：

1. 用户访问客户端： 用户通过浏览器访问客户端应用。
2. 客户端重定向到授权服务器： 客户端将用户重定向到授权服务器的授权端点，并携带客户端ID、重定向URI、权限范围等参数。
3. 用户登录并授权： 用户在授权服务器登录，并同意授权客户端访问自己的资源。
4. 授权服务器重定向回客户端： 授权服务器将用户重定向回客户端的重定向URI，并携带授权码。
5. 客户端使用授权码获取Access Token： 客户端使用授权码向授权服务器的令牌端点发送请求，并携带客户端ID、客户端密钥等参数。
6. 授权服务器颁发Access Token： 授权服务器验证客户端的身份，并颁发Access Token和Refresh Token。
7. 客户端使用Access Token访问资源服务器： 客户端使用Access Token访问资源服务器，获取受保护的资源。

配置：

在AuthorizationServerConfig中，我们已经配置了authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)和redirectUri("http://127.0.0.1:8080/login/oauth2/code/messaging-client")。

测试：

1. 访问http://auth-server:9000/oauth2/authorize?response_type=code&client_id=client-id&scope=openid message.read&redirect_uri=http://127.0.0.1:8080/login/oauth2/code/messaging-client (需要替换成你的授权服务器地址和客户端信息)。
2. 授权登录。
3. 授权服务器会重定向到http://127.0.0.1:8080/login/oauth2/code/messaging-client?code=...。
4. 你可以使用授权码来获取Access Token。

客户端模式 (Client Credentials Grant)

客户端模式适用于客户端自身需要访问资源服务器的场景，例如：定时任务。

配置：

在AuthorizationServerConfig中，我们已经配置了authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS)。

测试：

参考之前的client_credentials授权类型的测试。

Spring Security OAuth2 的“坑”与“填坑”指南

虽然Spring Security OAuth2功能强大，但使用过程中也难免会遇到一些“坑”，下面咱们就来总结一下常见的“坑”以及相应的“填坑”方法：

1. 配置错误： 这是最常见的“坑”，例如：客户端ID、客户端密钥、重定向URI等配置错误，导致认证失败。填坑方法： 仔细检查配置文件，确保所有配置项都正确无误。
2. 权限不足： 客户端没有足够的权限访问资源服务器，导致请求被拒绝。填坑方法： 检查客户端的权限范围，确保它包含了访问所需资源的权限。
3. Token过期： Access Token过期，导致请求被拒绝。填坑方法： 使用Refresh Token获取新的Access Token。
4. 安全性问题： 客户端密钥泄露，导致攻击者可以冒充客户端访问资源服务器。填坑方法： 使用安全的存储方式保存客户端密钥，例如：使用加密算法进行加密。

总结

Spring Security OAuth2是构建安全的微服务架构的利器，它能够简化用户管理、提高安全性、增强用户体验、促进服务解耦。

当然，要掌握Spring Security OAuth2，还需要不断学习和实践，才能真正做到“知其然，更知其所以然”。

希望这篇文章能够帮助你更好地理解Spring Security OAuth2，并在你的微服务项目中发挥它的威力！

最后，别忘了给个👍哦！ 咱们下次再见！