JWT学习

转x33g5p2x  于2021-11-17 转载在 其他  
字(21.0k)|赞(0)|评价(0)|浏览(383)

常见的认证机制

HTTP Basic Auth

HTTP Basic Auth简单点说明就是每次请求API时都提供用户的username和password，简言之，Basic Auth是配合RESTful API 使用的最简单的认证方式，只需提供用户名密码即可，但由于有把用户名密码暴露给第三方客户端的风险，在生产环境下被使用的越来越少。因此，在开发对外开放的RESTful API时，尽量避免采用HTTP Basic Auth。

Cookie认证机制就是为一次请求认证在服务端创建一个Session对象，同时在客户端的浏览器端创建了一个Cookie对象；通过客户端带上来Cookie对象来与服务器端的session对象匹配来实现状态管理的。默认的，当我们关闭浏览器的时候，cookie会被删除。但可以通过修改cookie 的expire time使cookie在一定时间内有效。

OAuth

OAuth（开放授权,Open Authorization）是一个开放的授权标准，允许用户让第三方应用访问该用户在某一web服务上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。如网站通过微信、微博登录等，主要用于第三方登录。

OAuth允许用户提供一个令牌，而不是用户名和密码来访问他们存放在特定服务提供者的数据。每一个令牌授权一个特定的第三方系统（例如，视频编辑网站)在特定的时段（例如，接下来的2小时内）内访问特定的资源（例如仅仅是某一相册中的视频）。这样，OAuth让用户可以授权第三方网站访问他们存储在另外服务提供者的某些特定信息，而非所有内容。

下面是OAuth2.0的流程：

这种基于OAuth的认证机制适用于个人消费者类的互联网产品，如社交类APP等应用，但是不太适合拥有自有认证权限管理的企业应用。

缺点：过重。

Token Auth

使用基于 Token 的身份验证方法，在服务端不需要存储用户的登录记录。大概的流程是这样的：

  1. 客户端使用用户名跟密码请求登录
  2. 服务端收到请求，去验证用户名与密码
  3. 验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端
  4. 客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里
  5. 客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
  6. 服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据

比第一种方式更安全，比第二种方式更节约服务器资源，比第三种方式更加轻量。

具体，Token Auth的优点（Token机制相对于Cookie机制又有什么好处呢？）：

  1. 支持跨域访问: Cookie是不允许垮域访问的，这一点对Token机制是不存在的，前提是传输的用户认证信息通过HTTP头传输.
  2. 无状态(也称：服务端可扩展行):Token机制在服务端不需要存储session信息，因为Token 自身包含了所有登录用户的信息，只需要在客户端的cookie或本地介质存储状态信息.
  3. 更适用CDN: 可以通过内容分发网络请求你服务端的所有资料（如：javascript，HTML,图片等），而你的服务端只要提供API即可.
  4. 去耦: 不需要绑定到一个特定的身份验证方案。Token可以在任何地方生成，只要在你的API被调用的时候，你可以进行Token生成调用即可.
  5. 更适用于移动应用: 当你的客户端是一个原生平台（iOS, Android，Windows 10等）时，Cookie是不被支持的（你需要通过Cookie容器进行处理），这时采用Token认证机制就会简单得多。
  6. CSRF:因为不再依赖于Cookie，所以你就不需要考虑对CSRF（跨站请求伪造）的防范。
  7. 性能: 一次网络往返时间（通过数据库查询session信息）总比做一次HMACSHA256计算的Token验证和解析要费时得多.
  8. 不需要为登录页面做特殊处理: 如果你使用Protractor 做功能测试的时候，不再需要为登录页面做特殊处理.
  9. 基于标准化:你的API可以采用标准化的 JSON Web Token (JWT). 这个标准已经存在多个后端库（.NET, Ruby, Java,Python, PHP）和多家公司的支持（如：Firebase,Google, Microsoft）.

JWT简介

JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改。

官网： https://jwt.io/

标准： https://tools.ietf.org/html/rfc7519

