• 全栈之路-小程序API-JWT令牌详细剖析与使用


      JSON Web Token(JWT)是目前最流行的跨域身份验证解决方案。通过客户端保存数据,而服务器根本不保存会话数据,每个请求都被发送回服务器。 JWT是这种解决方案的代表。

    一、跨域身份验证

    1、Internet服务无法与用户身份验证分开。一般过程如下:

    (1)用户向服务器发送用户名和密码。

    (2)验证服务器后,相关数据(如用户角色,登录时间等)将保存在当前会话中。

    (3)服务器向用户返回session_id,session信息都会写入到用户的Cookie。

    (4)用户的每个后续请求都将通过在Cookie中取出session_id传给服务器。

    (5)服务器收到session_id并对比之前保存的数据,确认用户的身份。

    2、此模式存在的问题

    这种模式最大的问题是,没有分布式架构,无法支持横向扩展。如果使用一个服务器,该模式完全没有问题。

    但是,如果它是服务器群集或面向服务的跨域体系结构的话,则需要一个统一的session数据库库来保存会话数据实现共享,这样负载均衡下的每个服务器才可以正确的验证用户身份。

    在分布式的情况下,jwt令牌的这种解决方案是比较优雅的,只是通过客户端保存数据,而服务器根本不保存会话数据,每个请求都被发送回服务器,jwt验证模式流程图如下:

     注意:图片来源网络

     二、jwt详解

    (注意:jwt详解的内容来自 https://baijiahao.baidu.com/s?id=1608021814182894637&wfr=spider&for=pc 什么鬼,我怎么会引用百家号的内容!!!)

    1、jwt的原则

    JWT的原则是在服务器身份验证之后,将生成一个JSON对象并将其发送回用户,之后,当用户与服务器通信时,客户在请求中发回JSON对象。服务器仅依赖于这个JSON对象来标识用户。为了防止用户篡改数据,服务器将在生成对象时添加签名(有关详细信息,请参阅下文)。服务器不保存任何会话数据,即服务器变为无状态,使其更容易扩展

    2、jwt的数据结构

    一个jwt的由三部分构成,此对象为一个很长的字符串,字符之间通过"."分隔符分为三个子串。注意JWT对象为一个长字串,各字串之间也没有换行符,此处为了演示需要,我们特意分行并用不同颜色表示了。每一个子串表示了一个功能块,总共有以下三个部分:

    jwt的三个部分如下。jwt头、有效载荷和签名,将它们写成一行,如下:

     注意:图片来源于网络

    (1)jwt头

    JWT头部分是一个描述JWT元数据的JSON对象,通常如下所示:

    {"alg": "HS256","typ": "JWT"}

    在上面的代码中,alg属性表示签名使用的算法,默认为HMAC SHA256(写为HS256);typ属性表示令牌的类型,JWT令牌统一写为JWT。

    最后,使用Base64 URL算法将上述JSON对象转换为字符串保存。

    (2)有效载荷

    有效载荷部分,是JWT的主体内容部分,也是一个JSON对象,包含需要传递的数据。 JWT指定七个默认字段供选择。

      iss:发行人

      exp:到期时间

      sub:主题

      aud:用户

      nbf:在此之前不可用

      iat:发布时间

      jti:JWT ID用于标识该JWT

    除以上默认字段外,我们还可以自定义私有字段,如下例:

    {"sub": "1234567890","name": "chongchong","admin": true}

    请注意,默认情况下JWT是未加密的,任何人都可以解读其内容,因此不要构建隐私信息字段,存放保密信息,以防止信息泄露。

    JSON对象也使用Base64 URL算法转换为字符串保存。

    (3)签名哈希

    签名哈希部分是对上面两部分数据签名,通过指定的算法生成哈希,以确保数据不会被篡改。

      首先,需要指定一个密码(secret)。该密码仅仅为保存在服务器中,并且不能向用户公开。然后,使用标头中指定的签名算法(默认情况下为HMAC SHA256)根据以下公式生成签名。

    HMACSHA256( base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

    在计算出签名哈希后,JWT头,有效载荷和签名哈希的三个部分组合成一个字符串,每个部分用"."分隔,就构成整个JWT对象。

    (4)Base64URL算法

    如前所述,JWT头和有效载荷序列化的算法都用到了Base64URL。该算法和常见Base64算法类似,稍有差别。

    作为令牌的JWT可以放在URL中(例如api.example/?token=xxx)。 Base64中用的三个字符是"+","/"和"=",由于在URL中有特殊含义,因此Base64URL中对他们做了替换:"="去掉,"+"用"-"替换,"/"用"_"替换,这就是Base64URL算法,很简单把。

    三、jwt在小程序API中使用

    1、整体流程梳理

    (1)我们用code码(用户的account账户)通过调用微信开放的接口,获取到一个唯一的openid

    (2)分为两种情况:(首先是通过openid查询user表)

      用户第一次使用(相当于注册):我们将openid写入到user表中

      用户第二次或者多次使用之后(相当于登录):得到userId

    (3)userId写入到jwt令牌中

    (4)将jwt令牌返回给小程序

    2、令牌的生成

    注意:生成jwt的时候,可供选择的库有多个,例如:jjwt,auth0 (详情见:https://jwt.io/

    (1)安装auth0的依赖(版本随意,bug自处理)

    1 <dependency>
    2    <groupId>com.auth0</groupId>
    3    <artifactId>java-jwt</artifactId>
    4    <version>3.8.3</version>
    5 </dependency>

    (2)生成令牌(这里只看一下生成jwt令牌的方法)

     1 @Component
     2 public class JwtToken {
     3 
     4     private static String jwtKey;
     5 
     6     private static Integer expiredTimeIn;
     7 
     8     private static Integer defaultScope = 8;
     9 
    10     @Value("${missyou.security.jwt-key}")
    11     public void setJwtKey(String jwtKey) {
    12         JwtToken.jwtKey = jwtKey;
    13     }
    14 
    15     @Value("${missyou.security.token-expired-in}")
    16     public void setExpiredTimeIn(Integer expiredTimeIn) {
    17         JwtToken.expiredTimeIn = expiredTimeIn;
    18     }
    19 
    20     /**
    21      * 生成token 主方法(适用于有分级权限的)
    22      *
    23      * @param uid   用户id
    24      * @param scope 权限分级的数字
    25      * @return
    26      */
    27     public static String makenToken(Long uid, Integer scope) {
    28         return JwtToken.getToken(uid, scope);
    29     }
    30 
    31     /**
    32      * 生成token方法 (适用于没有分级权限的)
    33      *
    34      * @param uid 用户id
    35      * @return
    36      */
    37     public static String makeToken(Long uid) {
    38         return JwtToken.getToken(uid, JwtToken.defaultScope);
    39     }
    40 
    41     /**
    42      * 真正生成token的方法
    43      *
    44      * @param uid
    45      * @param scope
    46      * @return
    47      */
    48     private static String getToken(Long uid, Integer scope) {
    49 
    50         // 需要传入一个secret 随机字符串 这个写到配置文件中,从配置文件中读取,方便更改
    51         Algorithm algorithm = Algorithm.HMAC256(JwtToken.jwtKey);
    52 
    53         // 计算过期时间以及令牌签发的当前时间
    54         Map<String, Date> map = JwtToken.calculateExpiredIssues();
    55 
    56         // 过期时间是传入Date类型,需要我们自己来转换成一个过期时间
    57         // 例如 12:00 10s后过期,我们需要得到 12:00:10 这个过期时间
    58         String token = JWT.create()
    59                 .withClaim("uid", uid)
    60                 .withClaim("scope", scope)
    61                 .withExpiresAt(map.get("expiredTime"))
    62                 .withIssuedAt(map.get("now")) //令牌的签发时间
    63                 .sign(algorithm);
    64         return token;
    65     }
    66 
    67     /**
    68      * 计算过期时间以及当前的时间
    69      *
    70      * @return
    71      */
    72     private static Map<String, Date> calculateExpiredIssues() {
    73         Map<String, Date> map = new HashMap<>();
    74         Calendar calendar = Calendar.getInstance();
    75         Date now = calendar.getTime();
    76         calendar.add(Calendar.SECOND, JwtToken.expiredTimeIn);
    77         map.put("now", now);
    78         map.put("expiredTime", calendar.getTime());
    79         return map;
    80     }
    81 }

    注意:方法基本上就是这样子,jwt令牌的create()方法可以加入多个参数的,你自己自定义的!还有那个setter方法注入的是可以值得思考学习一下的!

    (3)后续

    至于如何和微信小程序进行交互,接口如何设计,就不贴出来了,自己思考一下吧!

     3、令牌的校验与全局处理

    思考:令牌如果在每一个请求中进行校验的话,在每个controller中的方法进行校验的话,会导致大量重复的代码,我们需要做的是做一个全局处理,进行令牌的验证

    (1)令牌的校验

    主要就是在token工具类中继续追加验证token的方法,其实是验证并且获取令牌中的数据,这里用的是Optional来进行处理的,具体方法如下:

     1     /**
     2      * 验证令牌token并获取令牌中的数据(Optional的使用)
     3      *
     4      * @param token 加密令牌token
     5      * @return
     6      */
     7     public Optional<Map<String, Claim>> verifyAndGetClaims(String token) {
     8         DecodedJWT decodedJWT;
     9         Algorithm algorithm = Algorithm.HMAC256(JwtToken.jwtKey);
    10         JWTVerifier jwtVerifier = JWT.require(algorithm).build();
    11 
    12         try{
    13             decodedJWT = jwtVerifier.verify(token);
    14         }catch (JWTVerificationException e){
    15             return Optional.empty();
    16         }
    17         return Optional.of(decodedJWT.getClaims());
    18     }

     (2)全局处理

      在springboot中,有三种方式实现拦截HTTP请求的方式,分别是filter,interceptor以及AOP

    三者主要的区别:

      ## filter是基于servlet(servlet其实是一种为web开发制定的规范,是一种标准接口,Tomcat是一种servlet的容器)

      ## interceptor和AOP是基于spring框架的(interceptor相对来说实现起来简单一些)

     注意:

    当一个http请求向服务器发送的时候,如果项目中同时配置了这三种拦截机制,那么他是有一个顺序的,就是

    filter --> interceptor --> aop (请求经过的顺序)

    --> controller --> (controller处理层)

    aop --> interceptor --> filter (处理结果返回顺序)

     当然,在这里我们使用的是interceptor,开始搞起!

    interceptor相关代码:

     1 public class PermissionInterceptor extends HandlerInterceptorAdapter {
     2 
     3     @Override
     4     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     5         Optional<ScopeLevel> scopeLevel = this.getScopeLevel(handler);
     6         // 没有加上@ScopeLevel注解,说明没有访问权限的设定
     7         if (!scopeLevel.isPresent()) {
     8             return true;
     9         }
    10         String bearerToken = request.getHeader("Authorization");
    11         // token为空
    12         if (StringUtils.isEmpty(bearerToken)) {
    13             throw new UnAuthenticatedException(10004);
    14         }
    15         // token是默认的Bearer <token>格式,以Bearer开头,需要进行判断一下
    16         if (bearerToken.startsWith("Bearer")) {
    17             throw new UnAuthenticatedException(10004);
    18         }
    19         String[] tokens = bearerToken.split(" ");
    20         if(tokens.length != 2){
    21             throw new UnAuthenticatedException(10004);
    22         }
    23         String token = tokens[1];
    24         Optional<Map<String, Claim>> stringClaimMap = JwtToken.verifyAndGetClaims(token);
    25         Map<String, Claim> map = stringClaimMap.orElseThrow(
    26                 () -> new UnAuthenticatedException(40001));
    27         return this.hasPermission(scopeLevel.get(), map);
    28     }
    29 
    30     @Override
    31     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    32         super.postHandle(request, response, handler, modelAndView);
    33     }
    34 
    35     @Override
    36     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    37         super.afterCompletion(request, response, handler, ex);
    38     }
    39 
    40     @Override
    41     public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    42         super.afterConcurrentHandlingStarted(request, response, handler);
    43     }
    44 
    45     /**
    46      * 获取请求方法上的scope权限
    47      *
    48      * @param handler
    49      * @return
    50      */
    51     private Optional<ScopeLevel> getScopeLevel(Object handler) {
    52         if (handler instanceof HandlerMethod) {
    53             HandlerMethod handlerMethod = (HandlerMethod) handler;
    54             ScopeLevel scopeLevel = handlerMethod.getMethod().getAnnotation(ScopeLevel.class);
    55             if(scopeLevel == null){
    56                 return Optional.empty();
    57             }
    58             return Optional.of(scopeLevel);
    59         }
    60         return Optional.empty();
    61     }
    62 
    63     /**
    64      * token中的权限与注解中的权限进行比较 判断是否有权限进行访问
    65      *
    66      * @param scopeLevel 权限注解
    67      * @param map token中传递的参数
    68      * @return
    69      */
    70     private boolean hasPermission(ScopeLevel scopeLevel, Map<String, Claim> map) {
    71         Integer level = scopeLevel.value();
    72         Integer scope = map.get("scope").asInt();
    73         if(level > scope){
    74             throw new ForbiddenException(10005);
    75         }
    76         return true;
    77     }
    78 }

    将interceptor注册到spring容器的启动项中:

    1 @Component
    2 public class InterceptorConfiguration implements WebMvcConfigurer {
    3 
    4     @Override
    5     public void addInterceptors(InterceptorRegistry registry) {
    6         // 将权限拦截器注册到spring启动项中
    7         registry.addInterceptor(new PermissionInterceptor());
    8     }
    9 }

     内容出处:七月老师《从Java后端到全栈》视频课程

    七月老师课程链接:https://class.imooc.com/sale/javafullstack

  • 相关阅读:
    网络学习笔记
    zabbix4.2学习笔记系列
    ansible2.7学习笔记系列
    记一次磁盘UUID不能识别故障处理
    白话ansible-runner--1.环境搭建
    kubernetes的思考
    计算机网络原理精讲第六章--应用层
    计算机网络原理精讲第五章--传输层
    centos7下LVM挂载和扩容
    多线程下载命令--axel
  • 原文地址:https://www.cnblogs.com/ssh-html/p/13083436.html
Copyright © 2020-2023  润新知