• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

微服务统⼀认证⽅案 Spring Cloud OAuth2 + JWT

OAuth2 winrains 来源:190coder 3个月前 (08-15) 108次浏览

一、微服务架构下统⼀认证思路

  • 基于Session的认证⽅式:在分布式的环境下,基于session的认证会出现⼀个问题,每个应⽤服务都需要在session中存储⽤ 户身份信息,通过负载均衡将本地的请求分配到另⼀个应⽤服务需要将session信息带过去,否则会重新认证。我们可以使⽤Session共享、Session黏贴等⽅案。Session⽅案也有缺点,⽐如基于cookie,移动端不能有效使⽤等
  • 基于token的认证⽅式 : 基于token的认证⽅式,服务端不⽤存储认证数据,易维护扩展性强, 客户端可以把token 存在任 意地⽅,并且可以实现web和app统⼀认证机制。其缺点也很明显,token由于⾃包含信息,因此⼀般数据量较⼤,⽽且每次请求 都需要传递,因此⽐较占带宽。另外,token的签名验签操作也会给cpu带来额外的处理负担。

二、OAuth2开放授权协议/标准

1. OAuth2介绍

OAuth(开放授权)是⼀个开放协议/标准,允许⽤户授权第三⽅应⽤访问他们存储在另外的服务提供者上的信息,⽽不需要将⽤户名和密码提供给第三⽅应⽤或分享他们数据的所有内容。

OAuth2是OAuth协议的延续版本,但不向后兼容OAuth1即完全废⽌了OAuth1。

允许⽤户授权第三⽅应⽤访问他们存储在另外的服务提供者上的信息,⽽不需要将⽤户名和密码提供给第三⽅应⽤或分享他们数据的所有内容

举例:所有的第三方登陆授权都算OAuth,不想注册在第三方网站,可以用QQ、微信授权登陆,开放部分功能。

2. OAuth2协议⻆⾊和流程

  • 资源所有者(Resource Owner):可以理解为⽤户⾃⼰
  • 客户端(Client):我们想登陆的⽹站或应⽤,⽐如拉勾⽹
  • 认证服务器(Authorization Server):可以理解为微信或者QQ
  • 资源服务器(Resource Server):可以理解为微信或者QQ

3. 什么情况下需要使⽤OAuth2?

  • 第三⽅授权登录的场景 : 微信授权登录、QQ授权登录、微博授权登录等,这是典型的 OAuth2 使⽤场景。
  • 单点登录的场景 :微服务场景,可以专⻔做⼀个认证中⼼(充当认证平台⻆⾊),所有的服务都要到这个认证中⼼做认证,只做⼀次登录,就可以在多个授权范围内的服务中⾃由串⾏。

4. OAuth2的颁发Token授权⽅式

  1. 授权码(authorization-code)
  2. 密码式(password)提供⽤户名+密码换取token令牌
  3. 隐藏式(implicit)
  4. 客户端凭证(client credentials)

授权码模式使⽤到了回调地址,是最复杂的授权⽅式,微博、微信、QQ等第三⽅登录就是这种模式。一般都是使用密码模式(提供⽤户名+密码换取token)。

三、Spring Cloud OAuth2 + JWT 实现

1. Spring Cloud OAuth2介绍

Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现,可以⽤来做多个微服务的统⼀认证(验证身份合法性)授权(验证权限)。通过向OAuth2服务(统⼀认证授权服务)发送某个类型的grant_type进⾏集中认证和授权,从⽽获得access_token(访问令牌),⽽这个token是受其他微服务信任的。

注意:使⽤OAuth2解决问题的本质是,引⼊了⼀个认证授权层,认证授权层连接了资源的拥有者,在授权层⾥⾯,资源的拥有者可以给第三⽅应⽤授权去访问我们的某些受保护资源。

2. Spring Cloud OAuth2构建微服务统⼀认证服务思路

注意:如果比喻成第三方登陆,在我们统⼀认证的场景中,Resource Server其实就是我们的各种受保护的微服务,微服务中的各种API访问接⼝就是资源,发起http请求的浏览器就是Client客户端(对应为第三⽅应⽤),资源服务器就是从三方登陆(比如QQ)那里拿到的头像姓名等信息。

3. (进入开发)搭建认证服务器(Authorization Server)和 资源服务器 (Resource Server)