JWT令牌的优点：

  1. jwt基于json，非常方便解析。
  2. 可以在令牌中自定义丰富的内容，易扩展。
  3. 通过非对称加密算法及数字签名技术，JWT防止篡改，安全性高。
  4. 资源服务使用JWT可不依赖认证服务即可完成授权。

缺点：

  1. JWT令牌较长，占存储空间比较大。

JWT组成

一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。

头部(Header)

头部用于描述关于该JWT的最基本的信息，例如其类型（即JWT）以及签名所用的算法（如HMAC SHA256或RSA）等。这也可以被表示成一个JSON对象。

  1. {
  2.   "alg": "HS256",
  3.   "typ": "JWT"
  4. }
  • typ：是类型。
  • alg：签名的算法，这里使用的算法是HS256算法

我们对头部的json字符串进行BASE64编码（网上有很多在线编码的网站），编码后的字符串如下：

  1. eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64，所以每6个比特为一个单元，对应某个可打印字符。三个字节有24个比特，对应于4个Base64单元，即3个字节需要用4个可打印字符来表示。JDK 中提供了非常方便的 BASE64Encoder和 BASE64Decoder，用它们可以非常方便的完成基于 BASE64 的编码和解码。

负载(Payload)

第二部分是负载，就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分：

  • 标准中注册的声明（建议但不强制使用）
  1. iss: jwt签发者
  2. sub: jwt所面向的用户
  3. aud: 接收jwt的一方
  4. exp: jwt的过期时间，这个过期时间必须要大于签发时间
  5. nbf: 定义在什么时间之前，该jwt都是不可用的.
  6. iat: jwt的签发时间
  7. jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。
  • 公共的声明

公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.

  • 私有的声明

私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。

这个指的就是自定义的claim。比如下面那个举例中的name都属于自定的claim。这些claim跟JWT标准规定的claim区别在于：JWT规定的claim，JWT的接收方在拿到JWT之后，都知道怎么对这些标准的claim进行验证(还不知道是否能够验证)；而private claims不会验证，除非明确告诉接收方要对这些claim进行验证以及规则才行。

  1. {
  2.   "sub": "1234567890",
  3.   "name": "John Doe",
  4.   "iat": 1516239022
  5. }

其中sub是标准的声明，name是自定义的声明（公共的或私有的）

然后将其进行base64编码，得到Jwt的第二部分：

  1. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkphbWVzIiwiYWRtaW4iOnRydWV9

提示：声明中不要放一些敏感信息。

签证、签名（signature）

jwt的第三部分是一个签证信息，这个签证信息由三部分组成：

  1. header (base64后的)
  2. payload (base64后的)
  3. secret（盐，一定要保密）

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分：

  1. 8HI-Lod0ncfVDnbKIPJJqLH998duF9DSDGkx3gRPNVI

将这三部分用.连接成一个完整的字符串,构成了最终的jwt:

  1. eyJhbGciOiJIUzI1NiIsInR9cCI6IkpXVCJ9.
  2. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
  3. 8HI-Lod0ncfVDnbKIPJJqLH998duF9DSDGkx3gRPNVI

注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。

JJWT简介

JJWT是一个提供端到端的JWT创建和验证的Java库。永远免费和开源(Apache License，版本2.0)，JJW很容易使用和理解。它被设计成一个以建筑为中心的流畅界面，隐藏了它的大部分复杂性。

规范官网：https://jwt.io/

快速入门

token的创建

