Spring Security OAuth2 实战

Spring Security OAuth2

OAuth（Open Authorization）是一个关于授权（authorization）的开放网络标准，允许用户授权第三
方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方移动应用或
分享他们数据的所有内容
OAuth协议：https://tools.ietf.org/html/rfc6749

协议特点：
简单：不管是OAuth服务提供者还是应用开发者，都很易于理解与使用；
安全：没有涉及到用户密钥等信息，更安全更灵活；
开放：任何服务提供商都可以实现OAuth，任何软件开发商都可以使用OAuth；

适用场景

原生app授权：app登录请求后台接口，为了安全认证，所有请求都带token信息，如果登录验证、
请求后台数据。
前后端分离单页面应用：前后端分离框架，前端请求后台数据，需要进行oauth2安全认证，比如
使用vue、react后者h5开发的app
第三方应用授权登录，比如QQ，微博，微信的授权登录。

优缺点

优点：
更安全，客户端不接触用户密码，服务器端更易集中保护
广泛传播并被持续采用
短寿命和封装的token
资源服务器和授权服务器解耦
集中式授权，简化客户端
HTTP/JSON友好，易于请求和传递token
考虑多种客户端架构场景
客户可以具有不同的信任级别
缺点：
协议框架太宽泛，造成各种实现的兼容性和互操作性差
不是一个认证协议，本身并不能告诉你任何用户信息。

颁发令牌方式

授权码模式（authorization code）
密码模式（resource owner password credentials）
简化(隐式)模式（implicit）
客户端模式（client credentials）

授权码模式

授权码（authorization code）方式，指的是第三方应用先申请一个授权码，然后再用该码获取令牌。
这种方式是最常用的流程，安全性也最高，它适用于那些有后端的 Web 应用。授权码通过前端传送，
令牌则是储存在后端，而且所有与资源服务器的通信都在后端完成。这样的前后端分离，可以避免令牌
泄漏。
适用场景：目前市面上主流的第三方验证都是采用这种模式

http://localhost:60818/oauth2/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://www.baidu.com&scope=all
或者: http://localhost:60818/oauth2/oauth/authorize?response_type=code&client_id=client
response_type：表示授权类型，必选项，此处的值固定为"code"
client_id：表示客户端的ID，必选项
redirect_uri：表示重定向URI，可选项
scope：表示申请的权限范围，可选项
state：表示客户端的当前状态，可以指定任意值，授权服务器会原封不动地返回这个值。

密码模式

如果你高度信任某个应用，RFC 6749 也允许用户把用户名和密码，直接告诉该应用。该应用就使用你
的密码，申请令牌，这种方式称为"密码式"（password）。
在这种模式中，用户必须把自己的密码给客户端，但是客户端不得储存密码。这通常用在用户对客户端
高度信任的情况下，比如客户端是操作系统的一部分，或者由一个著名公司出品。而授权服务器只有在
其他授权模式无法执行的情况下，才能考虑使用这种模式。
适用场景：自家公司搭建的授权服务器

客户端模式

客户端模式（Client Credentials Grant）指客户端以自己的名义，而不是以用户的名义，向"服务提供
商"进行授权。
适用于没有前端的命令行应用，即在命令行下请求令牌。一般用来提供给我们完全信任的服务器端服
务

更新令牌

令牌的有效期到了，如果让用户重新走一遍上面的流程，再申请一个新的令牌，很可能体验不好，而且
也没有必要。OAuth 2.0 允许用户自动更新令牌。

关键配置