搭建 认证服务器(Authorization Server),负责颁发token

  • 新建项⽬lagou-cloud-oauth-server-9999
  • 引入依赖 pom.xml
<!--导入Eureka Client依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>


<!--导入spring cloud oauth2依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.security.oauth.boot</groupId>
            <artifactId>spring-security-oauth2-autoconfigure</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.security.oauth.boot</groupId>
    <artifactId>spring-security-oauth2-autoconfigure</artifactId>
    <version>2.1.11.RELEASE</version>
</dependency>
<!--引入security对oauth2的支持-->
<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>
  • application.yml(构建认证服务器,配置⽂件⽆特别之处)
server:
  port: 9999
Spring:
  application:
    name: lagou-cloud-oauth-server
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/oauth2?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
    username: root
    password: 123456
    druid:
      initialSize: 10
      minIdle: 10
      maxActive: 30
      maxWait: 50000
eureka:
  client:
    serviceUrl: # eureka server的路径
      defaultZone: http://lagoucloudeurekaservera:8761/eureka/,http://lagoucloudeurekaserverb:8762/eureka/ #把 eureka 集群中的所有 url 都填写了进来,也可以只写一台,因为各个 eureka server 可以同步注册表
  instance:
    #使用ip注册,否则会使用主机名注册了(此处考虑到对老版本的兼容,新版本经过实验都是ip)
    prefer-ip-address: true
    #自定义实例显示格式,加上版本号,便于多版本管理,注意是ip-address,早期版本是ipAddress
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}:@project.version@

  • ⼊⼝类⽆特殊之处(@SpringBootApplication @EnableDiscoveryClient还是老二位)
  • 认证服务器配置类
package config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
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.AuthorizationServerTokenServices;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.InMemoryTokenStore;

/**
 * @author: 190coder <190coder.cn>
 * @description:  当前类为Oauth2 server的配置类(需要继承特定的⽗类)
 * @create: 2020-07-30 20:03
 */

@Configuration
@EnableAuthorizationServer // 开启认证服务器功能
public class OauthServerConfiger  extends AuthorizationServerConfigurerAdapter {


    @Autowired
    private AuthenticationManager authenticationManager;
    
    /**
     * 认证服务器最终是以api接⼝的⽅式对外提供服务(校验合法性并⽣成令牌、校验令牌等)
     * 那么,以api接⼝⽅式对外的话,就涉及到接⼝的访问权限,我们需要在这⾥进⾏必要的配置
     *
     * @param security
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        super.configure(security);

        // 相当于打开endpoints 访问接⼝的开关,这样的话后期我们能够访问该接⼝
        security.
                // 允许客户端表单认证
                allowFormAuthenticationForClients()
                // 开启端⼝/oauth/token_key的访问权限(允许)
                .tokenKeyAccess("permitAll()")
                // 开启端⼝/oauth/check_token的访问权限(允许)
                .checkTokenAccess("permitAll()");

    }

    /**
     * 客户端详情配置,
     * ⽐如client_id,secret
     * 当前这个服务就如同QQ平台,拉勾⽹作为客户端需要qq平台进⾏登录授权认证等,提前需
       要到QQ平台注册,QQ平台会给拉勾⽹
     * 颁发client_id等必要参数,表明客户端是谁
     *
     * @param clients
     * @throws Exception
     *
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        super.configure(clients);

        clients.
                // 客户端信息存储在什么地⽅,可以在内存中,可以在数据库⾥
                inMemory()
                // 添加⼀个client配置,指定其client_id
                .withClient("client_lagou")
                // 指定客户端的密码/安全码
                .secret("abcxyz")
                // 指定客户端所能访问资源
                .resourceIds("autodeliver")
                // 认证类型/令牌颁发模式,可以配置多个在这⾥,但是不⼀定都⽤,具体使⽤哪种⽅式颁发token,需要客户端调⽤的时候传递参数指定
                .authorizedGrantTypes("password","refresh_token")
                // 客户端的权限范围,此处配置为all全部即可
                .scopes("all");
    }

    /**
     * 认证服务器是玩转token的,那么这⾥配置token令牌管理相关(token此时就是⼀个字符
        串,当下的token需要在服务器端存储,那么存储在哪⾥呢?都是在这⾥配置)
     *
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        super.configure(endpoints);

        endpoints
                // 指定token的存储⽅法
                .tokenStore(tokenStore())
                //token服务的⼀个描述,可以认为是token⽣成细节的描述,⽐如有效时间多少等
                .tokenServices(authorizationServerTokenServices())
                // 指定认证管 理器,随后注⼊⼀个到当前类使⽤即可
                .authenticationManager(authenticationManager)
                .allowedTokenEndpointRequestMethods(HttpMethod.GET,HttpMethod.POST);
    }

    /**
     * 该⽅法⽤户获取⼀个token服务对象(该对象描述了token有效期等信息)
     *
     * @return
     */
    private AuthorizationServerTokenServices authorizationServerTokenServices() {

        // 使⽤默认实现
        DefaultTokenServices defaultTokenServices = new DefaultTokenServices();

        // 是否开启令牌刷新
        defaultTokenServices.setSupportRefreshToken(true);
        // token以什么形式存储
        defaultTokenServices.setTokenStore(tokenStore());
        // access_token就是我们请求资源需要携带的令牌
        defaultTokenServices.setAccessTokenValiditySeconds(30);
        // 设置刷新令牌的有效时间 3天
        defaultTokenServices.setRefreshTokenValiditySeconds(259200);

        return defaultTokenServices;

    }