创建SpringBoot工程，引入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.    <modelVersion>4.0.0</modelVersion>
  4.    <parent>
  5.       <groupId>org.springframework.boot</groupId>
  6.       <artifactId>spring-boot-starter-parent</artifactId>
  7.       <version>2.2.2.RELEASE</version>
  8.       <relativePath/> <!-- lookup parent from repository -->
  9.    </parent>
  10.    <groupId>com.yjxxt</groupId>
  11.    <artifactId>jwtdemo</artifactId>
  12.    <version>0.0.1-SNAPSHOT</version>
  13.    <name>jwtdemo</name>
  14.    <description>Demo project for Spring Boot</description>
  16.    <properties>
  17.       <java.version>1.8</java.version>
  18.    </properties>
  20.    <dependencies>
  21.       <dependency>
  22.          <groupId>org.springframework.boot</groupId>
  23.          <artifactId>spring-boot-starter-web</artifactId>
  24.       </dependency>
  25.       <!--JWT依赖-->
  26.       <dependency>
  27.          <groupId>io.jsonwebtoken</groupId>
  28.          <artifactId>jjwt</artifactId>
  29.          <version>0.9.0</version>
  30.       </dependency>
  32.       <dependency>
  33.          <groupId>org.springframework.boot</groupId>
  34.          <artifactId>spring-boot-starter-test</artifactId>
  35.          <scope>test</scope>
  36.          <exclusions>
  37.             <exclusion>
  38.                <groupId>org.junit.vintage</groupId>
  39.                <artifactId>junit-vintage-engine</artifactId>
  40.             </exclusion>
  41.          </exclusions>
  42.       </dependency>
  43.    </dependencies>
  44. </project>

创建测试类JwtTest，用于生成token：

  1. @SpringBootTest
  2. public class JwtdemoApplicationTests {
  4.    /** * 创建token */
  5.    @Test
  6.    public void testCreatToken() {
  7.       //创建一个JwtBuilder对象
  8.       JwtBuilder jwtBuilder = Jwts.builder()
  9.             //声明的标识{"jti":"888"}
  10.             .setId("888")
  11.             //主体，用户{"sub":"Rose"}
  12.             .setSubject("Rose")
  13.             //创建日期{"ita":"yjxxtxx"}
  14.             .setIssuedAt(new Date())
  15.             //签名手段，参数1：算法，参数2：盐
  16.             .signWith(SignatureAlgorithm.HS256,"yjxxt");
  17.       //获取jwt的token
  18.       String token = jwtBuilder.compact();
  19.       System.out.println(token);
  21.       //三部分的base64解密
  22.       System.out.println("--------------------");
  23.       //按照点分割
  24.       String[] split = token.split("\\.");
  25.       System.out.println(Base64Codec.BASE64.decodeToString(split[0]));
  26.       System.out.println(Base64Codec.BASE64.decodeToString(split[1]));
  27.       //无法解密---因为是非对成性加密，并且如果轻易解密了，那么盐就没啥用了
  28.       System.out.println(Base64Codec.BASE64.decodeToString(split[2]));
  29.    }
  30. }

运行结果如下

再次运行，会发现每次运行的结果是不一样的，因为我们的载荷中包含了时间

token的验证解析

我们刚才已经创建了token ，在web应用中这个操作是由服务端进行然后发给客户端，客户端在下次向服务端发送请求时需要携带这个token（这就好像是拿着一张门票一样），那服务端接到这个token 应该解析出token中的信息（例如用户id）,根据这些信息查询数据库返回相应的结果。

  1. @Test
  2. public void testParseToken(){
  3.    //token
  4.    String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI4ODgiLCJzdWIiOiJSb3NlIiwiaWF0IjoxNTc4ODE0MjUyfQ" +
  5.          ".-FYFMHyfTcGzq900f_Drfdsges0ge2UjaWvPW9gCDto";
  6.    //解析token获取负载中的声明对象
  7.    Claims claims = Jwts.parser()
  8.          .setSigningKey("yjxxt")
  9.          .parseClaimsJws(token)
  10.          .getBody();
  11.    //打印声明的属性
  12.    System.out.println("id:"+claims.getId());
  13.    System.out.println("subject:"+claims.getSubject());
  14.    System.out.println("issuedAt:"+claims.getIssuedAt());
  15. }

试着将token或签名秘钥篡改一下，会发现运行时就会报错，所以解析token也就是验证token

token过期校验

有很多时候，我们并不希望签发的token是永久生效的（上节的token是永久的），所以我们可以为token添加一个过期时间。原因：从服务器发出的token，服务器自己并不做记录，就存在一个弊端就是，服务端无法主动控制某token的立刻失效。

