Spring Security 6.x 系列【28】授权服务器篇之Spring Authorization Server 1.0 入门案例

痛定思痛。 2023-10-09 19:02 15阅读 0赞

> **有道无术，术尚可求，有术无道，止于术。**
> 
> **本系列Spring Boot 版本 3.0.4** 
> 
> **本系列Spring Security 版本 6.0.2** 
> 
> **本系列Spring Authorization Server 版本 1.0.2** 
> 
> **源码地址：https://gitee.com/pearl-organization/study-spring-security-demo**

#### 文章目录 ####

*   *  1. 前言
     *  2. ~~Spring Security OAuth~~
     *   *  2.1 简介
         *  2.2 停止维护
     *  3. Spring Authorization Server
     *   *  3.1 简介
         *  3.2 功能特性
     *  4. 案例演示
     *   *  4.1 环境搭建
         *  4.2 配置类
         *  4.3 授权码模式
         *  4.4 客户端模式
         *  4.5 刷新令牌模式

### 1. 前言 ###

在前几篇文档中，我们学习了`OAuth 2.0`协议，并使用`spring-security-oauth2-client`完成了基于授权码模式的第三方平台登录功能。

`OAuth 2.0`中的四大角色，`Spring Security`原生框架已经帮我们实现了**资源所有者、客户端、资源服务器**，那么`Spring`是否提供了**授权服务器**的实现呢？

### 2. Spring Security OAuth ###

[GitHub地址][GitHub]

#### 2.1 简介 ####

在`OAuth 1.0`时代，`Spring`组织已经开始开发基于`Spring Security`对`OAuth`的支持，该框架就是`Spring Security OAuth`。其实现了大部分的`OAuth`规范，并提供了**资源服务器、客户端和授权服务器**。

#### 2.2 停止维护 ####

**2018年1月**，`Spring`官方发布了一个将会停更`Spring Security OAuth`的通知，并开始在 `Spring Security 5.0`中构建下一代`0Auth2.0`支持。

**2019年11月**，`Spring Security 0Auth`中**客户端、资源服务器**的功能大部分已迁移到`Spring Security 5`中，在`5.3`版本中完成了迁移工作，并添加了许多新功能，比如对`OpenID Connect 1.0`的支持。

在`Spring Security`源码`oauth2`模块中可以看到相关体现：

![在这里插入图片描述][15b0ec2cf78b4ad886174fa99437ed11.png]

同时还宣布不再支持**授权服务器**，因为`Spring`觉得授权服务器更像是一个产品，而`Spring Security`作为框架，并不适合做这件事情，而且已经有大量商业和开源并且成熟的**授权服务器**。

**2022年5月31日**，`Spring Security OAuth`正式归档。

### 3. Spring Authorization Server ###

[GitHub地址][GitHub 1]

`Spring Security OAuth`的停止维护，以及`Spring Security`不再提供**授权服务器**这件事，在社区一石激起千层浪，引起很多人的反对，经过`Spring`社区的努力，`Spring`决定在**2020年4月**开始启动新的**授权服务器**项目。

#### 3.1 简介 ####

`Spring Authorization Server`是一个授权服务器框架，提供 [OAuth 2.1][] 和 [OpenID Connect 1.0][] 规范及其他相关规范的实现。它建立在 `Spring Security` 之上，为构建开发标准的**授权服务器**产品提供了一个安全、轻量级和可定制的基础。

**注意：** 是基于`OAuth 2.1`而不是`2.0`！！！目前最新版本为`1.0.2`，早前已经成为`spring-projects`下的正式项目，表明已经生产可用！！！

#### 3.2 功能特性 ####

**授权模式支持：**

*  授权码模式
 *  客户端模式
 *  刷新令牌模式

**令牌格式支持：**

*  **JWT**
 *  **JWS**

**客户端认证方式支持：**

