Springcloud之OAuth2

  OAuth2是一个开放的标准，协议。即允许用户让第三方应用访问某一个网站上存储的用户私密资源(照片，头像等)。这个过程中无需将用户名和密码提供给第三方应用。在互联网中，我们最常见的OAuth2的应用就是各种第三方通过QQ授权，微信授权，微博授权等登录了。
  OAuth2协议一共支持4中不同的授权模式。

1. 授权码模式
     常见的第三方平台登录功能基本上都使用这种模式。
2. 简化模式
     简化模式不想要客户端服务器(第三方应用服务器)参与，直接在浏览器中向授权服务器申请令牌。
3. 密码模式
     密码模式是用户把用户名，密码直接告诉客户端，客户端使用这些信息向授权服务器申请令牌。这需要用户对客户端高度信任。
4. 客户端模式
     客户端模式是指客户端使用自己的名义而不是用户的名义向服务器申请授权。

OAuth2的重要参数

①response_type
code：表示要求返回授权码。token：表示直接返回令牌
②client_id
客户端身份标识
③client_secret
客户端密钥
④redirect_uri
重定向地址
⑤scope
表示授权的范围。read：只读权限，all读写权限
⑥grant_type
表示授权的方式。AUTHORIZATION_CODE(授权码)，PASSWORD(密码)，CLIENT_CREDENTIALS(品正式)，REFRESH_TOKEN(更新令牌)
⑦state
应用程序传递的一个随机数，用来防止CSRF攻击。

授权码模式

  它是安全系数最高的，当然也最复杂，比较常用的一种方式。使用网上的图。掘金原作者连接

  用户选择通过微信登录掘金，掘金会向微信发起授权请求，微信询问用户是否同意授权(一个弹窗)。reponse_type为code要求返回授权码。scope参数表示本地授权范围为只读权限，redirect_rui重定向地址。

https://wx.com/oauth/authorize?
  response_type=code&
  client_id=CLIENT_ID&
  redirect_uri=http://juejin.im/callback&
  scope=read
1
2
3
4
5

  用户同意授权后，微信根据redirect_uri重定向并带上授权码。

http://juejin.im/callback?code=AUTHORIZATION_CODE
1

  当掘金拿到授权码(code)时，带授权码和密钥等参数向微信申请令牌。grant_type表示本次授权为授权码方式：AUTHORIZATION_CODE,获取令牌要带上客户端密钥CLIENT_SECRET,和上一步得到的授权码code。

https://wx.com/oauth/token?
 client_id=CLIENT_ID&
 client_secret=CLIENT_SECRET&
 grant_type=authorization_code&
 code=AUTHORIZATION_CODE&
 redirect_uri=http://juejin.im/callback
1
2
3
4
5
6

  最后微信收到请求后向redirect_uri地址发送JSON数据，其中的ACCESS_TOKEN就是令牌。

 {    
  "access_token":"ACCESS_TOKEN",
  "token_type":"bearer",
  "expires_in":2592000,
  "refresh_token":"REFRESH_TOKEN",
  "scope":"read",
  ....
  }
1
2
3
4
5
6
7
8

隐藏式模式

  有一些应用时没有后端的，纯前端应用，就无法用到授权码模式。令牌的申请和存储都需要在前端完成，跳过了授权码这一步。
  前端应用直接获取token，response_type设置为token，要求直接返回令牌，跳过授权码。微信授权通过后重定向到指定的redirect_uri。

https://wx.com/oauth/authorize?
  response_type=token&
  client_id=CLIENT_ID&
  redirect_uri=http://juejin.im/callback&
  scope=read
1
2
3
4
5

密码式模式

  密码式模式，就是用户直接输入自己的用户名，密码。直接去申请令牌，请求响应的json结果中返回token。grant_type为password表示密码式授权。
  这种方式缺点式非常明显的，就是非常危险。如果采取此方式授权，该应用一定是可以高度信任的。

凭证式模式

  凭证式和密码式很相似，主要使用与那些没有前端的命令行应用。可以用最简单的方式获取令牌，在请求响应json结果中返回token。grant_type为client_credentials表示凭证式授权，client_id和client_secret用来识别身份。

https://wx.com/token?
  grant_type=client_credentials&
  client_id=CLIENT_ID&
  client_secret=CLIENT_SECRET
1
2
3
4

令牌过期处理

  token是具有失效性的，一旦过期就需要重新获取，但是重走一边验证流程，不仅麻烦，而且用户体验也不好。
  一般在颁发令牌的时候会一次发两个令牌，一个令牌用来请求API，另一个令牌负责更新refresh_token。grant_type为refresh_token请求为更新令牌，参数refresh_token是用于更新令牌的令牌。

https://wx.com/oauth/token?
  grant_type=refresh_token&
  client_id=CLIENT_ID&
  client_secret=CLIENT_SECRET&
  refresh_token=REFRESH_TOKEN
1
2
3
4
5

自定义授权服务

  项目引入spring-cloud-starter-oauth2。
  增加配置类AuthrizationServer 继承 AuthorizationServerConfigurerAdapter。

@Configuration
public class AccessTokenConfig {
    @Bean
    TokenStore tokenStore() {
        return new InMemoryTokenStore();
    }
}
@EnableAuthorizationServer
@Configuration
public class AuthorizationServer extends AuthorizationServerConfigurerAdapter {
    @Autowired
    TokenStore tokenStore;
    @Autowired
    ClientDetailsService clientDetailsService;

