JWT详解（文章内嵌jwt工具类）

迷南。 2023-09-24 14:26 71阅读 0赞

## JWT 基础概念详解，工具类和使用方法放在最后 ##

### 什么是 JWT? ###

JWT （JSON Web Token） 是目前最流行的跨域认证解决方案，是一种基于 Token 的认证授权机制。 从 JWT 的全称可以看出，JWT 本身也是 Token，一种规范化之后的 JSON 结构的 Token。

JWT 自身包含了身份验证所需要的所有信息，因此，我们的服务器不需要存储 Session 信息。这显然增加了系统的可用性和伸缩性，大大减轻了服务端的压力。

> ### jwt生成的token如下（例子）： ###
> 
> eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRlIjoxNjY4NjczOTM4LCJib29sIjp0cnVlLCJkb3VibGUiOjExMi4yMjIsIkxvbmciOjExMiwicm9zZSI6ImFkbWluIiwiaW50ZWdlciI6MTExMSwiZXhwIjoxNjY4Njc0ODM4LCJpYXQiOjE2Njg2NzM5MzgsInVzZXJJZCI6IjEyMzQ1NiJ9.ryTEhOnX9B\_vIhfMdgWVPeCBN8Y5mjNoQC-ba8tOXj8
> 
> 目前我们**不需要了解这个很长的 token 的意思**，我们只要了解他是由三部分组成，用 `.` 进行分割，里面拥有信息（自定义参数、私钥、生成时间、过期时间、 token 算法等），由后端生成传递给前端（登录时，账号密码对了，后端（后端不保留 token 值）就生成个 token 给前端（这个token可以携带自己定义的参数，如：用户id（userId））），然后前端把 token 保存起来（仅在前端保存 token 就行了），每次请求时带上这个 token ，我们可以根据后台的 jwt 算法与 jwt 私钥参数（这些我都写在工具类里，拿这个工具类来解析这个 token 就行），对前端再次传过来的这段 token 进行解密，并得到自己需要的参数（如：userId ），那么就可以拿到这个 userId 操作数据库。
> 
> #### 一、例子如下： ####
> 
>     //下面这段代码只是一个参照，没有实现token生成的代码，只是告诉我们jwt是干嘛的
>     public static void main(String[] args) throws InterruptedException {
>          
>     		//我们可以自定义一个map，并把map传进token里面
>             Map<String,Object> map = new HashMap<>();
>             //可以加很多的参数，包括但不限于以下两种
>             map.put("userId","123456");
>             map.put("rose","admin");
>         
>             // sign() 是一个当前文件的静态方法，之后调用的所有方法都是当前文件的方法，封装了一个工具类，在最后面，我会给大家，目前先理解着
>         
>             String token = sign(map); //把map丢进去，生成token
>             System.out.println(token); //输出token
>             System.out.println(verify(token));//验证token是否正确
>             String dd = getClaims(token).get("userId").asString(); //使用方法
>             System.out.println(dd);  // 获取 userId ，后端根据这个token就可以拿到 userId 了，那么就可以拿着这个id去增删改数据库了
>             System.out.println("获取签发token时间：" +getIssuedAt(token));
>             System.out.println("获取过期时间："+getExpiresAt(token));
>             System.out.println("检查是否已过期："+isExpired(token));
>             System.out.println("获取头"+getHeaderByBase64(token));
>             System.out.println("获取负荷"+getPayloadByBase64(token));
>         }
> 
> #### 二、我的项目中的使用案例：（写的有点差，大佬们看看就行） ####
> 
> ##### 登录传递token： #####
> 
>     @Override
>         public R login(LoginDTO loginDTO) {
>          
>             User loginUser = new User();
>             loginUser.setUserName(loginDTO.getUserName())
>                     .setPassword(loginDTO.getPassword());
>             try {
>          
>                 //根据账号密码拿到用户信息
>                 User user = this.baseMapper.selectOne(
>                         new LambdaQueryWrapper<User>()
>                                 .eq(User::getUserName, loginUser.getUserName())
>      // 这是我毕设，目前还在开发中，前端是vue写的，vue太难了，就直接明文传输了，在后端加密跟数据库匹配，体现我的确是知道密码是要加密的，但前端太难，懒得做了
>                                 .eq(User::getPassword, MD5Util.md5(loginUser.getPassword())));
>                 if (user!=null){
>          
>                     // 把两个参数加入到map中
>                     Map<String,Object> map = new HashMap<>(2);
>                     map.put("userId",user.getUserId());
>                     map.put("jurisdiction",user.getJurisdiction());
>                     // 把map丢给jwt处理，拿到token返回
>                     String token = Auth0JwtUtils.sign(map);
>                     Map<String , String> map2 = new HashMap<>(1);
>                     map2.put("token",token);
>                     // 因为我的vue模板要k-v键值对的方式传递token，所以我也懒得改，直接返个map给前端就行了
>                     return R.Success(map2);
>                 }
>             } catch (NoSuchAlgorithmException e) {
>          
>                 log.error(e.getMessage());
>             }
>             return R.Failed("账号密码错误");
>         }
> 
> ##### 根据前端返回的token获取用户信息： #####
> 
>     @Override
>     	// 获取用户信息的 serviceImpl
>         public R getUserInfo(String token) {
>          
>             try {
>          
>                 // 判断token是否正确且在有效期范围内
>                 if (Auth0JwtUtils.verify(token)&&!Auth0JwtUtils.isExpired(token)){
>          
>                     // 根据token，获取到 jurisdiction（权限）和 userId 用户的id
>                     Integer jurisdiction = Auth0JwtUtils.getInteger(token,"jurisdiction");
>                     Integer userId = Auth0JwtUtils.getInteger(token,"userId");
>                     // 根据 userId 查询数据库
>                     User user = this.baseMapper.selectOne(new LambdaQueryWrapper<User>().eq(User::getUserId, userId));
>                     Map<String , Object> map = new HashMap<>(10);
>                     // 写了个枚举来遍历权限
>                     for (JurisdictionEnum value : JurisdictionEnum.values()) {
>          
>                         if (value.getJurisdiction().equals(jurisdiction)){
>          
>                             map.put("role",value.getName());
>                             map.put("roles",value.getX());
>                             break;
>                         }
>                     }
>                     // 挨个装起来
>                     map.put("sex",user.getSex());
>                     map.put("introduction",user.getIntroduction());
>                     map.put("avatar",user.getImage());
>                     map.put("phone",user.getPhone());
>                     map.put("name",user.getRealName());
>                     // 返回给前端
>                     return R.Success(map);
>                 }
>             } catch (Exception e) {
>          
>                 log.error(e.getMessage());
>             }
>             return R.Failed();
>         }

