1、应用场景
为了理解OAuth的适用场合，让我举一个假设的例子。java
有一个"云冲印"的网站，能够将用户储存在Google的照片，冲印出来。用户为了使用该服务，必须让"云冲印"读取本身储存在Google上的照片。web
问题是只有获得用户的受权，Google才会赞成"云冲印"读取这些照片。那么，"云冲印"怎样得到用户的受权呢？redis
传统方法是，用户将本身的Google用户名和密码，告诉"云冲印"，后者就能够读取用户的照片了。这样的作法有如下几个严重的缺点。spring
- "云冲印"为了后续的服务，会保存用户的密码，这样很不安全。
- Google不得不部署密码登陆，而咱们知道，单纯的密码登陆并不安全。
- "云冲印"拥有了获取用户储存在Google全部资料的权力，用户无法限制"云冲印"得到受权的范围和有效期。
- 用户只有修改密码，才能收回赋予"云冲印"的权力。可是这样作，会使得其余全部得到用户受权的第三方应用程序所有失效。
- 只要有一个第三方应用程序被破解，就会致使用户密码泄漏，以及全部被密码保护的数据泄漏。
OAuth就是为了解决上面这些问题而诞生的。数据库
2、名词定义
在详细讲解OAuth 2.0以前，须要了解几个专用名词。它们对读懂后面的讲解，尤为是几张图，相当重要。express
- Third-party application：第三方应用程序，本文中又称"客户端"（client），即上一节例子中的"云冲印"。
- HTTP service：HTTP服务提供商，本文中简称"服务提供商"，即上一节例子中的Google。
- Resource Owner：资源全部者，本文中又称"用户"（user）。
- User Agent：用户代理，本文中就是指浏览器。
- Authorization server：认证服务器，即服务提供商专门用来处理认证的服务器。
- Resource server：资源服务器，即服务提供商存放用户生成的资源的服务器。它与认证服务器，能够是同一台服务器，也能够是不一样的服务器。
知道了上面这些名词，就不难理解，OAuth的做用就是让"客户端"安全可控地获取"用户"的受权，与"服务商提供商"进行互动。api
3、OAuth的思路
OAuth在"客户端"与"服务提供商"之间，设置了一个受权层（authorization layer）。"客户端"不能直接登陆"服务提供商"，只能登陆受权层，以此将用户与客户端区分开来。"客户端"登陆受权层所用的令牌（token），与用户的密码不一样。用户能够在登陆的时候，指定受权层令牌的权限范围和有效期。浏览器
"客户端"登陆受权层之后，"服务提供商"根据令牌的权限范围和有效期，向"客户端"开放用户储存的资料。缓存
4、客户端的受权模式
客户端必须获得用户的受权（authorization grant），才能得到令牌（access token）。OAuth 2.0定义了四种受权方式。安全
- 受权码模式（authorization code）
- 简化模式（implicit）
- 密码模式（resource owner password credentials）
- 客户端模式（client credentials）
5、受权码模式
受权码模式（authorization code）是功能最完整、流程最严密的受权模式。它的特色就是经过客户端的后台服务器，与"服务提供商"的认证服务器进行互动。
它的步骤以下：
（A）用户访问客户端，后者将前者导向认证服务器。
（B）用户选择是否给予客户端受权。
（C）假设用户给予受权，认证服务器将用户导向客户端事先指定的"重定向URI"（redirection URI），同时附上一个受权码。
（D）客户端收到受权码，附上早先的"重定向URI"，向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的，对用户不可见。
（E）认证服务器核对了受权码和重定向URI，确认无误后，向客户端发送访问令牌（access token）和更新令牌（refresh token）。
6、简化模式
简化模式（implicit grant type）不经过第三方应用程序的服务器，直接在浏览器中向认证服务器申请令牌，跳过了"受权码"这个步骤，所以得名。全部步骤在浏览器中完成，令牌对访问者是可见的，且客户端不须要认证。
它的步骤以下：
（A）客户端将用户导向认证服务器。
（B）用户决定是否给于客户端受权。
（C）假设用户给予受权，认证服务器将用户导向客户端指定的"重定向URI"，并在URI的Hash部分包含了访问令牌。
（D）浏览器向资源服务器发出请求，其中不包括上一步收到的Hash值。
（E）资源服务器返回一个网页，其中包含的代码能够获取Hash值中的令牌。
（F）浏览器执行上一步得到的脚本，提取出令牌。
（G）浏览器将令牌发给客户端。
7、密码模式
密码模式（Resource Owner Password Credentials Grant）中，用户向客户端提供本身的用户名和密码。客户端使用这些信息，向"服务商提供商"索要受权。
在这种模式中，用户必须把本身的密码给客户端，可是客户端不得储存密码。这一般用在用户对客户端高度信任的状况下，好比客户端是操做系统的一部分，或者由一个著名公司出品。而认证服务器只有在其余受权模式没法执行的状况下，才能考虑使用这种模式。
它的步骤以下：
（A）用户向客户端提供用户名和密码。
（B）客户端将用户名和密码发给认证服务器，向后者请求令牌。
（C）认证服务器确认无误后，向客户端提供访问令牌。
8、客户端模式
客户端模式（Client Credentials Grant）指客户端以本身的名义，而不是以用户的名义，向"服务提供商"进行认证。严格地说，客户端模式并不属于OAuth框架所要解决的问题。在这种模式中，用户直接向客户端注册，客户端以本身的名义要求"服务提供商"提供服务，其实不存在受权问题。
它的步骤以下：
（A）客户端向认证服务器进行身份认证，并要求一个访问令牌。
（B）认证服务器确认无误后，向客户端提供访问令牌。
9、更新令牌
若是用户访问的时候，客户端的"访问令牌"已通过期，则须要使用"更新令牌"申请一个新的访问令牌。
客户端发出更新令牌的HTTP请求，包含如下参数：
- granttype：表示使用的受权模式，此处的值固定为"refreshtoken"，必选项。
- refresh_token：表示早前收到的更新令牌，必选项。
- scope：表示申请的受权范围，不能够超出上一次申请的范围，若是省略该参数，则表示与上一次一致。
10、client_credentials代码示范
首先引入主要jar包：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security.oauth</groupId>
<artifactId>spring-security-oauth2</artifactId>
<version>2.3.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
下面配置获取token的配置文件：
package cn.chinotan.config.oauth;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;
/**
* @program: test
* @description: OAuth2服务配置
* @author: xingcheng
* @create: 2018-12-01 16:27
**/
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
@Autowired
@Qualifier("authenticationManagerBean")
private AuthenticationManager authenticationManager ;
@Autowired
private RedisConnectionFactory connectionFactory;
@Bean
public RedisTokenStore tokenStore() {
// redis 存储token，方便集群部署
return new RedisTokenStore(connectionFactory);
}
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
endpoints
.authenticationManager(authenticationManager) // 配置认证管理器
.tokenStore(tokenStore()); // 使用redis进行token存储
}
@Override
public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
security
.tokenKeyAccess("permitAll()")
.checkTokenAccess("isAuthenticated()")
.allowFormAuthenticationForClients(); // 容许表单认证
}
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
clients.inMemory()
.withClient("start_test_two") // 获取token的客户端id
.secret("start_test_two") // 获取token密钥
.scopes("start_test_two") // 资源范围
.authorizedGrantTypes("client_credentials", "password", "refresh_token") // 受权类型
.resourceIds("oauth2-resource") // 资源id
.accessTokenValiditySeconds(120); // token 有效时间
}
}
其中，RedisTokenStore这个是基于Redis的实现，令牌（Access Token）会保存到Redis中，须要配置Redis的链接服务
# Redis数据库索引（默认为0） spring.redis.database: 0 # Redis服务器地址 spring.redis.host: 127.0.0.1 # Redis服务器链接端口 spring.redis.port: 6379 # Redis服务器链接密码（默认为空） spring.redis.password: # 链接池最大链接数（使用负值表示没有限制） spring.redis.pool.max-active: 8 # 链接池最大阻塞等待时间（使用负值表示没有限制） spring.redis.pool.max-wait: -1 # 链接池中的最大空闲链接 spring.redis.pool.max-idle: 8 # 链接池中的最小空闲链接 spring.redis.pool.min-idle: 0 # 链接超时时间（毫秒） spring.redis.timeout: 100
package cn.chinotan.config.redis;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @program: test
* @description: redis
* @author: xingcheng
* @create: 2018-12-01 17:09
**/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private int timeout;
@Autowired
private JedisConnectionFactory jedisConnectionFactory;
/**
* Logger
*/
private static final Logger lg = LoggerFactory.getLogger(RedisConfig.class);
@Bean
@Override
public KeyGenerator keyGenerator() {
// 设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
// 使用：进行分割，能够不少显示出层级关系
// 这里其实就是new了一个KeyGenerator对象
return (target, method, params) -> {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(":");
sb.append(method.getName());
for (Object obj : params) {
sb.append(":" + String.valueOf(obj));
}
String rsToUse = String.valueOf(sb);
return rsToUse;
};
}
//缓存管理器
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
// 初始化缓存管理器，在这里咱们能够缓存的总体过时时间什么的，我这里默认没有配置
RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
.RedisCacheManagerBuilder
.fromConnectionFactory(jedisConnectionFactory);
return builder.build();
}
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory){
//设置序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置redisTemplate
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<Object, Object>();
redisTemplate.setConnectionFactory(jedisConnectionFactory);
RedisSerializer stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer); // key序列化
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value序列化
redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // Hash value序列化
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Override
@Bean
public CacheErrorHandler errorHandler() {
// 异常处理，当Redis发生异常时，打印日志，可是程序正常走
CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
@Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
lg.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
}
@Override
public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
lg.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
}
@Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
lg.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
}
@Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
lg.error("Redis occur handleCacheClearError：", e);
}
};
return cacheErrorHandler;
}
}
以后配置资源服务器：
package cn.chinotan.config.oauth;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import javax.servlet.http.HttpServletResponse;
/**
* @program: test
* @description: Resource服务配置
* @author: xingcheng
* @create: 2018-12-01 16:30
**/
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
}
以及Web安全配置：
package cn.chinotan.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.security.access.expression.method.MethodSecurityExpressionHandler;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.oauth2.provider.expression.OAuth2MethodSecurityExpressionHandler;
import javax.servlet.http.HttpServletResponse;
/**
* @program: test
* @description: WebSecurityConfig
* @author: xingcheng
* @create: 2018-12-01 17:29
**/
@Configuration
@EnableWebSecurity
@Order(Ordered.HIGHEST_PRECEDENCE)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@Override
public void configure(HttpSecurity http) throws Exception {
http.csrf().disable()
.exceptionHandling() // 统一异常处理
.authenticationEntryPoint((request, response, authException) -> response.sendError(HttpServletResponse.SC_UNAUTHORIZED)) // 自定义异常返回
.and()
.authorizeRequests()
.antMatchers("/api/**")
.authenticated() // 拦截全部/api开头下的资源路径，包括其/api自己
.anyRequest()
.permitAll()// 其余请求无需认证
.and()
.httpBasic(); // 启用httpBasic认证
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder()).withUser("start_test_two").password(new BCryptPasswordEncoder().encode("start_test_two")).roles("USER"); // 内存中配置httpBasic认证名和密码，使用BCryptPasswordEncoder加密
}
}
其中注意WebSecurityConfigurerAdapter和ResourceServerConfigurerAdapter都有对于HttpSecurity的配置：
而在ResourceServerConfigurer中，默认全部接口都须要认证：
且一旦匹配上一个filter后就不会走其余的filter了，所以须要将WebSecurityConfigurerAdapter的调用顺序调到最高级：
@Order(Ordered.HIGHEST_PRECEDENCE)
配置完成后启动：
能够看到暴露了/oauth/token接口
Spring-Security-Oauth2的提供的jar包中内置了与token相关的基础端点。本文认证与受权token与/oauth/token有关，其处理的接口类为TokenEndpoint。下面咱们来看一下对于认证与受权token流程的具体处理过程。
1 @FrameworkEndpoint
2 public class TokenEndpoint extends AbstractEndpoint {
3 ...
4 @RequestMapping(value = "/oauth/token", method=RequestMethod.POST)
5 public ResponseEntity<OAuth2AccessToken> postAccessToken(Principal principal, @RequestParam
6 Map<String, String> parameters) throws HttpRequestMethodNotSupportedException {
7 //首先对client信息进行校验
8 if (!(principal instanceof Authentication)) {
9 throw new InsufficientAuthenticationException(
10 "There is no client authentication. Try adding an appropriate authentication filter.");
11 }
12 String clientId = getClientId(principal);
13 //根据请求中的clientId，加载client的具体信息
14 ClientDetails authenticatedClient = getClientDetailsService().loadClientByClientId(clientId);
15 TokenRequest tokenRequest = getOAuth2RequestFactory().createTokenRequest(parameters, authenticatedClient);
16 ...
17
18 //验证scope域范围
19 if (authenticatedClient != null) {
20 oAuth2RequestValidator.validateScope(tokenRequest, authenticatedClient);
21 }
22 //受权方式不能为空
23 if (!StringUtils.hasText(tokenRequest.getGrantType())) {
24 throw new InvalidRequestException("Missing grant type");
25 }
26 //token endpoint不支持Implicit模式
27 if (tokenRequest.getGrantType().equals("implicit")) {
28 throw new InvalidGrantException("Implicit grant type not supported from token endpoint");
29 }
30 ...
31
32 //进入CompositeTokenGranter，匹配受权模式，而后进行password模式的身份验证和token的发放
33 OAuth2AccessToken token = getTokenGranter().grant(tokenRequest.getGrantType(), tokenRequest);
34 if (token == null) {
35 throw new UnsupportedGrantTypeException("Unsupported grant type: " + tokenRequest.getGrantType());
36 }
37 return getResponse(token);
38 }
39 ...
口处理的主要流程就是对authentication信息进行检查是否合法，不合法直接抛出异常，而后对请求的GrantType进行处理，根据GrantType，进行password模式的身份验证和token的发放。下面咱们来看下TokenGranter的类图。
能够看出TokenGranter的实现类CompositeTokenGranter中有一个List<TokenGranter>，对应五种GrantType的实际受权实现。这边涉及到的getTokenGranter()，代码也列下：
1 public class CompositeTokenGranter implements TokenGranter {
2 //GrantType的集合，有五种，以前有讲
3 private final List<TokenGranter> tokenGranters;
4 public CompositeTokenGranter(List<TokenGranter> tokenGranters) {
5 this.tokenGranters = new ArrayList<TokenGranter>(tokenGranters);
6 }
7
8 //遍历list，匹配到相应的grantType就进行处理
9 public OAuth2AccessToken grant(String grantType, TokenRequest tokenRequest) {
10 for (TokenGranter granter : tokenGranters) {
11 OAuth2AccessToken grant = granter.grant(grantType, tokenRequest);
12 if (grant!=null) {
13 return grant;
14 }
15 }
16 return null;
17 }
18 ...
19 }
启动后，访问下面的接口：
package cn.chinotan.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @program: test
* @description: oauth2测试类
* @author: xingcheng
* @create: 2018-12-01 17:43
**/
@RestController
public class WordController {
@RequestMapping("/")
public String index(){
return "index" ;
}
@RequestMapping("/api")
public String api(){
return "api" ;
}
@RequestMapping("/login")
public String login() {
return "login";
}
}
能够看到访问/api接口的时候被拦截了，可是其余接口能够访问
那么如何才能访问/api接口呢，首先得获取到access_token才行
经过暴露出的/oauth/token?grant_type=client_credentials接口就能够获取到access_token，其中expires_in为有效时间，看下咱们的token是存储在哪里：
没错，被存在了redis中，相比存在本地内存和数据库中，redis这样的数据结构有着自然的时间特性，能够方便的来作失效处理
以后即可以经过access_token方便的访问/api接口了
坑
NoSuchMethodError.RedisConnection.set([B[B)V #16错误
版本问题，spring-data-redis 2.0版本中set(String,String)被弃用了。而后我按照网页中的决解方法“spring-date-redis”改成2.3.3.RELEASE版本，下面是源码中的存储token过程：