    @Bean
    AuthorizationServerTokenServices tokenServices() {
        DefaultTokenServices services = new DefaultTokenServices();
        services.setClientDetailsService(clientDetailsService);
        services.setSupportRefreshToken(true);
        services.setTokenStore(tokenStore);
        services.setAccessTokenValiditySeconds(60 * 60 * 2);
        services.setRefreshTokenValiditySeconds(60 * 60 * 24 * 3);
        return services;
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.checkTokenAccess("permitAll()")
                .allowFormAuthenticationForClients();
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("javaboy")
                .secret(new BCryptPasswordEncoder().encode("123"))
                .resourceIds("res1")
                .authorizedGrantTypes("authorization_code","refresh_token")
                .scopes("all")
                .redirectUris("http://localhost:8082/index.html");
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authorizationCodeServices(authorizationCodeServices())
                .tokenServices(tokenServices());
    }
    @Bean
    AuthorizationCodeServices authorizationCodeServices() {
        return new InMemoryAuthorizationCodeServices();
    }
}
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

1. TokenStore实例，是指生成的Token要往那里存储。
2. 自定义授权服务配置类要标注@EnableAuthorizationServer注解，开启授权服务的自动化配置。
3. 在自定义配置授权配置类中，重写三个configure方法
   ①AuthorizationServerSecurityConfigurer用来配置令牌端点的安全约束。也就是这个端点谁能访问，谁不能访问。checkTokenAccess是指一个Token校验的端点。这个端点我们设置为可以直接访问。
   ②CientDetailsServiceConfigurer用来配置客户端的详细信息。授权服务主要做两方面的校验，一方面是校验客户端，另一方面是校验用户。这里面配置的就是校验客户端。客户端的信息主要包含客户端id，secret，资源id，授权类型，授权范围以及重定向uri。授权类型就文章最开头介绍的四种。这四种之中不包含refresh_token这种类型。在实际操作中，refresh_token也被算作一种。线上经常用数据库存储客户端信息。
   ③AuthorizatinServerEndPointsConfigurer用来配置令牌的访问端点和令牌的服务。authorizationCodeServices用来配置授权码的存储。TokenServices用来配置令牌的存储，即access_toke的存储位置。授权码是用来获取令牌的，使用一次就失效。令牌是用来获取资源的。
4. tokenServices。这个bean是用来配置Token的一些基本信息。例如Token是否支持刷新，Token的存储位置，Token的有效期以及刷新Token的有效期等等。刷新Token的有效期是指，当Token快要过期的时候，我们需要获取一个新的Token，在获取新的Token的时候，需要有一个凭证信息，这个凭证信息不是旧的Token，是另外一个refresh_token。这个refresh_token也是有有效期的。线上常用的时JWTtokenStore或者redistokenStore。

自定义资源服务器

  晚上资源服务器大多都是和授权服务器放在一起的。如果项目比较小，这样做没问题。如果是一个大的项目，这种做法就不合适了。
  资源服务器哟过来存放我们用户的资源，例如头像，opendi等信息。用户从授权服务器拿到access_token之后，接下来就可以通过access_token来资源服务器请求数据。
  和授权服务一样，引入OAuth2的依赖。自定义一个资源配置类，继承ResourceServerConfigurerAdapter。注解@EnableResourceServer
开启资源服务的自动配置。

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Bean
    RemoteTokenServices tokenServices() {
        RemoteTokenServices services = new RemoteTokenServices();
        services.setCheckTokenEndpointUrl("http://localhost:8080/oauth/check_token");
        services.setClientId("javaboy");
        services.setClientSecret("123");
        return services;
    }
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("res1").tokenServices(tokenServices());
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin")
                .anyRequest().authenticated();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1. tokenServices我们配置一个RemoteTokenServices的实例。这是因为资源服务和授权服务是分开的，资源服务如果和授权服务放到一起，就不需要配置RemoteTokenServices。
2. RemoteTokenServices我们配置了access_token校验地址，client_id,client_secret三个信息。当用户来资源服务器请求资源时，会带着一个access_token，通过这里的配置，就能够校验这个token是否正确。
3. 最后配置一下资源的拦截规则，写法和spring security差不多。
     在资源服务器中我们定义两个测试接口：

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
    @GetMapping("/admin/hello")
    public String admin() {
        return "admin";
    }
}
1
2
3
4
5
6
7
8
9
10
11

自定义第三方应用

  通过spingboot快速构建一个web应用。定义一个回调接口，接受授权返回的code。
  前端代码：

第三方登录
1

  后端代码：

@Controller
public class HelloController {
    @Autowired
    RestTemplate restTemplate;

    @GetMapping("/index.html")
    public String hello(String code, Model model) {
        if (code != null) {
            MultiValueMap map = new LinkedMultiValueMap<>();
            map.add("code", code);
            map.add("client_id", "testOne");
            map.add("client_secret", "123");
            map.add("redirect_uri", "http://localhost:8082/index.html");
            map.add("grant_type", "authorization_code");
            Map resp = restTemplate.postForObject("http://localhost:8080/oauth/token", map, Map.class);
            String access_token = resp.get("access_token");
            System.out.println(access_token);
            HttpHeaders headers = new HttpHeaders();
            headers.add("Authorization", "Bearer " + access_token);
            HttpEntity