可以看出，**JWT 更符合设计 RESTful API 时的「Stateless（无状态）」原则** 。

并且， 使用 JWT 认证可以有效避免 CSRF 攻击，因为 JWT 一般是存在在 localStorage 中，使用 JWT 进行身份验证的过程中是不会涉及到 Cookie 的。

下面是 [RFC 7519open in new window][] 对 JWT 做的较为正式的定义。

> JSON Web Token (JWT) is a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is used as the payload of a JSON Web Signature (JWS) structure or as the plaintext of a JSON Web Encryption (JWE) structure, enabling the claims to be digitally signed or integrity protected with a Message Authentication Code (MAC) and/or encrypted. ——[JSON Web Token (JWT)open in new window][RFC 7519open in new window]

### JWT 由哪些部分组成？ ###

![此图片来源于：https://supertokens.com/blog/oauth-vs-jwt][https_supertokens.com_blog_oauth-vs-jwt]

JWT 本质上就是一组字串，通过（`.`）切分成三个为 Base64 编码的部分：

*  **Header** : 描述 JWT 的元数据，定义了生成签名的算法以及 `Token` 的类型。
 *  **Payload** : 用来存放实际需要传递的数据
 *  **Signature（签名）** ：服务器通过 Payload、Header 和一个密钥(Secret)使用 Header 里面指定的签名算法（默认是 HMAC SHA256）生成。

JWT 通常是这样的：`xxxxx.yyyyy.zzzzz`。

示例：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
    eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
    SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

你可以在 [jwt.ioopen in new window][] 这个网站上对其 JWT 进行解码，解码之后得到的就是 Header、Payload、Signature 这三部分。

Header 和 Payload 都是 JSON 格式的数据，Signature 由 Payload、Header 和 Secret(密钥)通过特定的计算公式和加密算法得到。

![img][]

#### Header ####

Header 通常由两部分组成：

*  `typ`（Type）：令牌类型，也就是 JWT。
 *  `alg`（Algorithm） ：签名算法，比如 HS256。

示例：

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

JSON 形式的 Header 被转换成 Base64 编码，成为 JWT 的第一部分。

#### Payload ####

Payload 也是 JSON 格式数据，其中包含了 Claims(声明，包含 JWT 的相关信息)。

Claims 分为三种类型：

*  **Registered Claims（注册声明）** ：预定义的一些声明，建议使用，但不是强制性的。
 *  **Public Claims（公有声明）** ：JWT 签发方可以自定义的声明，但是为了避免冲突，应该在 [IANA JSON Web Token Registryopen in new window][] 中定义它们。
 *  **Private Claims（私有声明）** ：JWT 签发方因为项目需要而自定义的声明，更符合实际项目场景使用。

下面是一些常见的注册声明：

*  `iss`（issuer）：JWT 签发方。
 *  `iat`（issued at time）：JWT 签发时间。
 *  `sub`（subject）：JWT 主题。
 *  `aud`（audience）：JWT 接收方。
 *  `exp`（expiration time）：JWT 的过期时间。
 *  `nbf`（not before time）：JWT 生效时间，早于该定义的时间的 JWT 不能被接受处理。
 *  `jti`（JWT ID）：JWT 唯一标识。

示例：

{
        
      "uid": "ff1212f5-d8d1-4496-bf41-d2dda73de19a",
      "sub": "1234567890",
      "name": "John Doe",
      "exp": 15323232,
      "iat": 1516239022,
      "scope": ["admin", "user"]
    }

Payload 部分默认是不加密的，**一定不要将隐私信息存放在 Payload 当中！！！**

JSON 形式的 Payload 被转换成 Base64 编码，成为 JWT 的第二部分。

#### Signature ####

Signature 部分是对前两部分的签名，作用是防止 JWT（主要是 payload） 被篡改。

这个签名的生成需要用到：

*  Header + Payload。
 *  存放在服务端的密钥(一定不要泄露出去)。
 *  签名算法。

签名的计算公式如下：

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

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（`.`）分隔，这个字符串就是 JWT 。

### 如何基于 JWT 进行身份验证？ ###

在基于 JWT 进行身份验证的的应用程序中，服务器通过 Payload、Header 和 Secret(密钥)创建 JWT 并将 JWT 发送给客户端。客户端接收到 JWT 之后，会将其保存在 Cookie 或者 localStorage 里面，以后客户端发出的所有请求都会携带这个令牌。

![JWT 身份验证示意图][JWT]

简化后的步骤如下：

1.  用户向服务器发送用户名、密码以及验证码用于登陆系统。
2.  如果用户用户名、密码以及验证码校验正确的话，服务端会返回已经签名的 Token，也就是 JWT。
3.  用户以后每次向后端发请求都在 Header 中带上这个 JWT 。
4.  服务端检查 JWT 并从中获取用户相关信息。

两点建议：

1.  建议将 JWT 存放在 localStorage 中，放在 Cookie 中会有 CSRF 风险。
2.  请求服务端并携带 JWT 的常见做法是将其放在 HTTP Header 的 `Authorization` 字段中（`Authorization: Bearer Token`）。

**[spring-security-jwt-guideopen in new window][]** 就是一个基于 JWT 来做身份认证的简单案例，感兴趣的可以看看。

### 如何防止 JWT 被篡改？ ###

有了签名之后，即使 JWT 被泄露或者截获，黑客也没办法同时篡改 Signature 、Header 、Payload。

这是为什么呢？因为服务端拿到 JWT 之后，会解析出其中包含的 Header、Payload 以及 Signature 。服务端会根据 Header、Payload、密钥再次生成一个 Signature。拿新生成的 Signature 和 JWT 中的 Signature 作对比，如果一样就说明 Header 和 Payload 没有被修改。

不过，如果服务端的秘钥也被泄露的话，黑客就可以同时篡改 Signature 、Header 、Payload 了。黑客直接修改了 Header 和 Payload 之后，再重新生成一个 Signature 就可以了。

**密钥一定保管好，一定不要泄露出去。JWT 安全的核心在于签名，签名安全的核心在密钥。**

### 如何加强 JWT 的安全性？ ###

1.  使用安全系数高的加密算法。
2.  使用成熟的开源库，没必要造轮子。
3.  JWT 存放在 localStorage 中而不是 Cookie 中，避免 CSRF 风险。
4.  一定不要将隐私信息存放在 Payload 当中。
5.  密钥一定保管好，一定不要泄露出去。JWT 安全的核心在于签名，签名安全的核心在密钥。
6.  Payload 要加入 `exp` （JWT 的过期时间），永久有效的 JWT 不合理。并且，JWT 的过期时间不易过长。
7.  and so on

## 好了，讲了这么多，其实我也记不全，直接拿JWT工具类来用就行，但稍微理解下原理的话，那么就可以应对各种各样的问题了不是 ##

### maven包：![在这里插入图片描述][01be7907ffec4ebdae733c8f97570251.png] ###

<dependency>
        <groupId>com.auth0</groupId>
        <artifactId>java-jwt</artifactId>
        <version>3.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.9</version>
    </dependency>

### 工具类： ###

package com.zhao.utils;
    
    import com.auth0.jwt.JWT;
    import com.auth0.jwt.JWTCreator;
    import com.auth0.jwt.JWTVerifier;
    import com.auth0.jwt.algorithms.Algorithm;
    import com.auth0.jwt.exceptions.JWTDecodeException;
    import com.auth0.jwt.exceptions.TokenExpiredException;
    import com.auth0.jwt.interfaces.Claim;
    import com.auth0.jwt.interfaces.DecodedJWT;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    
    import java.util.Base64;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     *@author:Tlimited
     */
    @Slf4j
    public class Auth0JwtUtils {
        
        //过期时间 15分钟
        private static final long EXPIRE_TIME = 15* 60 * 1000;
        //私钥
        private static final String TOKEN_SECRET = "privateKey";
    
        /**
         * 生成签名，15分钟过期
         * 根据内部改造，支持6中类型，Integer,Long,Boolean,Double,String,Date
         * @param map
         * @return
         */
        public static String sign(Map<String,Object> map) {
        
            try {
        
                // 设置过期时间
                Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
                // 私钥和加密算法
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
                // 设置头部信息
                Map<String, Object> header = new HashMap<>(2);
                header.put("typ", "jwt");
                // 返回token字符串
               JWTCreator.Builder builder =  JWT.create()
                        .withHeader(header)
                        .withIssuedAt(new Date()) //发证时间
                        .withExpiresAt(date);  //过期时间
                     //   .sign(algorithm);  //密钥
                 // map.entrySet().forEach(entry -> builder.withClaim( entry.getKey(),entry.getValue()));
                  map.entrySet().forEach(entry -> {
        
                      if (entry.getValue() instanceof Integer) {
        
                          builder.withClaim( entry.getKey(),(Integer)entry.getValue());
                      } else if (entry.getValue() instanceof Long) {
        
                          builder.withClaim( entry.getKey(),(Long)entry.getValue());
                      } else if (entry.getValue() instanceof Boolean) {
        
    
                          builder.withClaim( entry.getKey(),(Boolean) entry.getValue());
                      } else if (entry.getValue() instanceof String) {
        
                          builder.withClaim( entry.getKey(),String.valueOf(entry.getValue()));
                      } else if (entry.getValue() instanceof Double) {
        
                          builder.withClaim( entry.getKey(),(Double)entry.getValue());
                      } else if (entry.getValue() instanceof Date) {
        
                              builder.withClaim( entry.getKey(),(Date)entry.getValue());
                      }
                  });
                return builder.sign(algorithm);
            } catch (Exception e) {
        
                log.error(e.getMessage());
                return null;
            }
        }
    
    
        /**
         * 检验token是否正确
         * @param **token**
         * @return
         */
        public static boolean verify(String token){
        
            try {
        
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
                JWTVerifier verifier = JWT.require(algorithm).build();
                verifier.verify(token);
    
                return true;
            } catch (Exception e){
        
                log.error(e.getMessage());
                return false;
            }
        }
    
        /**
         *获取用户自定义Claim集合
         * @param token
         * @return
         */
        public static Map<String, Claim> getClaims(String token){
        
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            JWTVerifier verifier = JWT.require(algorithm).build();
            Map<String, Claim> jwt = verifier.verify(token).getClaims();
            return jwt;
        }
    
        /**
         *获取用户自定义根据token和字符串拿到String数据
         * @param token
         * @return String
         */
        public static String getString(String token,String z) {
        
            try {
        
                DecodedJWT jwt = JWT.decode(token);
                return jwt.getClaim(z).asString();
            } catch (JWTDecodeException e) {
        
                log.error(e.getMessage());
                return null;
            }
        }
        /**
         *获取用户自定义根据token和字符串拿到Integer数据
         * @param token
         * @return Integer
         */
        public static Integer getInteger(String token,String z) {
        
            try {
        
                DecodedJWT jwt = JWT.decode(token);
                return jwt.getClaim(z).asInt();
            } catch (JWTDecodeException e) {
        
                log.error(e.getMessage());
                return null;
            }
        }
    
    
        /**
         * 获取过期时间
         * @param token
         * @return
         */
        public static Date getExpiresAt(String token){
        
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
             return  JWT.require(algorithm).build().verify(token).getExpiresAt();
        }
    
        /**
         * 获取jwt发布时间
         */
        public static Date getIssuedAt(String token){
        
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            return  JWT.require(algorithm).build().verify(token).getIssuedAt();
        }
    
        /**
         * 验证token是否失效
         *
         * @param token
         * @return true:过期   false:没过期
         */
        public static boolean isExpired(String token) {
        
            try {
        
                final Date expiration = getExpiresAt(token);
                return expiration.before(new Date());
            }catch (TokenExpiredException e) {
        
                log.error(e.getMessage());
                return true;
            }
    
        }
    
        /**
         * 直接Base64解密获取header内容
         * @param token
         * @return
         */
        public static String getHeaderByBase64(String token){
        
            if (StringUtils.isEmpty(token)){
        
                return null;
            }else {
        
                byte[] header_byte = Base64.getDecoder().decode(token.split("\\.")[0]);
                String header = new String(header_byte);
                return header;
            }
    
        }
    
        /**
         * 直接Base64解密获取payload内容
         * @param token
         * @return
         */
        public static String getPayloadByBase64(String token){
        
    
            if (StringUtils.isEmpty(token)){
        
                return null;
            }else {
        
                byte[] payload_byte = Base64.getDecoder().decode(token.split("\\.")[1]);
                String payload = new String(payload_byte);
                return payload;
            }
    
        }
        public static void main(String[] args) throws InterruptedException {
        
            Map<String,Object> map = new HashMap<>();
            map.put("userId","123456");
            map.put("rose","admin");
            map.put("integer",1111);
            map.put("double",112.222);
            map.put("Long",112L);
            map.put("bool",true);
            map.put("date",new Date());
            String token = sign(map); //生成token
            System.out.println(token);
            System.out.println(verify(token));//验证token是否正确
            String dd = getClaims(token).get("integer").asString(); //使用方法
            System.out.println(dd);
            String userId = getString(token, "userId");  //获取String 类型的 userId
            System.out.println(userId);
            Integer integer = getInteger(token, "integer"); // 获取Integer 类型的 userId
            System.out.println(integer);
            System.out.println("获取签发token时间：" +getIssuedAt(token));
            System.out.println("获取过期时间："+getExpiresAt(token));
           // Thread.sleep(1000*40);
            System.out.println("检查是否已过期："+isExpired(token));
            System.out.println("获取头"+getHeaderByBase64(token));
            System.out.println("获取负荷"+getPayloadByBase64(token));
        }
    
    }

### 输出： ###

> eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRlIjoxNjY4Njc3NzQyLCJib29sIjp0cnVlLCJkb3VibGUiOjExMi4yMjIsIkxvbmciOjExMiwicm9zZSI6ImFkbWluIiwiaW50ZWdlciI6MTExMSwiZXhwIjoxNjY4Njc4NjQyLCJpYXQiOjE2Njg2Nzc3NDIsInVzZXJJZCI6IjEyMzQ1NiJ9.48may1A-FwGUdB6N2dbGnVX2NuKCGfUBSehsA6ARm5Y  
> true  
> null  
> 123456  
> 1111  
> 获取签发token时间：Thu Nov 17 17:35:42 CST 2022  
> 获取过期时间：Thu Nov 17 17:50:42 CST 2022  
> 检查是否已过期：false  
> 获取头\{“typ”:“JWT”,“alg”:“HS256”\}  
> System.out.println(“获取负荷”+getPayloadByBase64(token));  
> \}

### 参考文章：[JWT 基础概念详解][JWT 1] ###

[RFC 7519open in new window]: https://tools.ietf.org/html/rfc7519
[https_supertokens.com_blog_oauth-vs-jwt]: https://img-blog.csdnimg.cn/img_convert/12b88a9f815b8fd96499ccda2f96e1d7.png
[jwt.ioopen in new window]: https://jwt.io/
[img]: https://img-blog.csdnimg.cn/img_convert/94636c5bb6be422387da2da118a20675.png
[IANA JSON Web Token Registryopen in new window]: https://www.iana.org/assignments/jwt/jwt.xhtml
[JWT]: https://img-blog.csdnimg.cn/img_convert/074bd3771c8fb4cc067cec8b5d136610.png
[spring-security-jwt-guideopen in new window]: https://github.com/Snailclimb/spring-security-jwt-guide
[01be7907ffec4ebdae733c8f97570251.png]: https://img-blog.csdnimg.cn/01be7907ffec4ebdae733c8f97570251.png
[JWT 1]: https://javaguide.cn/system-design/security/jwt-intro.html