    /**
     * 该⽅法⽤于创建tokenStore对象(令牌存储对象)token以什么形式存储
    */
    public TokenStore tokenStore(){
        return new InMemoryTokenStore();
    }
}

配置类解读:

  • 关于三个configure⽅法
    • configure(ClientDetailsServiceConfigurer clients) : 客户端详情信息在 这⾥进⾏初始化,你能够把客户端详情信息写死在这⾥或者是通过数据库来存储调取详情信息
    • configure(AuthorizationServerEndpointsConfigurer endpoints) : 配置令牌(token)的访问端点和令牌服务(token services) 和存储介质
    • configure(AuthorizationServerSecurityConfigurer oauthServer) : 配置访问权限和令牌服务(token services)
  • 关于 TokenStore
    • InMemoryTokenStore :存放内存中。 默认采⽤,它可以完美的⼯作在单服务器上(即访问并发量 压⼒不⼤的情况下,并且它在失败的时候不会进⾏备份),⼤多数的项⽬都可以使⽤这个版本的实现来进⾏ 尝试,你可以在开发的时候使⽤它来进⾏管理,因为不会被保存到磁盘中,所以更易于调试。
    • JdbcTokenStore : 这是⼀个基于JDBC的实现版本,令牌会被保存进关系型数据库。使⽤这个版本的实现时, 你可以在不同的服务器之间共享令牌信息,使⽤这个版本的时候请注意把”springjdbc”这个依赖加⼊到你的 classpath当中。
    • JwtTokenStore : 全称是 JSON Web Token(JWT),它可以把令牌相关的数据进⾏编码(因此对于后端服务来说,它不需要进⾏存储,这将是⼀个重⼤优势),缺点就是这个令牌占⽤的空间会⽐较⼤,如果你加⼊了⽐较多⽤户凭证信息,JwtTokenStore 不会保存任何数据。
  • 认证服务器安全配置类
package config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.util.ArrayList;

/**
 * @author: 190coder <190coder.cn>
 * @description: 该配置类,主要处理⽤户名和密码的校验等事宜
 * @create: 2020-07-30 20:52
 */

@Configuration
public class SecurityConfiger extends WebSecurityConfigurerAdapter {

    @Autowired
    private PasswordEncoder passwordEncoder;

    /**
     * 注册⼀个认证管理器对象到容器
     *
     * @throws Exception
     */
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    /**
     * 
     * 处理⽤户名和密码验证事宜
     * 1)客户端传递username和password参数到认证服务器
     * 2)⼀般来说,username和password会存储在数据库中的⽤户表中
     * 3)根据⽤户表中数据,验证当前传递过来的⽤户信息的合法性
     *
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 在这个⽅法中就可以去关联数据库了,当前我们先把⽤户信息配置在内存中
        // 实例化⼀个⽤户对象(相当于数据表中的⼀条⽤户记录)
        UserDetails user = new User("admin","123456",new ArrayList<>());
        auth.inMemoryAuthentication()
                .withUser(user).passwordEncoder(passwordEncoder);
    }

    /**
     * 密码编码对象(密码不进⾏加密处理)
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }
}

  • 测试:启动Eureka Server 注册中心,和认证服务

访问:http://localhost:9998/oauth/token?client_secret=abcxyz&grant_type=password&username=admin&password=123456&client_id=client_lagou


搭建 资源服务器(希望访问被认证的微服务)Resource Server配置

  • 引入outh2对应jar包
  • 资源服务配置类
package com.lagou.edu.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.RemoteTokenServices;

/**
 * @author: 190coder <190coder.cn>
 * @description: 资源服务配置类
 * @create: 2020-07-30 21:20
 */

@Configuration
@EnableResourceServer // 开启资源服务器功能
@EnableWebSecurity // 开启web访问安全
public class ResourceServerConfiger extends ResourceServerConfigurerAdapter {