认证授权服务配置

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Resource
    private AuthenticationManager authenticationManager;

    @Resource
    private MemberUserService memberUserService;

    @Resource
    private DataSource dataSource;

    @Resource
    private SecurityConfigProperties jwtConfigProperties;

    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        //jwt的密钥
        converter.setSigningKey(jwtConfigProperties.getSignatureKey());
        return converter;
    }

    @Bean
    public TokenEnhancer oAuthTokenEnhancer() {
        return new OauthTokenEnhancer();
    }

    /**
     * 方法实现说明:认证服务器能够给哪些 客户端颁发token  我们需要把客户端的配置 存储到
     * 数据库中 可以基于内存存储和db存储
     *授权码模式
     *http://localhost:60818/oauth2/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://www.baidu.com&scope=all
     或者: http://localhost:60818/oauth2/oauth/authorize?response_type=code&client_id=client
     * password模式
     * http://localhost:60818/oauth2/oauth/token?username=gene&password=123456&grant_type=password&client_id=client&client_secret=123123&scope=all
     *
     * 客户端模式,可进行完全信任客户端
     * http://localhost:60818/oauth2/oauth/token?grant_type=client_credentials&scope=all&client_id=client&client_secret=123123
     *
     * 简化模式
     * http://localhost:60818/oauth2/oauth/token?response_type=token&scope=read&client_id=client&redirect_uri=xxxxx
     *
     * 刷新令牌
     * http://localhost:60818/oauth2/oauth/token?grant_type==refresh_token&scope=all&client_id=client&client_secret=123123&refresh_token=REFRESH_TOKEN
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.withClientDetails(clientDetails());
    }

    /**
     * 方法实现说明:用于查找我们第三方客户端的组件 主要用于查找 数据库表 oauth_client_details
     * 查找授权client_id client-secret grant_type 权限范围 token的有效期/刷新token有效期/redirect_uri 等信息
     */
    @Bean
    public ClientDetailsService clientDetails() {
        return new JdbcClientDetailsService(dataSource);
    }

    /**
     * 方法实现说明:授权服务器的配置的配置
     *
     * @author:smlz
     * @return:
     * @exception:
     * @date:2020/1/15 20:21
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        // token增强器
        TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain();
        tokenEnhancerChain.setTokenEnhancers(Arrays.asList(oAuthTokenEnhancer(), jwtAccessTokenConverter()));
        //使用密码模式需要配置
        endpoints.authenticationManager(authenticationManager)
                //refresh_token是否重复使用
                .reuseRefreshTokens(false)
                //刷新令牌授权包含对用户信息的检查
                .userDetailsService(memberUserService)
                //指定token存储策略是jwt
                .tokenStore(tokenStore())
                .accessTokenConverter(jwtAccessTokenConverter())
                //配置tokenEnhancer
                .tokenEnhancer(tokenEnhancerChain)
                //支持GET,POST请求
                .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST);
    }

    /**
     * 方法实现说明:授权服务器安全配置
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        //第三方客户端校验token需要带入 clientId 和clientSecret来校验
        security.checkTokenAccess("isAuthenticated()")
                //来获取我们的tokenKey需要带入clientId,clientSecret
                .tokenKeyAccess("isAuthenticated()");
        //允许表单认证
        security.allowFormAuthenticationForClients();
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

资源服务器配置

@Configuration
@EnableResourceServer
public class ResourceServiceConfig extends ResourceServerConfigurerAdapter {

    @Resource
    private SecurityConfigProperties securityConfigProperties;
    @Override
    public void configure(HttpSecurity http) throws Exception {
        ExpressionUrlAuthorizationConfigurer.ExpressionInterceptUrlRegistry registry = http
                .authorizeRequests();
        for (String url : securityConfigProperties.getUrls()) {
            registry.antMatchers(url).permitAll();
        }
        http.authorizeRequests()
        .anyRequest().authenticated()
                // member服务授权
        .and().requestMatchers().antMatchers("/member/**");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

spring security配置

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Resource
    public MemberUserService memberUserService;

    /**
     * 方法实现说明:用于构建用户认证组件,需要传递userDetailsService和密码加密器
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(memberUserService).passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Resource
    private SecurityConfigProperties securityConfigProperties;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        ExpressionUrlAuthorizationConfigurer.ExpressionInterceptUrlRegistry registry = http
                .authorizeRequests();
        for (String url : securityConfigProperties.getUrls()) {
            registry.antMatchers(url).permitAll();
        }
        http.formLogin().permitAll()
                .and().authorizeRequests()
                .antMatchers("/oauth/**").permitAll()
                .anyRequest().authenticated()
                .and().logout().permitAll()
                .and().csrf().disable();
    }

}
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

@Data
@Component
@RefreshScope
public class SecurityConfigProperties {

    // jwt 放开的请求
    @Value("#{'${security.url.ignored:login}'.split(',')}")
    private List urls = new ArrayList<>();
    @Value("${security.url.login.path:wx/login}")
    private String loginPath;

    @Value("${jwt.signature-key:xxxxxxx")
    private String signatureKey;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

token增强器

@Slf4j
public class OauthTokenEnhancer implements TokenEnhancer {
    @Override
    public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
        // 通过openFegin调用会员信息
        if (authentication.getPrincipal() instanceof MemberDetails) {
            MemberDetails userDetails = (MemberDetails) authentication.getPrincipal();
            final Map additionalInfo = new HashMap<>();
            final Map retMap = new HashMap<>();
            //这里暴露memberId到Jwt的令牌中,后期可以根据自己的业务需要 进行添加字段
            MemberData memberData = userDetails.getMemberData();
            additionalInfo.put("openId", memberData.getMiniOpenid());
            additionalInfo.put("unionId", memberData.getUnionId());
            retMap.put("account", additionalInfo);
            ((DefaultOAuth2AccessToken) accessToken).setAdditionalInformation(retMap);
        } else {
            Object principal = authentication.getPrincipal();
            log.info("客户端模式或者简要模式或刷新令牌: principal");
        }
        return accessToken;
    }
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

用户名密码认证UserDetailsService

@Service
@Slf4j
public class MemberUserService implements UserDetailsService {
    @Autowired
    private MemberFeignService memberFeignService;
    @Override
    public UserDetails loadUserByUsername(String username) throws
            UsernameNotFoundException {
        if (StringUtils.isEmpty(username)) {
            log.warn("用户登陆用户名为空:{}", username);
            throw new UsernameNotFoundException("用户名不能为空");
        }
        MemberData memberData = getByUsername(username);
        if (null == memberData) {
            log.warn("根据用户名没有查询到对应的用户信息:{}", username);
        }
        log.info("根据用户名:{}获取用户登陆信息:{}", username, memberData);

        MemberDetails memberDetails = new MemberDetails(memberData);
        return memberDetails;
    }

    public MemberData getByUsername(String username) {
        // fegin获取会员信息
        CommonResult memberCommonResult = memberFeignService.loadUserByUsername(username);
        return umsMemberCommonResult.getResult();
        // 测试阶段模拟
        /*return MemberData.builder().memberNo("root123").username(username).password(new BCryptPasswordEncoder().encode("123")).miniOpenid("xxxxopenid")
                .status(1).unionId("xxxunionId").build();*/
    }
}
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

