JWT讲解

JWT

1.什么是JWT

JSON Web Token (JWT) is an open standard ([RFC 7519](https://tools.ietf.org/html/rfc7519)) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. 
This information can be verified and trusted because it is digitally signed.
JWTs can be signed using a secret (with the **HMAC** algorithm) or a public/private key pair using **RSA** or **ECDSA**.` 

​ --[摘自官网]

#1.翻译

--官网：https://tools.ietf.org/html/rfc7519

--翻译：jsonwebtoken(JWT)是一个开放标准（rfc7519），它定义了一种紧凑的、自包含的方式，用于在各方面之间以json对象安全地传输信息，此信息可以验证和信任，因为它是数字签名的。jwt可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名。

#2.通俗翻译

--JWT简称JSON WEB Token，也就是通过JSON形式作为web应用中的令牌。用于在各方面之间安全地将信息作为JSON对象传输，在数据传输过程中还可以完成数据加密，签名等相关处理。

2.JWT能做什么

#1.授权
--这是使用JWT的最常见的方案，一旦用户登录，每个后续请求将包括JWT，从而允许用户方位该令牌允许的路由、服务和资源。单点登录是当今广泛使用JWT的一项功能，因为它开销很小并且可以在不同的域中轻松使用。
#2.信息交换
--JSON Web Token是在各方之间安全地传输信息的好方法。因为可以对JWT进行签名（例如：使用公钥/私钥对），所以可以确保发件人是他们所说的人。此外。由于签名是使用标头和有效负载计算的。因此您还可以验证内容是否遭到篡改。

3.为什么是JWT

基于传统的session认证

#1.认证方式

--我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证。那么下一次请求时。用户还要再一次进行用户认证才行。因为根据http协议。我们并不能知道是哪一个用户发出的请求。所以为了让我们的应用能识别是哪一个用户发出的请求。我们只能在服务器存储一份用户登录信息。这份登录信息会在响应时传递给浏览器。告诉其保存为cookie，以便下次请求时发送给我们的应用。这样我们的应用就能识别请求来自哪个用户了，这就是传统的基于session认证。

#2.认证流程

#3.暴露问题

--1.每个用户经过我们的应用认证之后，我们的应用都要在服务器做一次记录，以方便用户下次请求的鉴别。通常而言session都是保存在内容中。而随着认证用户的增多，服务端的开销会明显增大。

--2.用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话。这意味着用户下次请求还必须要请求在这台服务器上。这样才能拿到授权的资源。这样的分布式应用上。相应的限制了负载均衡器的能力。这也意味着限制了应用的扩展能力。

--3.因为是基于cookie来进行限制识别的，cookie如果被截获，用户就很容易收到跨站请求伪造的攻击。

--4.在前后端分离系统中就更加痛苦：如下图所示

    也就是说前后端分离在应用解耦后增加了部署的复杂性。通常用户一次请求就要转发多次。如果session每次携带sessionid到服务器，服务器还要查询用户信息。同时如果用户很多。这些信息存储在服务器内存中。给服务器增加负担。还有就是CSRF（跨站伪造请求攻击）攻击，session是基于cookie进行用户识别的。cookie如果被截获，用户就会很容易收到跨站请求伪造攻击。还有就是sessionid就是一个特征值，表单的信息不够丰富。不容易扩展。而且如果你后端应用是多节点部署。那么就需要实现session共享机制。不方便集群应用。

基于JWT认证

#1.认证流程

--首先，前端通过Web表单将自己的用户名和密码发送到后端的接口，这一过程一般是一个Http post请求。建议的方式是通过SSL加密的传输(https协议)，从而避免敏感信息被嗅探。

--后端核对用户名和密码成功后，将用户名的id等其他信息作为JWT Payload(负载)，将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。形成的JWT就是一个形同与lll.zzz.xxx的字符串。token格式：header.payload.signature;

--后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage或sessionStrorager上，退出登录时前端删除保存的JWT即可。

--前端在每次请求时将JWT放入HTTP Header中Authorization位。（解决XSS和XSRF问题）HEADER

--后端检查是否存在。如存在验证JWT的有效性。例如，检查签名是否正确；检查Token是否过期；检查Token的接收方是否是自己(可选)。



--验证通过后后端使用JWT中包含的用户信息进行其他逻辑操作，返回相应结果。

#2.jwt优势

--简洁(Compact):可以通过URL,POST参数或者在HTTP Header发送，因为数据量小，传输速度也很快。

--自包含(Self-contained):负载中包含了所有用户所需要的信息。避免了多次查询数据库。

--因为Token是-JSON加密的形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。

--不需要在服务端保存会话信息，特别使用于分布式微服务。

4.JWT的结构是什么？

token 		String =====Header.Payload.signature    token

#1.令牌组成

--1.标头(Header)

--2.有效载荷(Payload)

--3.签名(signature)

--因此JWT通常如下所示：xxxx.yyyyy.zzzz    Header.Payload.signature 

#2.Header

--标头通常由两部分组成：令牌的类型(即JWT)和所使用的签名算法，例如HMAC SHA256或RSA。它会使用Base64组成JWT结构的第一部分.

--注意：Base64是一种编码，也就是说，它是可以被翻译回原来的样子来的。它并不是一种加密过程。

{
"alg":"HS256"
"type":"JWT"
}

#3.payload

--令牌的第二部分是有效负载，其中包含声明。声明是有关实体(通常是用户)和其他数据的声明。同样的，它会使用Base64编码组成JWT结构的第二部分

{
"sub":"1234567890",
"name":"John Doe",
"admin":true
}

#4.Signature

--前面两部分都是使用Base64进行编码的，即前端可以解开知道里面的信息。Signature需要使用编码后的header和payload以及我们提供的一个秘钥，然后使用header中指定的签名算法（HS256）进行签名。签名的作用是保证JWT没有被篡改过

--如：

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

#签名目的
--最后一步签名的过程，实际上是对头部以及负载内容进行签名，防止内容被篡改。如果有人对头部以及负载的内容解码之后进行修改，再进行编码，最后加上之前的签名组合形成新的JWT的话，那么服务器端会判断出新的头部和负载形成的签名和JWT附带上的签名是不一样的。如果要对新的头部和负载进行签名，在不知道服务器加密时用密钥的话，得出来的签名也是不一样的。

#信息安全问题
--在这里大家一定会问一个问题：Base64是一种编码，是可逆的，那么我的信息不被暴露了吗？

--是的。所以，在JWT中，不应该在负载里面加入任何敏感的数据。在上面的例子中，我们传输的是用户的User ID.这个值实际上不是什么敏感的内容，一般情况下被知道也是安全的。但是想密码这样的内容就不能被放在JWT中了。如果将用户的密码放在了JWT中，那么怀有恶意的第三方通过Base64解码就能很快地知道你的密码了。因此JWT适合用于向WEB应用传递一些非敏感信息。JWT还经常用户设计用户认证和授权系统，甚至实现web应用的单点登录

#5.放在一起
--输出的三个点分隔的Base64-URL字符串，可以再HTML和HTTP环境中轻松传递这些字符串，与基于XML的标准(例如SAML)相比，它更紧凑。
--简洁(Compact)
	可以通过URL,POST参数或者在HTTP header发送，因为数据量小，传输速度快。
--自包含(Self-contained)
负载中包含了所有用户所需要的信息，避免了多次查询数据库

5.使用JWT

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.16.0</version>
</dependency>

java测试类

package com.zhshhypt;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.apache.commons.collections.bag.SynchronizedSortedBag;
import org.testng.annotations.Test;

import java.util.Calendar;
/**
 * @Description:JWT测试程序
 * @Author: JWTTest
 * @Date: 2021/6/20 0020
 */
public class TEST {
    /**
     * @Description: 生成token对象
     * @params: 
     * @return: 
     * @Author: Administrator
     * @Date: 2021/6/20 0020
     */
   @Test
   public void ContextLoad() {
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND, 60);//设置有效时间
        String sign = JWT.create()
                .withClaim("username", "cyz")
                .withClaim("userid", 12)
                .withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256("!FDA12SD@#@#"));
                System.out.println(sign);
    }
    /*输出token结果：eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MjQyMDI5NTcsInVzZXJpZCI6MTIsInVzZXJuYW1lIjoiY3l6In0.LwhE-nkfo8OFgO8hPWuO9YQfJAGtXXuUpc6ET7tESOs*/

    /**
     * @Description:验证签名：根据令牌和签名解析数据
     * @params: []
     * @return: void
     * @Author: Administrator
     * @Date: 2021/6/20 0020
     */
  @Test
  public void test() {
       JWTVerifier jwtverify = JWT.require(Algorithm.HMAC256("!FDA12SD@#@#")).build();
        DecodedJWT verify =jwtverify.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MjQyMDIyMjEsInVzZXJpZCI6MTIsInVzZXJuYW1lIjoiY3l6In0.fMx5j59Fu_PPTo2mt9GGgo1yYB4HpXu-u_kS4hbPuZ8");
        System.out.println("用户名" + verify.getClaim("username").asString());
        System.out.println("用户id" + verify.getClaim("userid").asInt());
        System.out.println("过期时间：" + verify.getExpiresAt());
    }
}

#1.常见的异常信息
-SignatureVerificationException： 签名不一致异常
-TokenExpiredException：          令牌过期异常
-AlgorithmMismatchException：     算法不匹配异常
-InvalidClaimException:           失效的payload异常

6.封装工具类

package com.zhshhypt.util;
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.interfaces.DecodedJWT;
import java.util.Calendar;
import java.util.Map;
/**
 *  @Description:jwt工具类封装
 *  @Author: JWTUtils
 *  @Date: 2021/6/20 0020
 */
public class JWTUtils {
    private  static final String sign="!FDA12SD@#@#";//盐
    public static String getToken(Map<String,String> map){
        Calendar instance;
        instance =Calendar.getInstance();
        instance.add(Calendar.DATE,7);//设置有效时间7天
        //创建jwt builder
        JWTCreator.Builder builder=JWT.create();

        //payload
        map.forEach((k,v)->{
            builder.withClaim(k,v);
        });
        String token=builder.withExpiresAt(instance.getTime())//指定令牌过期时间
                .sign(Algorithm.HMAC256(sign));
        return token;
    }
    /**
     * @Description:验证token 合法性
     * @params: [token]
     * @return: void
     * @Author: Administrator
     * @Date: 2021/6/20 0020
     */
    public static void verify(String token){
       JWT.require(Algorithm.HMAC256("!FDA12SD@#@#")).build().verify(token);
        //或者直接返回DecodeJWT
    }
    /**
     * @Description:获取token信息方法
     * @params: [token]
     * @return: com.auth0.jwt.interfaces.DecodedJWT
     * @Author: Administrator
     * @Date: 2021/6/20 0020
     */
    public static DecodedJWT getTokenInfo(String token){
        DecodedJWT verify = JWT.require(Algorithm.HMAC256(sign)).build().verify(token);
        return verify;
    }
}

#springboot+mybatis+jwt环境

--引入依赖

--编写配置

 <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatisplus-spring-boot-starter</artifactId>
            <version>1.0.5</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>2.3</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!-- configuration yml自定义配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
        </dependency>
        <!--启动热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--JWT-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.16.0</version>
        </dependency>

package com.zhshhypt.Controller;/**
 * @description:
 * @author: cyz
 * @time: 2021/6/21 0021
 */

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.zhshhypt.pojo.User;
import com.zhshhypt.service.IUserService;
import com.zhshhypt.util.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.annotation.RequestScope;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

/**
 *  @Description:
 *  @Author: LoginController
 *  @Date: 2021/6/21 0021
 */
@RestController
@Slf4j
public class LoginController {
   @Resource
    private IUserService iUserService;

    @GetMapping(value="/login")
    public Map<String,Object> login(User user){
        log.info("用户名"+user.getName());
        log.info("密码"+user.getPwd());
        Map<String,Object>  map=new HashMap<>();
        try {
            User userDB = iUserService.login(user);
            Map<String,String>  payload=new HashMap<>();
            payload.put("id",userDB.getId());
            payload.put("name",userDB.getName());
            //生成JWT的令牌
            String token = JWTUtils.getToken(payload);
            map.put("statue", true);
            map.put("msg", "认证成功");
            map.put("token",token);//响应token
        }catch(Exception e){
            map.put("statue",false);
            map.put("msg",e.getMessage());
        }
        return map;
    }

    @PostMapping("/test")
    public Map<String,Object> test(String token){
        Map<String,Object>  map=new HashMap<>();
        log.info("当前token为"+token);
        try {
           DecodedJWT verify=JWTUtils.getTokenInfo(token);//验证令牌
            map.put("state",true);
            map.put("msg","请求成功！");
            return map;
        }catch(SignatureVerificationException e){
            e.printStackTrace();
            map.put("msg","无效签名！");
        }catch(TokenExpiredException e){
            e.printStackTrace();
            map.put("msg","token过期");
        }catch(AlgorithmMismatchException e){
            e.printStackTrace();
            map.put("msg","token算法不一致");
        }catch(Exception e){
            e.printStackTrace();
            map.put("msg","token无效！");
        }
        map.put("state",false);
        return map;
    }
}

service层

/**
 *  服务类
 *
 * @author jobob
 * @since 2021-05-29
 */
public interface IUserService extends IService<User> {

    User login(User user);
}

dao层

package com.zhshhypt.mapper;

import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.zhshhypt.pojo.User;

/**
 * Mapper 接口
 * @author jobob
 * @since 2021-05-29
 */
public interface UserMapper extends BaseMapper<User> {

    User login(User user);
}

mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhshhypt.mapper.UserMapper">
        <select id="login" resultType="com.zhshhypt.pojo.User">
             select * from tb_user where name=#{name} and pwd=#{pwd}
         </select>
</mapper>

将JWTUtils工具类日期失效改为20s

20s后的失效场景，将token值带入到test进行验证

#11.问题
–使用上述方式每次都要传递token数据，每个方法都需要验证token代码沉余，不够灵活？如何优化？
–使用拦截器进行优化

package com.zhshhypt.util;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

import org.springframework.web.servlet.HandlerInterceptor;
/**
 *  @Description:对token签名验证进行拦截
 *  @Author: JWTInterceptor
 *  @Date: 2021/6/23 0023
 */
public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Map<String,Object> map=new HashMap<>();
        //获取请求头中的令牌
        String token = request.getHeader("token");
        try {
            JWTUtils.verify(token);//验证令牌
            return true;
        }catch(SignatureVerificationException e){
            e.printStackTrace();
            map.put("msg","无效签名！");
        }catch(TokenExpiredException e){
            e.printStackTrace();
            map.put("msg","token过期");
        }catch(AlgorithmMismatchException e){
            e.printStackTrace();
            map.put("msg","token算法不一致");
        }catch(Exception e){
            e.printStackTrace();
            map.put("msg","token无效！");
        }
        map.put("state",false);//设置状态
        String json=new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

配置类进行拦截

package com.zhshhypt.config;
/**
 * @description:
 * @author: cyz
 * @time: 2021/6/23 0023
 */
import com.zhshhypt.util.JWTInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 *  @Description:
 *  @Author: InterceptorConfig
 *  @Date: 2021/6/23 0023
 */
@Configuration
public class InterceptorConfig  implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/**")   //其他接口验证令牌
                .excludePathPatterns("/login");//路劲放行
    }
}

请求controller

@PostMapping("/tesst")
    public Map<String,Object> test(HttpServletRequest request) {
        Map<String, Object> map = new HashMap<>();
        String token = request.getHeader("token");//请求头上带参数
        DecodedJWT tokenInfo = JWTUtils.getTokenInfo(token);//验证令牌
        System.out.println("用户id"+ tokenInfo.getClaim("id").asString());
        System.out.println("用户name"+ tokenInfo.getClaim("name").asString());
        map.put("state",true);
        map.put("msg","请求成功！");
        return map;
    }

postman请求

请求controller

```java
@PostMapping("/tesst")
    public Map<String,Object> test(HttpServletRequest request) {
        Map<String, Object> map = new HashMap<>();
        String token = request.getHeader("token");//请求头上带参数
        DecodedJWT tokenInfo = JWTUtils.getTokenInfo(token);//验证令牌
        System.out.println("用户id"+ tokenInfo.getClaim("id").asString());
        System.out.println("用户name"+ tokenInfo.getClaim("name").asString());
        map.put("state",true);
        map.put("msg","请求成功！");
        return map;
    }

postman请求