    private String sign_key = "190coder.cn"; // jwt签名密钥

    /**
     * 该⽅法⽤于定义资源服务器向远程认证服务器发起请求,进⾏token校验等事宜
     * @param resources
     * @throws Exception
     */
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("autodeliver");
        // 定义token服务对象(token校验就应该靠token服务对象)
        RemoteTokenServices remoteTokenServices = new RemoteTokenServices();
        // 校验端点/接⼝设置
        remoteTokenServices.setCheckTokenEndpointUrl("http://localhost:9998/oauth/check_token");
        // 携带客户端id和客户端安全码
        remoteTokenServices.setClientId("client_lagou");
        remoteTokenServices.setClientSecret("abcxyz");
        // 别忘了这⼀步
        resources.tokenServices(remoteTokenServices);

    }

    /**
     * 场景:⼀个服务中可能有很多资源(API接⼝)
     * 某⼀些API接⼝,需要先认证,才能访问
     * 某⼀些API接⼝,压根就不需要认证,本来就是对外开放的接⼝
     * 我们就需要对不同特点的接⼝区分对待(在当前configure⽅法中完成),设置
     是否需要经过认证
     *
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                // 设置session的创建策略(根据需要创建即可)
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED)
                .and()
                .authorizeRequests()
                // autodeliver为前缀的请求需要认证
                .antMatchers("/autodeliver/**").authenticated()
                // demo为前缀的请求需要认证
                .antMatchers("/demo/**").authenticated()
                .anyRequest().permitAll(); // 其他请求不认证
    }
}

思考:当我们第⼀次登陆之后,认证服务器颁发token并将其存储在认证服务器中,后期我们 访问资源服务器时会携带token,资源服务器会请求认证服务器验证token有效性,如果资源 服务器有很多,那么认证服务器压⼒会很⼤…….

另外,资源服务器向认证服务器check_token,获取的也是⽤户信息UserInfo,能否把⽤户信息存储到令牌中,让客户端⼀直持有这个令牌,令牌的验证也在资源服务器进⾏,这样避免和认证服务器频繁的交互……

我们可以考虑使⽤ JWT 进⾏改造,使⽤JWT机制之后资源服务器不需要访问认证服务器……

5. JWT改造统⼀认证授权中⼼的令牌存储机制

5.1 JWT令牌介绍:

通过上边的测试我们发现,当资源服务和授权服务不在⼀起时资源服务使⽤RemoteTokenServices 远程请求授权 服务验证token,如果访问量较⼤将会影响系统的性能。 解决上边问题: 令牌采⽤JWT格式即可解决上边的问题,⽤户认证通过会得到⼀个JWT令牌,JWT令牌中已经包括了⽤户相关的信 息,客户端只需要携带JWT访问资源服务,资源服务根据事先约定的算法⾃⾏完成令牌校验,⽆需每次都请求认证 服务完成授权。

5.2 什么是JWT?

JSON Web Token(JWT)是⼀个开放的⾏业标准(RFC 7519),它定义了⼀种简介的、⾃包含的协议格式,⽤于 在通信双⽅传递json对象,传递的信息经过数字签名可以被验证和信任。JWT可以使⽤HMAC算法或使⽤RSA的公钥/私钥对来签名,防⽌被篡改

5.3 JWT令牌结构

JWT令牌由三部分组成,每部分中间使⽤点(.)分隔,⽐如:xxxxx.yyyyy.zzzzz

  • Header : 头部包括令牌的类型(即JWT)及使⽤的哈希算法(如HMAC SHA256或RSA),例如
{
"alg": "HS256",
"typ": "JWT"
}

将上边的内容使⽤Base64Url编码,得到⼀个字符串就是JWT令牌的第⼀部分。

  • Payload 第⼆部分是负载,内容也是⼀个json对象,它是存放有效信息的地⽅,它可以存放jwt提供的现成字段,⽐ 如:iss(签发者),exp(过期时间戳), sub(⾯向的⽤户)等,也可⾃定义字段。 此部分不建议存放敏感信息,因为此部分可以解码还原原始内容。 最后将第⼆部分负载使⽤Base64Url编码,得到⼀个字符串就是JWT令牌的第⼆部分。 ⼀个例⼦:
{
"sub": "1234567890",
"name": "John Doe",
"iat": 1516239022
}
  • Signature 第三部分是签名,此部分⽤于防⽌jwt内容被篡改。 这个部分使⽤base64url将前两部分进⾏编码,编码后使⽤点(.)连接组成字符串,最后使⽤header中声明 签名算法进⾏签名。
HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

- base64UrlEncode(header):jwt令牌的第⼀部分。
- base64UrlEncode(payload):jwt令牌的第⼆部分。
- secret:签名所使⽤的密钥。

5.4 代码改造 (认证服务器 和 资源服务器)

认证服务器端JWT改造(改造主配置类)

  • 改造存token的介质,改为jwt,再配置转换器,将信息转化jwt token
/**
 * 该⽅法⽤于创建tokenStore对象(令牌存储对象)token以什么形式存储
*/
public TokenStore tokenStore(){
    //return new InMemoryTokenStore();
    // 使⽤jwt令牌
    return new JwtTokenStore(jwtAccessTokenConverter());
}

private String sign_key = "xxxxx"; // jwt签名密钥

/**
 * 返回jwt令牌转换器(帮助我们⽣成jwt令牌的)
 * 在这⾥,我们可以把签名密钥传递进去给转换器对象
 * @return
 */
private JwtAccessTokenConverter jwtAccessTokenConverter() {

    JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
    // 签名密钥
    jwtAccessTokenConverter.setSigningKey(sign_key);
    // 验证时使⽤的密钥,和签名密钥保持⼀致
    jwtAccessTokenConverter.setVerifier(new MacSigner(sign_key));

    return jwtAccessTokenConverter;
}
  • 修改 JWT 令牌服务⽅法,主要是添加jwt 转换器

资源服务器校验JWT令牌