测试用例：

  1. @Test
  2. public void testCreatTokenHasExp() {
  3.    //当前系统时间的长整型
  4.    long now = System.currentTimeMillis();
  5.    //过期时间，这里是1分钟后的时间长整型
  6.    long exp = now + 60 * 1000;
  7.    //创建一个JwtBuilder对象
  8.    JwtBuilder jwtBuilder = Jwts.builder()
  9.          //声明的标识{"jti":"888"}
  10.          .setId("888")
  11.          //主体，用户{"sub":"Rose"}
  12.          .setSubject("Rose")
  13.          //创建日期{"ita":"yjxxtxx"}
  14.          .setIssuedAt(new Date())
  15.          //签名手段，参数1：算法，参数2：盐
  16.          .signWith(SignatureAlgorithm.HS256, "yjxxt")
  17.          //设置过期时间
  18.          .setExpiration(new Date(exp));
  19.    //获取jwt的token
  20.    String token = jwtBuilder.compact();
  21.    System.out.println(token);
  22. }
  1. @Test
  2. public void testParseTokenHasExp() {
  3.    //token
  4.    String token = "eyJhbGciOiJIUzI1NiJ9" +
  5.          ".eyJqdGkiOiI4ODgiLCJzdWIiOiJSb3NlIiwiaWF0IjoxNTc4ODE1MDYyLCJleHAiOjE1Nzg4MTUxMjIsInJvbGVzIjoiYWRtaW4iLCJsb2dvIjoic2hzeHQuanBnIn0.hKog0RsZ9_6II_R8kUCp0HLAouUAYXAJVbz3xtLTUh4";
  6.    //解析token获取负载中的声明对象
  7.    Claims claims = Jwts.parser()
  8.          .setSigningKey("yjxxt")
  9.          .parseClaimsJws(token)
  10.          .getBody();
  11.    //打印声明的属性
  12.    System.out.println("id:" + claims.getId());
  13.    System.out.println("subject:" + claims.getSubject());
  14.    System.out.println("issuedAt:" + claims.getIssuedAt());
  15.    DateFormat sf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  16.    System.out.println("签发时间:"+sf.format(claims.getIssuedAt()));
  17.    System.out.println("过期时间:"+sf.format(claims.getExpiration()));
  18.    System.out.println("当前时间:"+sf.format(new Date()));
  19. }

测试：当未过期时可以正常读取，当过期时会引发io.jsonwebtoken.ExpiredJwtException异常。

自定义claims

我们刚才的例子只是存储了id和subject两个信息，如果你想存储更多的信息（例如角色）可以定义自定义claims