*  **client\_secret\_basic**：基于`Basic`消息头认证
 *  **client\_secret\_post**：`POST`请求进行认证
 *  **private\_key\_jwt**： 基于`JWT`进行认证，请求方使用私钥对`JWT`签名，授权服务器使用对应公钥进行验签认证
 *  **client\_secret\_jwt**：基于`JWT`进行认证，对`JWT`使用**客户端密码+签名算法** 签名
 *  **none (public clients)**：公共客户端

**协议端点支持：**

*  **OAuth2 Authorization Endpoint**：申请授权端点，默认为`/oauth2/authorize`
 *  **OAuth2 Token Endpoint**：获取访问令牌端点，默认为`/oauth2/token`
 *  **OAuth2 Token Introspection Endpoint**：令牌自省端点，默认为`/oauth2/introspect`
 *  **OAuth2 Token Revocation Endpoint**：令牌撤销端点，默认为`/oauth2/revoke`
 *  **OAuth2 Authorization Server Metadata Endpoint**：获取授权服务器元信息的端点，默认为`/.well-known/oauth-authorization-server`
 *  **JWK Set Endpoint**：`JWK`信息端点，默认为`/oauth2/jwks`
 *  **OpenID Connect 1.0 Provider Configuration Endpoint**：查询提供者配置端点，默认为`/.well-known/openid-configuration`
 *  **OpenID Connect 1.0 UserInfo Endpoint**：用户信息端点，默认为`/userinfo`
 *  **OpenID Connect 1.0 Client Registration Endpoint**：客户端注册端点，默认为`/connect/registe`

### 4. 案例演示 ###

`Spring Authorization Server`基于 [OAuth 2.1][] 和 [OpenID Connect 1.0][] 规范，`OAuth 2.1`和`2.0`最大的区别就是删除了密码和简化模式。

#### 4.1 环境搭建 ####

创建一个`Spring Boot`基础工程，引入`Spring`授权服务器依赖：

<dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-oauth2-authorization-server</artifactId>
                <version>1.0.2</version>
            </dependency>

#### 4.2 配置类 ####

添加`SpringSecurity`配置类，授权服务器是基于`Spring Security`开发的，本身也需要认证授权功能。

@Configuration(proxyBeanMethods = false)
    public class SpringSecurityConfig {
        
    
        /**
         * Spring Security SecurityFilterChain 认证配置
         */
        @Bean
        @Order(2)
        public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http)
                throws Exception {
        
            http.authorizeHttpRequests((authorize) -> authorize
                            .anyRequest().authenticated()
                    )
                    .formLogin(Customizer.withDefaults());
            return http.build();
        }
    
        /**
         * 内存存储用户
         */
        @Bean
        public UserDetailsService userDetailsService() {
        
            UserDetails userDetails = User.withDefaultPasswordEncoder()
                    .username("user")
                    .password("123456")
                    .roles("USER")
                    .build();
            return new InMemoryUserDetailsManager(userDetails);
        }
    }

添加授权服务器配置类：