  • 不需要和远程认证服务器交互,添加本地tokenStore,修改configure 方法
    /**
     * 该⽅法⽤于定义资源服务器向远程认证服务器发起请求,进⾏token校验等事宜
     * @param resources
     * @throws Exception
     */
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
//        resources.resourceId("autodeliver");
//        // 定义token服务对象(token校验就应该靠token服务对象)
//        RemoteTokenServices remoteTokenServices = new RemoteTokenServices();
//        // 校验端点/接⼝设置
//        remoteTokenServices.setCheckTokenEndpointUrl("http://localhost:9998/oauth/check_token");
//        // 携带客户端id和客户端安全码
//        remoteTokenServices.setClientId("client_lagou");
//        remoteTokenServices.setClientSecret("abcxyz");
//        // 别忘了这⼀步
//        resources.tokenServices(remoteTokenServices);

        // JWT 令牌改造
        resources.resourceId("autodeliver").tokenStore(tokenStore()).stateless(true);

    }
  • 添加 和认证服务器一样的jwt token 存储
 /**
 * 该⽅法⽤于创建tokenStore对象(令牌存储对象)token以什么形式存储
 */
public TokenStore tokenStore(){
    //return new InMemoryTokenStore();
    // 使⽤jwt令牌
    return new JwtTokenStore(jwtAccessTokenConverter());
}

private String sign_key = "190coder.cn"; // jwt签名密钥

/**
 * 返回jwt令牌转换器(帮助我们⽣成jwt令牌的)
 * 在这⾥,我们可以把签名密钥传递进去给转换器对象
 * @return
 */
private JwtAccessTokenConverter jwtAccessTokenConverter() {

    JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
    // 签名密钥
    jwtAccessTokenConverter.setSigningKey(sign_key);
    // 验证时使⽤的密钥,和签名密钥保持⼀致
    jwtAccessTokenConverter.setVerifier(new MacSigner(sign_key));

    return jwtAccessTokenConverter;
}