测试用例：

  1. @Test
  2. public void testCreatTokenByClaims() {
  3.    //当前系统时间的长整型
  4.    long now = System.currentTimeMillis();
  5.    //过期时间，这里是1分钟后的时间长整型
  6.    long exp = now + 60 * 1000;
  7.    //创建一个JwtBuilder对象
  8.    JwtBuilder jwtBuilder = Jwts.builder()
  9.          //声明的标识{"jti":"888"}
  10.          .setId("888")
  11.          //主体，用户{"sub":"Rose"}
  12.          .setSubject("Rose")
  13.          //创建日期{"ita":"yjxxtxx"}
  14.          .setIssuedAt(new Date())
  15.          //签名手段，参数1：算法，参数2：盐
  16.          .signWith(SignatureAlgorithm.HS256, "yjxxt")
  17.          //设置过期时间
  18.          .setExpiration(new Date(exp))
  19.          //直接传入map
  20.          // .addClaims(map)
  21.          .claim("roles","admin")
  22.          .claim("logo","yjxxt.jpg");
  23.    //获取jwt的token
  24.    String token = jwtBuilder.compact();
  25.    System.out.println(token);
  26. }
  1. @Test
  2. public void testParseTokenByClaims() {
  3.    //token
  4.    String token = "eyJhbGciOiJIUzI1NiJ9" +
  5.          ".eyJqdGkiOiI4ODgiLCJzdWIiOiJSb3NlIiwiaWF0IjoxNTc4ODE1MDYyLCJleHAiOjE1Nzg4MTUxMjIsInJvbGVzIjoiYWRtaW4iLCJsb2dvIjoic2hzeHQuanBnIn0.hKog0RsZ9_6II_R8kUCp0HLAouUAYXAJVbz3xtLTUh4";
  6.    //解析token获取负载中的声明对象
  7.    Claims claims = Jwts.parser()
  8.          .setSigningKey("yjxxt")
  9.          .parseClaimsJws(token)
  10.          .getBody();
  11.    //打印声明的属性
  12.    System.out.println("id:" + claims.getId());
  13.    System.out.println("subject:" + claims.getSubject());
  14.    System.out.println("issuedAt:" + claims.getIssuedAt());
  15.    DateFormat sf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  16.    System.out.println("签发时间:"+sf.format(claims.getIssuedAt()));
  17.    System.out.println("过期时间:"+sf.format(claims.getExpiration()));
  18.    System.out.println("当前时间:"+sf.format(new Date()));
  20.    System.out.println("roles:"+claims.get("roles"));
  21.    System.out.println("logo:"+claims.get("logo"));
  22. }

Spring Security Oauth2 整合JWT

整合JWT

我们拿之前Spring Security Oauth2的完整代码进行修改

添加配置文件JwtTokenStoreConfig.java

  1. /** * 使用Jwt存储token的配置 * @author zhoubin * @since 1.0.0 */
  2. @Configuration
  3. public class JwtTokenStoreConfig {
  5.    @Bean
  6.    public TokenStore jwtTokenStore(){
  7.       return new JwtTokenStore(jwtAccessTokenConverter());
  8.    }
  10.    @Bean
  11.    public JwtAccessTokenConverter jwtAccessTokenConverter(){
  12.       JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter();
  13.       //配置JWT使用的秘钥
  14.       accessTokenConverter.setSigningKey("test_key");
  15.       return accessTokenConverter;
  16.    }
  17. }

在认证服务器配置中指定令牌的存储策略为JWT

  1. /** * 授权服务器配置 * @author zhoubin * @since 1.0.0 */
  2. @Configuration
  3. @EnableAuthorizationServer
  4. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  6.     @Autowired
  7.     private PasswordEncoder passwordEncoder;
  9.     @Autowired
  10.     private AuthenticationManager authenticationManager;
  12.     @Autowired
  13.     private UserService userService;
  14.     
  15.     @Autowired
  16.     @Qualifier("jwtTokenStore")
  17.     private TokenStore tokenStore;
  19.     @Autowired
  20.     private JwtAccessTokenConverter jwtAccessTokenConverter;
  22.     /** * 使用密码模式需要配置 */
  23.     @Override
  24.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
  25.         endpoints.authenticationManager(authenticationManager)
  26.                 .userDetailsService(userService)
  27.                 //配置存储令牌策略
  28.                 .tokenStore(tokenStore)
  29.                 .accessTokenConverter(jwtAccessTokenConverter);
  30.     }
  32.     @Override
  33.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  34.         clients.inMemory()
  35.                 //配置client_id
  36.                 .withClient("admin")
  37.                 //配置client-secret
  38.                 .secret(passwordEncoder.encode("112233"))
  39.                 //配置访问token的有效期
  40.                 .accessTokenValiditySeconds(3600)
  41.                 //配置刷新token的有效期
  42.                 .refreshTokenValiditySeconds(864000)
  43.                 //配置redirect_uri，用于授权成功后跳转
  44.                 .redirectUris("http://www.baidu.com")
  45.                 //配置申请的权限范围
  46.                 .scopes("all")
  47.                 //配置grant_type，表示授权类型
  48.                 .authorizedGrantTypes("authorization_code","password");
  49.     }
  50. }

用密码模式测试：