@Configuration(proxyBeanMethods = false)
    public class SpringAuthServerConfig {
        
    
        /**
         * 授权服务器 SecurityFilterChain
         */
        @Bean
        @Order(Ordered.HIGHEST_PRECEDENCE)
        public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http)
                throws Exception {
        
            OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);
            http.getConfigurer(OAuth2AuthorizationServerConfigurer.class)
                    .oidc(Customizer.withDefaults());    // Enable OpenID Connect 1.0
            http
                    // Redirect to the login page when not authenticated from the
                    // authorization endpoint
                    .exceptionHandling((exceptions) -> exceptions
                            .authenticationEntryPoint(
                                    new LoginUrlAuthenticationEntryPoint("/login"))
                    )
                    // Accept access tokens for User Info and/or Client Registration
                    .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
            return http.build();
        }
    
        /**
         * 客户端配置，基于内存
         */
        @Bean
        public RegisteredClientRepository registeredClientRepository() {
        
            // http://localhost:8080/oauth2/authorize?client_id=client&scope=user_info&state=123456&response_type=code&redirect_uri=http://127.0.0.1:8080/authorized
            RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
                    .clientId("client")
                    .clientSecret("{noop}secret")
                    .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
                    .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
                    .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
                    .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS)
                    .redirectUri("http://127.0.0.1:8080/callback")
                    .scope("user_info")
                    .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build())
                    .build();
            return new InMemoryRegisteredClientRepository(registeredClient);
        }
    
    
        /**
         * 解码签名访问令牌
         */
        @Bean
        public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
        
            return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
        }
    
        /**
         * 配置Spring授权服务器
         */
        @Bean
        public AuthorizationServerSettings authorizationServerSettings() {
        
            return AuthorizationServerSettings.builder().build();
        }
        
        /**
         * 访问令牌签名
         */
        @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);
        }
    
        /**
         * 其 key 在启动时生成，用于创建上述 JWKSource
         */
        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;
        }
    }

#### 4.3 授权码模式 ####

浏览器地址栏访问**申请授权码**端点：

http://localhost:8080/oauth2/authorize?
    client_id=client&
    scope=user_info&
    state=123456&
    response_type=code&
    redirect_uri=http://127.0.0.1:8080/callback

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
   <th>是否必填</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>client_id</td> 
   <td>客户端<code>ID</code></td> 
   <td>YES</td> 
  </tr> 
  <tr> 
   <td>response_type</td> 
   <td>响应模式，固定为<code>code </code>（授权码）</td> 
   <td>YES</td> 
  </tr> 
  <tr> 
   <td>redirect_uri</td> 
   <td>回调地址，当授权码申请成功后l浏览器会重定向到此地址，并在后边带上<code>code</code>参数（授权码）</td> 
   <td>YES</td> 
  </tr> 
  <tr> 
   <td>scope</td> 
   <td>用来限制客户端的访问范围（权限），如果为空的话，那么会返回客户端拥有全部的访问范围</td> 
   <td>NO</td> 
  </tr> 
  <tr> 
   <td>state</td> 
   <td>可以取随机值， 用于防止<code>CSRF</code>攻击</td> 
   <td>NO</td> 
  </tr> 
 </tbody> 
</table>

之后会调转到登录接口，输入用户名密码：

![在这里插入图片描述][7e4e556f224a4306b78ff73b2c2f83b8.png]  
登录成功后跳转到授权页面，是否允许这个客户端访问你的资源，选择允许访问的范围，点击`Submit Consent`提交授权：

![在这里插入图片描述][6897f53a502e415da3f5172088d68bb3.png]  
之后浏览器会重定向到**回调地址**，并携带授权码参数：

![在这里插入图片描述][c3aa0a9454404b92b310cca079475a89.png]  
重定向`URL`如下所示：

http://127.0.0.1:8080/callback?
    code=5rZRbGqLbqWxj1aeLP9otKce0XE_CfH4&
    state=123456

接着使用授权码获取访问令牌端，需要`Post`请求，这里使用`Postman`，访问地址为`http://localhost:8080/oauth2/token`，首先需要传入客户端的`ID`及密码，可以采用`Basic`认证方式，并将其拼接成**用户名:密码**格式，中间是一个冒号，再用`Base64`编码，然后在请求头中附加 `Authorization:Basic xxx`。这里可以使用`Postman`选择`Basic Auth`，然后输入客户端`ID`及密码。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70]  
添加请求参数，发送请求，可以看到成功返回了访问令牌、刷新令牌等信息：

![在这里插入图片描述][463c916f961d4fb5b23ddefb5c4c3238.png]