官方的Oauth2.sql

    /*
    SQLyog Ultimate v12.08 (64 bit)
    MySQL - 8.0.16 : Database - security_authority
    网址: https://github.com/spring-attic/spring-security-oauth/blob/main/spring-security-oauth2/src/test/resources/schema.sql
    *********************************************************************
    */
    /*Table structure for table `oauth_access_token` */

    DROP TABLE IF EXISTS `oauth_access_token`;

    CREATE TABLE `oauth_access_token` (
      `token_id` varchar(255) DEFAULT NULL,
      `token` longblob,
      `authentication_id` varchar(255) DEFAULT NULL,
      `user_name` varchar(255) DEFAULT NULL,
      `client_id` varchar(255) DEFAULT NULL,
      `authentication` longblob,
      `refresh_token` varchar(255) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    /*Data for the table `oauth_access_token` */

    /*Table structure for table `oauth_approvals` */

    DROP TABLE IF EXISTS `oauth_approvals`;

    CREATE TABLE `oauth_approvals` (
       `userId` varchar(255) DEFAULT NULL,
       `clientId` varchar(255) DEFAULT NULL,
       `scope` varchar(255) DEFAULT NULL,
       `status` varchar(10) DEFAULT NULL,
       `expiresAt` datetime DEFAULT NULL,
       `lastModifiedAt` datetime DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    /*Data for the table `oauth_approvals` */

    /*Table structure for table `oauth_client_details` */

    DROP TABLE IF EXISTS `oauth_client_details`;

    CREATE TABLE `oauth_client_details` (
        `client_id` varchar(255) NOT NULL,
        `resource_ids` varchar(255) DEFAULT NULL,
        `client_secret` varchar(255) DEFAULT NULL,
        `scope` varchar(255) DEFAULT NULL,
        `authorized_grant_types` varchar(255) DEFAULT NULL,
        `web_server_redirect_uri` varchar(255) DEFAULT NULL,
        `authorities` varchar(255) DEFAULT NULL,
        `access_token_validity` int(11) DEFAULT NULL,
        `refresh_token_validity` int(11) DEFAULT NULL,
        `additional_information` varchar(255) DEFAULT NULL,
        `autoapprove` varchar(255) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    /*Data for the table `oauth_client_details` */

    /*Table structure for table `oauth_client_token` */

    DROP TABLE IF EXISTS `oauth_client_token`;

    CREATE TABLE `oauth_client_token` (
      `token_id` varchar(255) DEFAULT NULL,
      `token` longblob,
      `authentication_id` varchar(255) DEFAULT NULL,
      `user_name` varchar(255) DEFAULT NULL,
      `client_id` varchar(255) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    /*Data for the table `oauth_client_token` */

    /*Table structure for table `oauth_code` */

    DROP TABLE IF EXISTS `oauth_code`;

    CREATE TABLE `oauth_code` (
      `code` varchar(255) DEFAULT NULL,
      `authentication` varbinary(2550) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    /*Data for the table `oauth_code` */

    /*Table structure for table `oauth_refresh_token` */

    DROP TABLE IF EXISTS `oauth_refresh_token`;

    CREATE TABLE `oauth_refresh_token` (
    `token_id` varchar(255) DEFAULT NULL,
    `token` longblob,
    `authentication` longblob
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    /*Data for the table `oauth_refresh_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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

表描述

oauth_client_details【核心表】

该表用于在客户端系统中存储从服务端获取的token数据, 在spring-oauth-server项目中未使用到. 对oauth_client_token表的主要操作在JdbcClientTokenServices.java类中, 更多的细节请参考该类

oauth_access_token

在项目中,主要操作oauth_refresh_token表的对象是JdbcTokenStore.java. (与操作oauth_access_token表的对象一样);更多的细节请参考该类. 如果客户端的grant_type不支持refresh_token,则不会使用该表

Spring Security默认的过滤器顺序列表