发现获取到的令牌已经变成了JWT令牌，将access_token拿到https://jwt.io/ 网站上去解析下可以获得其中内容。

扩展JWT中存储的内容

有时候我们需要扩展JWT中存储的内容，这里我们在JWT中扩展一个key为enhance，value为enhance info的数据。

继承TokenEnhancer实现一个JWT内容增强器

  1. /** * JWT内容增强器 * @author zhoubin * @since 1.0.0 */
  2. public class JwtTokenEnhancer implements TokenEnhancer {
  4.    @Override
  5.    public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
  6.       Map<String,Object> info = new HashMap<>();
  7.       info.put("enhance","enhance info");
  8.       ((DefaultOAuth2AccessToken)accessToken).setAdditionalInformation(info);
  9.       return accessToken;
  10.    }
  11. }

创建一个JwtTokenEnhancer实例

  1. /** * 使用Jwt存储token的配置 * @author zhoubin * @since 1.0.0 */
  2. @Configuration
  3. public class JwtTokenStoreConfig {
  5.    @Bean
  6.    public TokenStore jwtTokenStore(){
  7.       return new JwtTokenStore(jwtAccessTokenConverter());
  8.    }
  10.    @Bean
  11.    public JwtAccessTokenConverter jwtAccessTokenConverter(){
  12.       JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter();
  13.       //配置JWT使用的秘钥
  14.       accessTokenConverter.setSigningKey("test_key");
  15.       return accessTokenConverter;
  16.    }
  18.    @Bean
  19.    public JwtTokenEnhancer jwtTokenEnhancer() {
  20.       return new JwtTokenEnhancer();
  21.    }
  22. }

在认证服务器配置中配置JWT的内容增强器

  1. /** * 授权服务器配置 * @author zhoubin * @since 1.0.0 */
  2. @Configuration
  3. @EnableAuthorizationServer
  4. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  6.     @Autowired
  7.     private PasswordEncoder passwordEncoder;
  9.     @Autowired
  10.     private AuthenticationManager authenticationManager;
  12.     @Autowired
  13.     private UserService userService;
  15.     @Autowired
  16.     @Qualifier("jwtTokenStore")
  17.     private TokenStore tokenStore;
  18.     @Autowired
  19.     private JwtAccessTokenConverter jwtAccessTokenConverter;
  20.     @Autowired
  21.     private JwtTokenEnhancer jwtTokenEnhancer;
  23.     /** * 使用密码模式需要配置 */
  24.     @Override
  25.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
  26.         TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
  27.         List<TokenEnhancer> delegates = new ArrayList<>();
  28.         //配置JWT的内容增强器
  29.         delegates.add(jwtTokenEnhancer);
  30.         delegates.add(jwtAccessTokenConverter);
  31.         enhancerChain.setTokenEnhancers(delegates);
  32.         endpoints.authenticationManager(authenticationManager)
  33.                 .userDetailsService(userService)
  34.                 //配置存储令牌策略
  35.                 .tokenStore(tokenStore)
  36.                 .accessTokenConverter(jwtAccessTokenConverter)
  37.                 .tokenEnhancer(enhancerChain);
  38.     }
  40.     @Override
  41.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  42.         clients.inMemory()
  43.                 //配置client_id
  44.                 .withClient("admin")
  45.                 //配置client-secret
  46.                 .secret(passwordEncoder.encode("112233"))
  47.                 //配置访问token的有效期
  48.                 .accessTokenValiditySeconds(3600)
  49.                 //配置刷新token的有效期
  50.                 .refreshTokenValiditySeconds(864000)
  51.                 //配置redirect_uri，用于授权成功后跳转
  52.                 .redirectUris("http://www.baidu.com")
  53.                 //配置申请的权限范围
  54.                 .scopes("all")
  55.                 //配置grant_type，表示授权类型
  56.                 .authorizedGrantTypes("authorization_code","password");
  57.     }
  58. }

运行项目后使用密码模式来获取令牌，之后对令牌进行解析，发现已经包含扩展的内容。

Java中解析JWT中的内容