请求参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>code</td> 
   <td>授权码，就是刚刚获取的授权码，注意：授权码只使用一次就无效了，需要重新申请</td> 
  </tr> 
  <tr> 
   <td>grant_type</td> 
   <td>授权类型，填写<code>authorization_code</code>，表示授权码模式</td> 
  </tr> 
  <tr> 
   <td>redirect_uri</td> 
   <td>申请授权码时的跳转<code>url</code>，一定要和申请授权码时用的<code>redirect_uri</code>一致。</td> 
  </tr> 
 </tbody> 
</table>

当再次点击时，会报错，说明`code`只能使用一次：

![在这里插入图片描述][20210715175049289.png]

#### 4.4 客户端模式 ####

客户端模式，可以直接通过**客户端认证**返回访问令牌，授权类型为`client_credentials`，访问端点为：

http://localhost:8080/oauth2/token?grant_type=client_credentials

首先设置`Basic`认证参数：

![在这里插入图片描述][8cbb8c48a2034dbb9dec4fce8c219f73.png]

发送请求返回令牌：

![在这里插入图片描述][a6389431529b45d5a15b0f75659e8e3e.png]

#### 4.5 刷新令牌模式 ####

访问令牌的**有效期**一般较短，这样可以保证在发生访问令牌泄露时，不至于造成太坏的影响，但是因为有限期太短，过期之后，需要重新授权获取令牌，这种方式不太友好。

所以在下发访问令牌的同时下发一个有效期较长的刷新令牌，访问令牌失效时，可以利用刷新令牌去授权服务器换取新的访问令牌。

首先同上设置`Basic`认证参数，然后访问`/oauth2/token`：

![在这里插入图片描述][f352b4d3de25469fbc3f200fff4285fc.png]  
请求参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>refresh_token</td> 
   <td>刷新令牌</td> 
  </tr> 
  <tr> 
   <td>grant_type</td> 
   <td>授权类型，填写<code>refresh_token</code>，表示刷新令牌模式</td> 
  </tr> 
 </tbody> 
</table>

响应结果如下：

![在这里插入图片描述][d8289da497f6469cbb695db5b74bab6c.png]

[GitHub]: https://github.com/spring-attic/spring-security-oauth
[15b0ec2cf78b4ad886174fa99437ed11.png]: https://img-blog.csdnimg.cn/15b0ec2cf78b4ad886174fa99437ed11.png
[GitHub 1]: https://github.com/spring-projects/spring-authorization-server/
[OAuth 2.1]: https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-07
[OpenID Connect 1.0]: https://openid.net/specs/openid-connect-core-1_0.html
[7e4e556f224a4306b78ff73b2c2f83b8.png]: https://img-blog.csdnimg.cn/7e4e556f224a4306b78ff73b2c2f83b8.png
[6897f53a502e415da3f5172088d68bb3.png]: https://img-blog.csdnimg.cn/6897f53a502e415da3f5172088d68bb3.png
[c3aa0a9454404b92b310cca079475a89.png]: https://img-blog.csdnimg.cn/c3aa0a9454404b92b310cca079475a89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210715174353380.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDM3ODc0,size_16,color_FFFFFF,t_70
[463c916f961d4fb5b23ddefb5c4c3238.png]: https://img-blog.csdnimg.cn/463c916f961d4fb5b23ddefb5c4c3238.png
[20210715175049289.png]: https://img-blog.csdnimg.cn/20210715175049289.png
[8cbb8c48a2034dbb9dec4fce8c219f73.png]: https://img-blog.csdnimg.cn/8cbb8c48a2034dbb9dec4fce8c219f73.png
[a6389431529b45d5a15b0f75659e8e3e.png]: https://img-blog.csdnimg.cn/a6389431529b45d5a15b0f75659e8e3e.png
[f352b4d3de25469fbc3f200fff4285fc.png]: https://img-blog.csdnimg.cn/f352b4d3de25469fbc3f200fff4285fc.png
[d8289da497f6469cbb695db5b74bab6c.png]: https://img-blog.csdnimg.cn/d8289da497f6469cbb695db5b74bab6c.png