6. 从数据库加载Oauth2客户端信息

  • 创建数据表并初始化。 数据根据源码可得出 (表名及字段保持固定)
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
配置数据源
-- Table structure for oauth_client_details
-- ----------------------------
DROP TABLE IF EXISTS `oauth_client_details`;
CREATE TABLE `oauth_client_details` (
`client_id` varchar(48) NOT NULL,
`resource_ids` varchar(256) DEFAULT NULL,
`client_secret` varchar(256) DEFAULT NULL,
`scope` varchar(256) DEFAULT NULL,
`authorized_grant_types` varchar(256) DEFAULT NULL,
`web_server_redirect_uri` varchar(256) DEFAULT NULL,
`authorities` varchar(256) DEFAULT NULL,
`access_token_validity` int(11) DEFAULT NULL,
`refresh_token_validity` int(11) DEFAULT NULL,
`additional_information` varchar(4096) DEFAULT NULL,
`autoapprove` varchar(256) DEFAULT NULL,
PRIMARY KEY (`client_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of oauth_client_details
-- ----------------------------
BEGIN;
INSERT INTO `oauth_client_details` VALUES ('client_lagou123',
'autodeliver,resume', 'abcxyz', 'all', 'password,refresh_token', NULL, NULL,
7200, 259200, NULL, NULL);
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;
  • 配置数据源
Spring:
  application:
    name: test-oauth2-9998
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/lagou_homework?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
    username: root
    password: 123321
    druid:
      initialSize: 10
      minIdle: 10
      maxActive: 30
      maxWait: 50000
  • 认证服务器主配置类改造
/**
     * 客户端详情配置,
     * ⽐如client_id,secret
     * 当前这个服务就如同QQ平台,拉勾⽹作为客户端需要qq平台进⾏登录授权认证等,提前需
       要到QQ平台注册,QQ平台会给拉勾⽹
     * 颁发client_id等必要参数,表明客户端是谁
     *
     * @param clients
     * @throws Exception
     *
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        super.configure(clients);

//        clients.
//                // 客户端信息存储在什么地⽅,可以在内存中,可以在数据库⾥
//                inMemory()
//                // 添加⼀个client配置,指定其client_id
//                .withClient("client_lagou")
//                // 指定客户端的密码/安全码
//                .secret("abcxyz")
//                // 指定客户端所能访问资源
//                .resourceIds("autodeliver")
//                // 认证类型/令牌颁发模式,可以配置多个在这⾥,但是不⼀定都⽤,具体使⽤哪种⽅式颁发token,需要客户端调⽤的时候传递参数指定
//                .authorizedGrantTypes("password","refresh_token")
//                // 客户端的权限范围,此处配置为all全部即可
//                .scopes("all");

        // 从内存中加载客户端详情改为从数据库中加载客户端详情
        clients.withClientDetails(createJdbcClientDetailsService());
    }

    @Autowired
    private DataSource dataSource;
    @Bean
    public JdbcClientDetailsService createJdbcClientDetailsService() {
        JdbcClientDetailsService jdbcClientDetailsService = new
                JdbcClientDetailsService(dataSource);
        return jdbcClientDetailsService;
    }

7. 从数据库验证⽤户合法性

  • 创建数据表users(表名不需固定),初始化数据
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for users
-- ----------------------------
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` char(10) DEFAULT NULL,
`password` char(100) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of users
-- ----------------------------
BEGIN;
INSERT INTO `users` VALUES (4, 'lagou-user', 'iuxyzds');
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;
  • 开发UserDetailsService接⼝的实现类,根据⽤户名从数据库加载⽤户信息
/**
 * @author: 190coder <190coder.cn>
 * @description:  UserDetailsService接⼝的实现类
 * @create: 2020-07-30 23:19
 */
@Service
public class JdbcUserDetailsService implements UserDetailsService {

    // Jpa 查询
    @Autowired
    private UsersRepository usersRepository;

    /**
     * 根据username查询出该⽤户的所有信息,封装成UserDetails类型的对象返回,⾄于密码,框
     * 架会⾃动匹配
     *
     * @param s
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        Users users = usersRepository.findByUsername(s);
        return new User(users.getUsername(),users.getPassword(),new
                ArrayList<>());
    }
}
  • 使⽤⾃定义的⽤户详情服务对象 (验证配置类)
@Autowired
    private JdbcUserDetailsService jdbcUserDetailsService;
    /**
     *
     * 处理⽤户名和密码验证事宜
     * 1)客户端传递username和password参数到认证服务器
     * 2)⼀般来说,username和password会存储在数据库中的⽤户表中
     * 3)根据⽤户表中数据,验证当前传递过来的⽤户信息的合法性
     *
     */
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 在这个⽅法中就可以去关联数据库了,当前我们先把⽤户信息配置在内存中
        // 实例化⼀个⽤户对象(相当于数据表中的⼀条⽤户记录)
//        UserDetails user = new User("admin","123456",new ArrayList<>());
//        auth.inMemoryAuthentication()
//                .withUser(user).passwordEncoder(passwordEncoder);

        auth.userDetailsService(jdbcUserDetailsService).passwordEncoder(passwordEncoder);
    }

8. 基于Oauth2的 JWT 令牌信息扩展

OAuth2帮我们⽣成的JWT令牌载荷部分信息有限,关于⽤户信息只有⼀个user_name,有些场景下我们希望放⼊⼀些扩展信息项,比如IP (提高安全性) ,UserId…,如下添加扩展信息:

认证服务器⽣成JWT令牌时存⼊扩展信息(⽐如clientIp)

  • 继承DefaultAccessTokenConverter类,重写convertAccessToken⽅法存⼊扩展信息
/**
 * @author: 190coder <190coder.cn>
 * @description: 自定义扩展信息
 * @create: 2020-07-30 23:41
 */
public class LagouAccessTokenConvertor extends DefaultAccessTokenConverter {

    @Override
    public Map<String, ?> convertAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {

        // 获取到request对象
        HttpServletRequest request = ((ServletRequestAttributes)
                (RequestContextHolder.getRequestAttributes())).getRequest();
        // 获取客户端ip(注意:如果是经过代理之后到达当前服务的话,那么这种⽅式获取的并不是真实的浏览器客户端ip)
        String remoteAddr = request.getRemoteAddr();
        Map<String, String> stringMap = (Map<String, String>)
                super.convertAccessToken(token, authentication);
        stringMap.put("clientIp",remoteAddr);
        return stringMap;
    }
}
  • 将⾃定义的转换器对象注⼊到配置jwt返回的类中
/**
    * 返回jwt令牌转换器(帮助我们生成jwt令牌的)
    * 在这里,我们可以把签名密钥传递进去给转换器对象
    * @return
    */
   public JwtAccessTokenConverter jwtAccessTokenConverter() {
       JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
       jwtAccessTokenConverter.setSigningKey(sign_key);  // 签名密钥
       jwtAccessTokenConverter.setVerifier(new MacSigner(sign_key));  // 验证时使用的密钥,和签名密钥保持一致
       jwtAccessTokenConverter.setAccessTokenConverter(lagouAccessTokenConvertor);
       return jwtAccessTokenConverter;
   }

9. 资源服务器取出 JWT 令牌扩展信息

  • 资源服务器也需要⾃定义⼀个转换器类,继承DefaultAccessTokenConverter,重写 extractAuthentication提取⽅法,把载荷信息设置到认证对象的details属性中
  • 将⾃定义的转换器对象注⼊ (返回jwt令牌转换器)的方法
  • 业务类⽐如Controller类中,可以通过SecurityContextHolder.getContext().getAuthentication()获取到认证对象,进⼀步获取到扩展信息
Object details = SecurityContextHolder.getContext().getAuthentication().getDetails();
  • 获取到扩展信息后,就可以做其他的处理了,⽐如根据userId进⼀步处理,或者根据clientIp处理,或者其他都是可以的了

10. 注意事项

  • JWT令牌就是⼀种可以被验证的数据组织格式,它的玩法很灵活,我们这⾥是基于Spring Cloud Oauth2 创建、校验JWT令牌
  • 我们也可以⾃⼰写⼯具类⽣成、校验JWT令牌
  • JWT令牌中不要存放过于敏感的信息,因为我们知道拿到令牌后,我们可以解码看到载荷部分的信息
  • JWT令牌每次请求都会携带,内容过多,会增加⽹络带宽占⽤

lagouedu 应颠大佬 笔记整理

作者:190coder

来源:https://juejin.im/post/6855302923996856334


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (0)