添加依赖

  1. <!--jwt 依赖-->
  2. <dependency>
  3.    <groupId>io.jsonwebtoken</groupId>
  4.    <artifactId>jjwt</artifactId>
  5.    <version>0.9.0</version>
  6. </dependency>

修改UserController类，使用jjwt工具类来解析Authorization头中存储的JWT内容

  1. /** * @author zhoubin * @since 1.0.0 */
  2. @RestController
  3. @RequestMapping("/user")
  4. public class UserController {
  6.    @GetMapping("/getCurrentUser")
  7.    public Object getCurrentUser(Authentication authentication, HttpServletRequest request) {
  8.       String header = request.getHeader("Authorization");
  9.       String token = header.substring(header.indexOf("bearer") + 7);
  10.       return Jwts.parser()
  11.             .setSigningKey("test_key".getBytes(StandardCharsets.UTF_8))
  12.             .parseClaimsJws(token)
  13.             .getBody();
  14.    }
  15. }

将令牌放入Authorization头中，访问如下地址获取信息：

http://localhost:8080/user/getCurrentUser

刷新令牌

在Spring Cloud Security 中使用oauth2时，如果令牌失效了，可以使用刷新令牌通过refresh_token的授权模式再次获取access_token。

只需修改认证服务器的配置，添加refresh_token的授权模式即可。

  1. @Override
  2. public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  3.     clients.inMemory()
  4.             //配置client_id
  5.             .withClient("admin")
  6.             //配置client-secret
  7.             .secret(passwordEncoder.encode("112233"))
  8.             //配置访问token的有效期
  9.             .accessTokenValiditySeconds(3600)
  10.             //配置刷新token的有效期
  11.             .refreshTokenValiditySeconds(86400)
  12.             //配置redirect_uri，用于授权成功后跳转
  13.             .redirectUris("http://www.baidu.com")
  14.             //配置申请的权限范围
  15.             .scopes("all")
  16.             //配置grant_type，表示授权类型
  17.             .authorizedGrantTypes("authorization_code","password","refresh_token");
  18. }

使用刷新令牌模式来获取新的令牌，访问如下地址：

http://localhost:8080/oauth/token

Spring Security Oauth2 整合单点登录（SSO）

创建客户端工程,添加依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.    <modelVersion>4.0.0</modelVersion>
  4.    <parent>
  5.       <groupId>org.springframework.boot</groupId>
  6.       <artifactId>spring-boot-starter-parent</artifactId>
  7.       <version>2.2.2.RELEASE</version>
  8.       <relativePath/> <!-- lookup parent from repository -->
  9.    </parent>
  10.    <groupId>com.yjxxt</groupId>
  11.    <artifactId>oauth2client01demo</artifactId>
  12.    <version>0.0.1-SNAPSHOT</version>
  13.    <name>oauth2client01demo</name>
  14.    <description>Demo project for Spring Boot</description>
  16.    <properties>
  17.       <java.version>1.8</java.version>
  18.       <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
  19.    </properties>
  21.    <dependencies>
  22.       <dependency>
  23.          <groupId>org.springframework.cloud</groupId>
  24.          <artifactId>spring-cloud-starter-oauth2</artifactId>
  25.       </dependency>
  26.       <dependency>
  27.          <groupId>org.springframework.cloud</groupId>
  28.          <artifactId>spring-cloud-starter-security</artifactId>
  29.       </dependency>
  30.       <dependency>
  31.          <groupId>org.springframework.boot</groupId>
  32.          <artifactId>spring-boot-starter-web</artifactId>
  33.       </dependency>
  34.       <dependency>
  35.          <groupId>io.jsonwebtoken</groupId>
  36.          <artifactId>jjwt</artifactId>
  37.          <version>0.9.0</version>
  38.       </dependency>
  40.       <dependency>
  41.          <groupId>org.springframework.boot</groupId>
  42.          <artifactId>spring-boot-starter-test</artifactId>
  43.          <scope>test</scope>
  44.       </dependency>
  45.    </dependencies>
  47.    <dependencyManagement>
  48.       <dependencies>
  49.          <dependency>
  50.             <groupId>org.springframework.cloud</groupId>
  51.             <artifactId>spring-cloud-dependencies</artifactId>
  52.             <version>${spring-cloud.version}</version>
  53.             <type>pom</type>
  54.             <scope>import</scope>
  55.          </dependency>
  56.       </dependencies>
  57.    </dependencyManagement>
  59.    <build>
  60.       <plugins>
  61.          <plugin>
  62.             <groupId>org.springframework.boot</groupId>
  63.             <artifactId>spring-boot-maven-plugin</artifactId>
  64.          </plugin>
  65.       </plugins>
  66.    </build>
  67. </project>

