转自极客时间,仅供非商业用途或交流学习使用,如有侵权请联系删除
你好,我朱晔,是《Java业务开发常见错误100例》专栏课程的作者。
《OAuth 2.0实战课》上线之后,我也第一时间关注了这门课。在开篇词中,我看到有一些同学留言问道:“如何使用Spring Security来实现OAuth 2.0?”这时,我想到之前自己写过一篇相关的文章,于是就直接在开篇词下留了言。后面我很快收到了不少用户的点赞和肯定,紧接着极客时间编辑也邀请我从自己的角度为专栏写篇加餐。好吧,功不唐捐,于是我就将之前我写的那篇老文章再次迭代、整理为今天的这一讲内容,希望可以帮助你掌握OAuth 2.0。
如果你熟悉Spring Security的话,肯定知道它因为功能多、组件抽象程度高、配置方式多样,导致了强大且复杂的特性。也因此,Spring Security的学习成本几乎是Spring家族中最高的。但不仅于此,在结合实际的复杂业务场景使用Spring Security时,我们还要去理解一些组件的工作原理和流程,不然需要自定义和扩展框架的时候就会手足无措。这就让使用Spring Security的门槛更高了。
因此,在决定使用Spring Security搭建整套安全体系(授权、认证、权限、审计)之前,我们还需要考虑的是:将来我们的业务会多复杂,徒手写一套安全体系来得划算,还是使用Spring Security更好?我相信,这也是王老师给出课程配套代码中,并没有使用Spring Security来演示OAuth 2.0流程的原因之一。
反过来说,如果你的应用已经使用了Spring Security来做鉴权、认证和权限管理的话,那么仍然使用Spring Security来实现OAuth的成本是很低的。而且,在学习了OAuth 2.0的流程打下扎实的基础之后,我们再使用Spring Security来配置OAuth 2.0就不会那么迷茫了。这也是我在工作中使用Spring Security来实现OAuth 2.0的直观感受。
所以,我就结合自己的实践和积累,带你使用Spring Security来一步一步地搭建一套基于JWT的OAuth 2.0授权体系。这些内容会涉及OAuth 2.0的三角色(客户端、授权服务、受保护资源),以及资源拥有者凭据许可、客户端凭据许可和授权码许可这三种常用的授权许可类型(隐式许可类型,不太安全也不太常用)。同时,我还会演示OAuth 2.0的权限控制,以及使用OAuth 2.0实现SSO单点登录体系。
这样一来,今天这一讲涉及到的流程就会比较多,内容也会很长。不过不用担心,我会手把手带你从零开始,完成整个程序的搭建,并给出所有流程的演示。
项目准备工作
实战之前,我们先来搭建项目父依赖和初始化数据库结构,为后面具体的编码做准备。
首先,我们来创建一个父POM,内含三个模块:
- springsecurity101-cloud-oauth2-client,用来扮演客户端角色;
- springsecurity101-cloud-oauth2-server,用来扮演授权服务器角色;
- springsecurity101-cloud-oauth2-userservice,是用户服务,用来扮演资源提供者角色。
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>me.josephzhu</groupId> <artifactId>springsecurity101</artifactId> <packaging>pom</packaging> <version>1.0-SNAPSHOT</version> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.1.RELEASE</version> <relativePath/> </parent> <modules> <module>springsecurity101-cloud-oauth2-client</module> <module>springsecurity101-cloud-oauth2-server</module> <module>springsecurity101-cloud-oauth2-userservice</module> </modules> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> </dependencies> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Greenwich.SR4</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build></project>
然后,我们来创建一个oauth数据库,初始化将来会用到的5个表。
- authorities表:记录账号的权限,需要我们在后面配置。
- oauth_approvals表:记录授权批准的状态。
- oauth_client_details表:记录OAuth的客户端,需要我们在后面做配置。
- oauth_code表:记录授权码。
- users表:记录账号,需要我们在后面做初始化。
SET NAMES utf8mb4;SET FOREIGN_KEY_CHECKS = 0;-- ------------------------------ Table structure for authorities-- ----------------------------DROP TABLE IF EXISTS authorities
;CREATE TABLE authorities
( username
varchar(50) NOT NULL, authority
varchar(50) NOT NULL, UNIQUE KEY ix_auth_username
(username
,authority
), CONSTRAINT fk_authorities_users
FOREIGN KEY (username
) REFERENCES users
(username
)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;-- ------------------------------ Table structure for oauth_approvals-- ----------------------------DROP TABLE IF EXISTS oauth_approvals
;CREATE TABLE oauth_approvals
( userId
varchar(256) DEFAULT NULL, clientId
varchar(256) DEFAULT NULL, partnerKey
varchar(32) DEFAULT NULL, scope
varchar(256) DEFAULT NULL, status
varchar(10) DEFAULT NULL, expiresAt
datetime DEFAULT NULL, lastModifiedAt
datetime DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- ------------------------------ Table structure for 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(4096) DEFAULT NULL, autoapprove
varchar(255) DEFAULT NULL, PRIMARY KEY (client_id
)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;-- ------------------------------ Table structure for oauth_code-- ----------------------------DROP TABLE IF EXISTS oauth_code
;CREATE TABLE oauth_code
( code
varchar(255) DEFAULT NULL, authentication
blob) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;-- ------------------------------ Table structure for users-- ----------------------------DROP TABLE IF EXISTS users
;CREATE TABLE users
( username
varchar(50) NOT NULL, password
varchar(100) NOT NULL, enabled
tinyint(1) NOT NULL, PRIMARY KEY (username
)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;SET FOREIGN_KEY_CHECKS = 1;
这5个表是Spring Security OAuth需要用到的存储表,我们不要去修改既有的表结构。这里可以看到,我们并没有在数据库中创建相应的表,来存放访问令牌和刷新令牌。这是因为,我们之后的实现会使用JWT来传输令牌信息,以便进行本地校验,所以并不一定要将其存放到数据库中。基本上所有的这些表都是可以自己扩展的,只需要继承实现Spring的一些既有类即可,这里不做展开。
接下来,我们开始搭建授权服务器和受保护资源服务器。
搭建授权服务器
我们先创建第一个模块,也就是授权服务器。首先创建POM,配置依赖:
<?xml version="1.0" encoding="UTF-8"?><project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent> <artifactId>springsecurity101</artifactId> <groupId>me.josephzhu</groupId> <version>1.0-SNAPSHOT</version> </parent> <modelVersion>4.0.0</modelVersion> <artifactId>springsecurity101-cloud-oauth2-server</artifactId> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-oauth2</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> </dependencies></project>
这里,我们使用了Spring Cloud的spring-cloud-starter-oauth2组件,而不是直接使用的Spring Security,因为前者做了一些自动化配置的工作,使用起来会更方便。
此外,我们还在POM中加入了数据访问、Web等依赖,因为我们的受保护资源服务器需要使用数据库来保存客户端的信息、用户信息等数据,同时也会引入thymeleaf模板引擎依赖,来稍稍美化一下登录页面。
然后创建一个配置文件application.yml实现程序配置:
server: port: 8080spring: application: name: oauth2-server datasource: url: jdbc:mysql://localhost:6657/oauth?useSSL=false username: root password: kIo9u7Oi0eg driver-class-name: com.mysql.jdbc.Driver
可以看到,我们配置了oauth数据库的连接字符串,定义了授权服务器的监听端口是8080。
最后,使用keytool工具生成密钥对,把密钥文件jks保存到资源目录下,并要导出一个公钥留作以后使用。
以上完成了项目框架搭建工作,接下来,我们正式开始编码。
第一步,创建一个最核心的类用于配置授权服务器。我把每段代码的作用放在了注释里,你可以直接看下。
@Configuration@EnableAuthorizationServer //开启授权服务器public class OAuth2ServerConfiguration extends AuthorizationServerConfigurerAdapter { @Autowired private DataSource dataSource; @Autowired private AuthenticationManager authenticationManager; /** * 我们配置了使用数据库来维护客户端信息。虽然在各种Demo中我们经常看到的是在内存中维护客户端信息,通过配置直接写死在这里。 * 但是,对于实际的应用我们一般都会用数据库来维护这个信息,甚至还会建立一套工作流来允许客户端自己申请ClientID,实现OAuth客户端接入的审批。 * @param clients * @throws Exception / @Override public void configure(ClientDetailsServiceConfigurer clients) throws Exception { clients.jdbc(dataSource); } /* * 这里干了两件事儿。首先,打开了验证Token的访问权限(以便之后我们演示)。 * 然后,允许ClientSecret明文方式保存,并且可以通过表单提交(而不仅仅是Basic Auth方式提交),之后会演示到这个。 * @param security * @throws Exception / @Override public void configure(AuthorizationServerSecurityConfigurer security) throws Exception { security.checkTokenAccess("permitAll()") .allowFormAuthenticationForClients().passwordEncoder(NoOpPasswordEncoder.getInstance()); } /* * 干了以下4件事儿: * 1. 配置我们的令牌存放方式为JWT方式,而不是内存、数据库或Redis方式。 * JWT是Json Web Token的缩写,也就是使用JSON数据格式包装的令牌,由.号把整个JWT分隔为头、数据体、签名三部分。 * JWT保存Token虽然易于使用但是不是那么安全,一般用于内部,且需要走HTTPS并配置比较短的失效时间。 * 2. 配置JWT Token的非对称加密来进行签名 * 3. 配置一个自定义的Token增强器,把更多信息放入Token中 * 4. 配置使用JDBC数据库方式来保存用户的授权批准记录 * @param endpoints * @throws Exception / @Override public void configure(AuthorizationServerEndpointsConfigurer endpoints) { TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain(); tokenEnhancerChain.setTokenEnhancers( Arrays.asList(tokenEnhancer(), jwtTokenEnhancer())); endpoints.approvalStore(approvalStore()) .authorizationCodeServices(authorizationCodeServices()) .tokenStore(tokenStore()) .tokenEnhancer(tokenEnhancerChain) .authenticationManager(authenticationManager); } /* * 使用JDBC数据库方式来保存授权码 * @return / @Bean public AuthorizationCodeServices authorizationCodeServices() { return new JdbcAuthorizationCodeServices(dataSource); } /* * 使用JWT存储 * @return / @Bean public TokenStore tokenStore() { return new JwtTokenStore(jwtTokenEnhancer()); } /* * 使用JDBC数据库方式来保存用户的授权批准记录 * @return / @Bean public JdbcApprovalStore approvalStore() { return new JdbcApprovalStore(dataSource); } /* * 自定义的Token增强器,把更多信息放入Token中 * @return / @Bean public TokenEnhancer tokenEnhancer() { return new CustomTokenEnhancer(); } /* * 配置JWT使用非对称加密方式来验证 * @return / @Bean protected JwtAccessTokenConverter jwtTokenEnhancer() { KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("jwt.jks"), "mySecretKey".toCharArray()); JwtAccessTokenConverter converter = new JwtAccessTokenConverter(); converter.setKeyPair(keyStoreKeyFactory.getKeyPair("jwt")); return converter; } /* * 配置登录页面的视图信息(其实可以独立一个配置类,这样会更规范) / @Configuration static class MvcConfig implements WebMvcConfigurer { @Override public void addViewControllers(ViewControllerRegistry registry) { registry.addViewController("login").setViewName("login"); } }}
第二步,还记得吗,刚才在第一步的代码中我们还用到了一个自定义的Token增强器,把用户信息嵌入到JWT Token中去(如果使用的是客户端凭据许可类型,这段代码无效,因为和用户没关系)。
这是一个常见需求。因为,默认情况下Token中只会有用户名这样的基本信息,我们往往需要把关于用户的更多信息返回给客户端(在实际应用中,你可能会从数据库或外部服务查询更多的用户信息加入到JWT Token中去)。这个时候,我们就可以自定义增强器来丰富Token的内容:
public class CustomTokenEnhancer implements TokenEnhancer { @Override public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) { Authentication userAuthentication = authentication.getUserAuthentication(); if (userAuthentication != null) { Object principal = authentication.getUserAuthentication().getPrincipal(); //把用户标识嵌入JWT Token中去(Key是userDetails) Map<String, Object> additionalInfo = new HashMap<>(); additionalInfo.put("userDetails", principal); ((DefaultOAuth2AccessToken) accessToken).setAdditionalInformation(additionalInfo); } return accessToken; }}
第三步,实现安全方面的配置。你可以直接看下代码注释,来了解关键代码的作用。
@Configurationpublic class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private DataSource dataSource; @Override @Bean public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } /* * 配置用户账户的认证方式。显然,我们把用户存在了数据库中希望配置JDBC的方式。 * 此外,我们还配置了使用BCryptPasswordEncoder哈希来保存用户的密码(生产环境中,用户密码肯定不能是明文保存的) * @param auth * @throws Exception / @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.jdbcAuthentication() .dataSource(dataSource) .passwordEncoder(new BCryptPasswordEncoder()); } /* * 开放/login和/oauth/authorize两个路径的匿名访问。前者用于登录,后者用于换授权码,这两个端点访问的时机都在登录之前。 * 设置/login使用表单验证进行登录。 * @param http * @throws Exception / @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/login", "/oauth/authorize") .permitAll() .anyRequest().authenticated() .and() .formLogin().loginPage("/login"); }}
第四步,在资源目录下创建一个templates文件夹,然后创建一个login.html登录页:
<body class="uk-height-1-1"><div class="uk-vertical-align uk-text-center uk-height-1-1"> <div class="uk-vertical-align-middle" style="width: 250px;"> <h1>Login Form</h1> <p class="uk-text-danger" th:if="$"> 用户名或密码错误... </p> <form class="uk-panel uk-panel-box uk-form" method="post" th:action="@{/login}"> <div class="uk-form-row"> <input class="uk-width-1-1 uk-form-large" type="text" placeholder="Username" name="username" value="reader"/> </div> <div class="uk-form-row"> <input class="uk-width-1-1 uk-form-large" type="password" placeholder="Password" name="password" value="reader"/> </div> <div class="uk-form-row"> <button class="uk-width-1-1 uk-button uk-button-primary uk-button-large">Login</button> </div> </form> </div></div></body>
至此,授权服务器的编码工作就完成了。
搭建受保护资源服务器
接下来,我们搭建一个用户服务模拟资源提供者(受保护资源服务器)。我们先看看项目初始化工作。
这次创建的POM没有什么特殊,依赖了spring-cloud-starter-oauth2:
<?xml version="1.0" encoding="UTF-8"?><project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent> <artifactId>springsecurity101</artifactId> <groupId>me.josephzhu</groupId> <version>1.0-SNAPSHOT</version> </parent> <modelVersion>4.0.0</modelVersion> <artifactId>springsecurity101-cloud-oauth2-userservice</artifactId> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-oauth2</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies></project>
配置文件非常简单,只是声明了资源服务端口为8081:
server: port: 8081
同时,还要记得把我们之前在项目准备工作时生成的密钥对的公钥命名为public.cert,并放到资源文件下。这样,资源服务器可以本地校验JWT的合法性。内容大概是这样的:
-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwR84LFHwnK5GXErnwkmDmPOJl4CSTtYXCqmCtlbF+5qVOosu0YsM2DsrC9O2gun6wVFKkWYiMoBSjsNMSI3Zw5JYgh+ldHvA+MIex2QXfOZx920M1fPUiuUPgmnTFS+Z3lmK3/T6jJnmciUPY1peh4MXL6YzeI0q4W9xNBBeKT6FDGpduc0FC3OlXHfLbVOThKmAUpAWFDwf9/uUA//l3PLchmV6VwTcUaaHp5W8Af/GU4lPGZbTAqOxzB9ukisPFuO1DikacPhrOQgdxtqkLciRTa884uQnkFwSguOEUYf3ni8GNRJauIuW0rVXhMOs78pKvCKmo53M0tqeC6ul+QIDAQAB-----END PUBLIC KEY-----
好了,让我们正式开始编码吧。
第一步,创建一个可以匿名访问的接口GET /hello,用来测试无需登录就可以访问的服务端资源:
@RestControllerpublic class HelloController { @GetMapping("hello") public String hello() { return "Hello"; }}
第二步,创建三个需要登录+授权才能访问到的接口。我们通过@PreAuthorize在方法执行前进行权限控制:
- GET /user/name接口,读权限或写权限可访问,返回登录用户名;
- GET /user接口,读权限或写权限可访问,返回登录用户信息;
- POST /user接口,只有写权限可以访问,返回访问令牌中的额外信息(也就是自定义的Token增强器CustomTokenEnhancer加入到访问令牌中的额外信息,Key是userDetails),这里也演示了使用TokenStore来解析Token的方式。
@RestController@RequestMapping("user")public class UserController { @Autowired private TokenStore tokenStore; /** * 读权限或写权限可访问,返回登录用户名 * @param authentication * @return / @PreAuthorize("hasAuthority('READ') or hasAuthority('WRITE')") @GetMapping("name") public String name(OAuth2Authentication authentication) { return authentication.getName(); } /* * 读权限或写权限可访问,返回登录用户信息 * @param authentication * @return / @PreAuthorize("hasAuthority('READ') or hasAuthority('WRITE')") @GetMapping public OAuth2Authentication read(OAuth2Authentication authentication) { return authentication; } /* * 只有写权限可以访问,返回访问令牌中的额外信息 * @param authentication * @return / @PreAuthorize("hasAuthority('WRITE')") @PostMapping public Object write(OAuth2Authentication authentication) { OAuth2AuthenticationDetails details = (OAuth2AuthenticationDetails) authentication.getDetails(); OAuth2AccessToken accessToken = tokenStore.readAccessToken(details.getTokenValue()); return accessToken.getAdditionalInformation().getOrDefault("userDetails", null); }}
第三步,创建核心的资源服务器配置类。这里我们需要注意下面两点:
- 我们硬编码了资源服务器的ID为userservice;
- 现在我们使用的是不落数据库的JWT方式+非对称加密,需要通过本地公钥进行验证,因此在这里我们配置了公钥的路径。
@Configuration@EnableResourceServer //启用资源服务器@EnableGlobalMethodSecurity(prePostEnabled = true) //启用方法注解方式来进行权限控制public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter { /* * 声明了资源服务器的ID是userservice,声明了资源服务器的TokenStore是JWT * @param resources * @throws Exception / @Override public void configure(ResourceServerSecurityConfigurer resources) throws Exception { resources.resourceId("userservice").tokenStore(tokenStore()); } /* * 配置TokenStore * @return / @Bean public TokenStore tokenStore() { return new JwtTokenStore(jwtAccessTokenConverter()); } /* * 配置公钥 * @return / @Bean protected JwtAccessTokenConverter jwtAccessTokenConverter() { JwtAccessTokenConverter converter = new JwtAccessTokenConverter(); Resource resource = new ClassPathResource("public.cert"); String publicKey = null; try { publicKey = new String(FileCopyUtils.copyToByteArray(resource.getInputStream())); } catch (IOException e) { e.printStackTrace(); } converter.setVerifierKey(publicKey); return converter; } /* * 配置了除了/user路径之外的请求可以匿名访问 * @param http * @throws Exception / @Override public void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/user/").authenticated() .anyRequest().permitAll(); }}
到这里,我们来想一下,如果授权服务器产生Token的话,受保护资源服务器必须要有一种办法来验证Token,那如果这里的Token不是JWT的方式,我们可以怎么办呢?
我来说下我的方法吧:
- 首先,Token可以保存在数据库或Redis中,资源服务器和授权服务器共享底层的TokenStore来验证;
- 然后,资源服务器可以使用RemoteTokenServices,来从授权服务器的/oauth/check_token端点进行Token校验。
到这里,资源服务器就配置完成了,我们还在资源服务器中分别创建了两个控制器HelloController和UserController,用于分别测试可以匿名访问以及受到权限保护的资源。
初始化数据配置
在实现了授权服务器和受保护资源服务器代码后,我们再来初始化oauth数据库的数据就非常容易理解了。总结起来,我们需要配置用户、权限和客户端三部分。
- 配置两个用户。其中,读用户reader具有读权限,密码为reader;写用户writer具有读写权限,密码为writer。还记得吗,密码我们使用的是BCryptPasswordEncoder加密(准确说是哈希)?
INSERT INTO users
VALUES ('reader', '$2a$04$C6pPJvC1v6.enW6ZZxX.luTdpSI/1gcgTVN7LhvQV6l/AfmzNU/3i', 1);INSERT INTO users
VALUES ('writer', '$2a$04$M9t2oVs3/VIreBMocOujqOaB/oziWL0SnlWdt8hV4YnlhQrORA0fS', 1);
- 配置两个权限,也就是配置reader用户具有读权限,writer用户具有写权限:
INSERT INTO authorities
VALUES ('reader', 'READ');INSERT INTO authorities
VALUES ('writer', 'READ,WRITE');
- 配置三个客户端,其中客户端userservice1使用资源拥有者凭据许可类型,客户端userservice2使用客户端凭据许可类型,客户端userservice3使用授权码许可类型。
INSERT INTO oauth_client_details
VALUES ('userservice1', 'userservice', '1234', 'FOO', 'password,refresh_token', '', 'READ,WRITE', 7200, NULL, NULL, 'true');INSERT INTO oauth_client_details
VALUES ('userservice2', 'userservice', '1234', 'FOO', 'client_credentials,refresh_token', '', 'READ,WRITE', 7200, NULL, NULL, 'true');INSERT INTO oauth_client_details
VALUES ('userservice3', 'userservice', '1234', 'FOO', 'authorization_code,refresh_token', 'https://baidu.com,http://localhost:8082/ui/login,http://localhost:8083/ui/login,http://localhost:8082/ui/remoteCall', 'READ,WRITE', 7200, NULL, NULL, 'false');
值得说明的是:
- 三个客户端账号能使用的资源ID都是userservice,对应我们受保护资源服务器刚才配置的资源ID,也就是userservice,这两者需要一致。
- 三个客户端账号的密码都是1234。
- 三个客户端账号的授权范围都是FOO(并不是关键信息),它们可以拿到的权限是读写。不过,对于和用户相关的授权许可类型(比如资源拥有者凭据许可、授权码许可),最终拿到的权限还取决于客户端权限和用户权限的交集。
- 通过grant_types字段配置支持不同的授权许可类型。这里为了便于测试观察,我们给三个客户端账号各自配置了一种授权许可类型;在实际业务场景中,你完全可以为同一个客户端配置支持OAuth 2.0的四种授权许可类型。
- userservice1和userservice2我们配置了用户自动批准授权(不会弹出一个页面要求用户进行授权)。
演示三种授权许可类型
到这里,授权服务器和受保护资源服务器程序都搭建完成了,数据库也配置了用于测试的用户、权限和客户端。接下来,我们就使用Postman来手工测试一下OAuth 2.0的授权码许可、资源拥有者凭据许可、客户端凭据许可这三种授权许可类型吧。
资源拥有者凭据许可类型
首先,我们测试的是资源拥有者凭据许可,POST请求地址是:
http://localhost:8080/oauth/token?grant_type=password&client_id=userservice1&client_secret=1234&username=writer&password=writer
得到如下图所示结果:
再使用JWT解析工具看下请求Token中的信息:
可以看到,Token中果然包含了Token增强器加入的userDetails自定义信息。如果我们把公钥粘贴到页面的话,可以看到这个JWT校验成功了:
除了本地校验外,还可以访问授权服务器来校验JWT:
http://localhost:8080/oauth/check_token?client_id=userservice1&client_secret=1234&token=...
得到如下结果:
客户端授权许可类型
我们再来测试下客户端授权许可类型。POST请求地址:
http://localhost:8080/oauth/token?grant_type=client_credentials&client_id=userservice2&client_secret=1234
如下图所示,可以直接拿到Token:
这里需要注意的是,并没有提供刷新令牌。这是因为,刷新令牌用于避免访问令牌失效后需要用户再次登录的问题,而客户端授权许可类型没有用户的概念,因此没有刷新令牌,也无法注入额外的userDetails信息。
也可以试一下,如果我们的授权服务器没有开启allowFormAuthenticationForClients参数(允许表单提交认证)的话,客户端的凭证需要通过Basic Auth传过去而不是通过Post:
授权码许可类型
最后,我们来测试下比较复杂的授权码许可。
第一步,打开浏览器访问地址:
http://localhost:8080/oauth/authorize?response_type=code&client_id=userservice3&redirect_uri=https://baidu.com
注意,客户端跳转地址需要和数据库中配置的一致(百度的URL https://baidu.com
我们之前已经在数据库中有配置了)。访问后页面会直接跳转到登录界面,我们使用用户名“reader”、密码“reader”来登录:
由于我们在数据库中设置的是禁用自动批准授权的模式,所以登录后来到了批准界面:
点击同意后可以看到,数据库中也会产生授权通过记录:
第二步,我们可以看到浏览器转到了百度并且提供给了我们授权码:
https://www.baidu.com/?code=XKkHGY
数据库中也记录了授权码:
然后POST访问下面的地址(code参数替换为刚才获得的授权码):
http://localhost:8080/oauth/token?grant_type=authorization_code&client_id=userservice3&client_secret=1234&code=XKkHGY&redirect_uri=https://baidu.com
可以通过授权码换取访问令牌:
虽然userservice3客户端可以有读权限和写权限,但是因为我们登录的用户reader只有读权限,所以最后拿到也只有读权限。
演示权限控制
现在我们来测试一下之前定义的两个账号,也就是读账号和写账号,看看它们的权限控制是否有效。
首先,测试一下我们的安全配置,访问/hello端点不需要认证可以匿名访问:
访问/user需要身份认证:
不管以哪种模式拿到访问令牌,我们用具有读权限的访问令牌访问资源服务器的如下地址
(请求头加入Authorization: Bearer XXXXXXXXXX,其中XXXXXXXXXX代表访问令牌):
http://localhost:8081/user/
可以得到如下结果:
以POST方式访问http://localhost:8081/user/,显然是失败的:
因为这个接口要求有写权限:
@PreAuthorize("hasAuthority('WRITE')")@PostMappingpublic Object write(OAuth2Authentication authentication) {
我们换一个具有读写权限的访问令牌来试试:
可以发现,果然访问成功了。这里输出的内容是Token中的userDetails额外信息,说明资源服务器的权限控制有效。
搭建客户端程序
在上面的演示中,我们使用的是Postman,也就是手动HTTP请求的方式来申请和使用Token。最后,我们来搭建一个OAuth客户端程序自动实现这个过程。
<?xml version="1.0" encoding="UTF-8"?><project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent> <artifactId>springsecurity101</artifactId> <groupId>me.josephzhu</groupId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>springsecurity101-cloud-oauth2-client</artifactId> <modelVersion>4.0.0</modelVersion> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-oauth2</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> </dependencies></project>
配置文件如下:
server: port: 8083 servlet: context-path: /uisecurity: oauth2: client: clientId: userservice3 clientSecret: 1234 accessTokenUri: http://localhost:8080/oauth/token userAuthorizationUri: http://localhost:8080/oauth/authorize scope: FOO resource: jwt: key-value: | -----BEGIN PUBLIC KEY----- *** -----END PUBLIC KEY-----spring: thymeleaf: cache: false#logging:# level:# ROOT: DEBUG
客户端项目端口8082,几个需要说明的地方:
- 本地测试的时候有一个坑,也就是我们需要配置context-path,否则可能会出现客户端和授权服务器服务端Cookie干扰,导致CSRF防御触发的问题。这个问题出现后程序没有任何错误日志输出,只有开启DEBUG模式后才能看到DEBUG日志里有提示,因此这个问题非常难以排查。说实话,我也不知道Spring为什么不把这个信息作为WARN级别的日志输出。
- 作为OAuth客户端,我们需要配置OAuth服务端获取Token的地址、授权(获取授权码)的地址,需要配置客户端的ID、密码和授权范围。
- 因为使用的是JWT Token,我们需要配置公钥(当然,如果不在这里直接配置公钥的话,也可以配置从授权服务器服务端获取公钥)。
接下来,我们可以开始编码了。
第一步,实现MVC的配置:
@Configuration@EnableWebMvcpublic class WebMvcConfig implements WebMvcConfigurer { / * 配置RequestContextListener用于启用session scope的Bean * @return / @Bean public RequestContextListener requestContextListener() { return new RequestContextListener(); } / * 配置index路径的首页Controller * @param registry / @Override public void addViewControllers(ViewControllerRegistry registry) { registry.addViewController("/") .setViewName("forward:/index"); registry.addViewController("/index"); }}
这里做了两件事情:
- 配置RequestContextListener,用于启用session scope的Bean;
- 配置了index路径的首页Controller。
第二步,实现安全方面的配置:
@Configuration@Order(200)public class WebSecurityConfig extends WebSecurityConfigurerAdapter { /* * /路径和/login路径允许访问,其它路径需要身份认证后才能访问 * @param http * @throws Exception / @Override protected void configure(HttpSecurity http) throws Exception { http .authorizeRequests() .antMatchers("/", "/login*") .permitAll() .anyRequest() .authenticated(); }}
这里我们实现的是/路径和/login路径允许访问,其它路径需要身份认证后才能访问。
第三步,我们来创建一个控制器:
@RestControllerpublic class DemoController { @Autowired OAuth2RestTemplate restTemplate; //演示登录后才能访问的安全页面 @GetMapping("/securedPage") public ModelAndView securedPage(OAuth2Authentication authentication) { return new ModelAndView("securedPage").addObject("authentication", authentication); } //演示通过OAuth2RestTemplate调用受保护资源 @GetMapping("/remoteCall") public String remoteCall() { ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://localhost:8081/user/name", String.class); return responseEntity.getBody(); }}
这里我们实现了两个功能:
- securedPage页面,实现的功能是,把用户信息作为模型传入了视图,这样打开页面后就能显示用户名和权限。
- remoteCall接口,实现的功能是,通过引入OAuth2RestTemplate,在登录后就可以使用凭据直接从受保护资源服务器拿资源,不需要繁琐地实现获得访问令牌、在请求头里加入访问令牌的过程。
第四步,配置一下刚才用到的OAuth2RestTemplate Bean,并启用OAuth2Sso功能:
@Configuration@EnableOAuth2Sso //这个注解包含了@EnableOAuth2Clientpublic class OAuthClientConfig { /** * 定义了OAuth2RestTemplate,网上一些比较老的资料给出的是手动读取配置文件来实现,最新版本已经可以自动注入OAuth2ProtectedResourceDetails * @param oAuth2ClientContext * @param details * @return */ @Bean public OAuth2RestTemplate oauth2RestTemplate(OAuth2ClientContext oAuth2ClientContext, OAuth2ProtectedResourceDetails details) { return new OAuth2RestTemplate(details, oAuth2ClientContext); }}
第五步,实现首页:
<body><div class="container"> <div class="col-sm-12"> <h1>Spring Security SSO Client</h1> <a class="btn btn-primary" href="securedPage">Login</a> </div></div></body>
以及登录后才能访问的securedPage页面:
<body><div class="container"> <div class="col-sm-12"> <h1>Secured Page</h1> Welcome, <span th:text="$">Name</span> <br/> Your authorities are <span th:text="$">authorities</span> </div></div></body>
演示单点登录
好,客户端程序搭建好之后,我们先来测试一下单点登录的功能。启动客户端项目,打开浏览器访问:
http://localhost:8082/ui/securedPage
可以看到,页面自动转到了授权服务器(8080端口)的登录页面:
登录后显示了当前用户名和权限:
我们再启动另一个客户端网站,端口改为8083,然后访问同样的地址:
可以看到直接是登录状态,单点登录测试成功。是不是很方便?其实,为了达成单点登录的效果,程序在背后自动实现了多次302重定向,整个流程为:
http://localhost:8083/ui/securedPage ->http://localhost:8083/ui/login ->http://localhost:8080/oauth/authorize?client_id=userservice3&redirect_uri=http://localhost:8083/ui/login&response_type=code&scope=FOO&state=Sobjqe ->http://localhost:8083/ui/login?code=CDdvHa&state=Sobjqe ->http://localhost:8083/ui/securedPage
演示客户端请求资源服务器资源
还记得吗,在上一节“搭建客户端程序”中,我们还定义了一个remoteCall接口,直接使用OAuth2RestTemplate来访问远程资源服务器的资源。现在,我们来测试一下这个接口是否可以实现自动的OAuth流程。访问:
http://localhost:8082/ui/remoteCall
会先转到授权服务器登录,登录后自动跳转回来:
可以看到输出了用户名,对应的资源服务器服务端接口是:
@PreAuthorize("hasAuthority('READ') or hasAuthority('WRITE')")@GetMapping("name")public String name(OAuth2Authentication authentication) { return authentication.getName();}
换一个writer用户登录试试,也能得到正确的输出:
总结
今天这一讲,我们完整演示了如何使用Spring Cloud的OAuth 2.0组件基于三个程序角色(授权服务器、受保护资源服务器和客户端)实现三种OAuth 2.0的授权许可类型(资源拥有者凭据许可、客户端凭据许可和授权码许可)。
我们先演示了三种授权许可类型的手动流程,然后也演示了如何实现权限控制和单点登录,以及如何使用客户端程序来实现自动的OAuth 2.0流程。
我把今天用到的所有代码都放到了GitHub上,你可以点击这个链接查看。
最后,我再提一下,将来Spring对于OAuth 2.0的支持可能会转移到由社区推进的Spring Authorization Server项目上来继续运作。如果你感兴趣的话,可以及时关注这个项目的进展。