修改配置文件

application.properties

  1. server.port=8081
  2. #防止Cookie冲突，冲突会导致登录验证不通过
  3. server.servlet.session.cookie.name=OAUTH2-CLIENT-SESSIONID01
  4. #授权服务器地址
  5. oauth2-server-url: http://localhost:8080
  6. #与授权服务器对应的配置
  7. security.oauth2.client.client-id=admin
  8. security.oauth2.client.client-secret=112233
  9. #OAuth2前往认证服务器获取授权码的url
  10. security.oauth2.client.user-authorization-uri=${oauth2-server-url}/oauth/authorize
  11. #OAuth2前往认证服务器获取access_token的uri
  12. security.oauth2.client.access-token-uri=${oauth2-server-url}/oauth/token
  13. #OAuth2前往认证服务器获取jwt token的uri
  14. security.oauth2.resource.jwt.key-uri=${oauth2-server-url}/oauth/token_key

在启动类上添加@EnableOAuth2Sso注解来启用单点登录功能

  1. @SpringBootApplication
  2. @EnableOAuth2Sso
  3. public class Oauth2client01demoApplication {
  5.    public static void main(String[] args) {
  6.       SpringApplication.run(Oauth2client01demoApplication.class, args);
  7.    }
  9. }

添加接口用于获取当前登录用户信息

  1. @RestController
  2. @RequestMapping("/user")
  3. public class UserController {
  4.     
  5.     @GetMapping("/getCurrentUser")
  6.     public Object getCurrentUser(Authentication authentication) {
  7.         return authentication;
  8.     }
  10. }

修改认证服务器配置

修改授权服务器中的AuthorizationServerConfig类，将绑定的跳转路径为

http://localhost:8081/login，并添加获取秘钥时的身份认证

  1. @Override
  2. public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  3.     clients.inMemory()
  4.             //配置client_id
  5.             .withClient("admin")
  6.             //配置client-secret
  7.             .secret(passwordEncoder.encode("112233"))
  8.             //配置访问token的有效期
  9.             .accessTokenValiditySeconds(3600)
  10.             //配置刷新token的有效期
  11.             .refreshTokenValiditySeconds(864000)
  12.             //配置redirect_uri，用于授权成功后跳转
  13.             // .redirectUris("http://www.baidu.com")
  14.             //单点登录时配置
  15.             .redirectUris("http://localhost:8081/login")
  16.             //配置申请的权限范围
  17.             .scopes("all")
  18.             //自动授权配置
  19.             .autoApprove(true) 
  20.             //配置grant_type，表示授权类型
  21.             .authorizedGrantTypes("authorization_code","password","refresh_token");
  22. }
  24. @Override
  25. public void configure(AuthorizationServerSecurityConfigurer security) {
  26.     // 获取密钥需要身份认证，使用单点登录时必须配置
  27.     security.tokenKeyAccess("isAuthenticated()");
  28. }

测试

启动授权服务和客户端服务；

访问客户端需要授权的接口http://localhost:8081/user/getCurrentUser

会跳转到授权服务的登录界面；

授权后会跳转到原来需要权限的接口地址，展示登录用户信息；

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/m0_53157173/article/details/121363580

内容来源于网络，如有侵权，请联系作者删除！

运维服务器网络

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com