JWT的认识学习

什么是JWT

JWT简称json、web、token,通过Json形式作为web中的令牌，用户各方是之间安全的将信息作为json对象进行传输，在数据传输过程中还可以完成数据加密、签名等相关处理。
授权 一旦用户登录，每个后续的请求将包括JWT，从而允许用户访问令牌允许访问路由，服务和资源。
信息交换因为可以对JWT进行签名(例如，使用公钥/私钥)，这样我们就可以确定发件人是他们所说的发件人。签名是使用标头和有效负载计算的，因此您还可以验证内同是否被篡改。

JWT的认证

认证流程
1.首先是前端web表单将自己的用户名和密码发送到后端接口，这一过程一般是post、http。建议的方式是通过SSL加密的传输（https协议），从而避免敏感信息被嗅到。
2.后端对用户名和密码成功后，将用户的id等其他信息作为JWT PayLoad(负载),将其与头部分别进行Base64位编码拼接成签名。形成JWT（token），JWT就是ｘｘｘ．ｘｘｘ．ｘｘｘ的字符串。ｈｅａｄ．ｐａｌｏａｄ．ｓｉｎｇｕｒａｔｅｒ。
3.后端将ｊｗｔ字符串作为登录成功的结果返回给前端，前端将结果保存到localStorage或 SessionStorage上，退出登录前端删除保存的jwt即可。
4.前端在每次请求时将JWT放入http Header中的Authorization位。（解决XSS 跨站脚本攻击 和XSRF问题 跨站点请求伪造）HEADER
5.后端检查是否存在，JWT的有效性，例如，检查签名是否正确；检查token是否过期，检查token 的接受方是否自己(可选)
6.验证通过后后端使用jwt中包含的用户信息进行其他逻辑操作，返回相应的结果。
jwt优势
简洁：可以通过URL、post参数或者HTTP header发送，因为数据量小，传输速度也很快。
自包含：负载中包含了所有用户的所有信息，避免多次查询数据库。
因为token是以json加密的形式保存在客户端，所以jwt是跨语言性，原则上web形式都支持。
不需要在服务端保存会话信息，特别适用与分布式微服务。

JWT结构

令牌的组成1.标头(Header)2.有效载荷（payload）3.签名(Signature)
Header.paload.Signature形式。
1.Header标头通常有两部分组成令牌类型(JWT)和签名算法，例如HMAC SHA256或RSA。他会使用Base64 编码组成JWT结构的第一部分。

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

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

{
	“sub”：“12345678”,
	"name":"aw,
	"admin":true
}

我们在这里面存储的是一些id、名字、角色，切忌这里面不能存储一些敏感词语，例如密码……因为Base64可以进行解码。
3.Signature 前端需要进行解码才能获得信息。Signature需要使用编码header和paload及我们提供的一个密钥，然后使用header中指明的算法(HS256)进行签名，签名的作用是保证JWT没有被篡改过。

签名的目的 实际上是对头部以及负载内容进行签名，防止被篡改。

这里我们说一下我们可能会用到的包

<dependencies>
        <!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.13.0</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.4</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.1</version>
        </dependency>

    </dependencies>

程序一

这样的就是我们创建token和解析token

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import jdk.nashorn.internal.ir.debug.JSONWriter;
import org.junit.Test;

import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;

public class T1 {
    @Test
   public void tt1(){
       Map<String, Object> map = new HashMap<>();
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.MINUTE,10);//令牌有效的时间设置 这里使用的分钟

        String token = JWT.create()
                .withHeader(map)//header 这个header都是一样的可写可不写
                .withClaim("userId", 10)//payload
                .withClaim("username", "阿威")
                .withExpiresAt(instance.getTime())//指定令牌的有效时间
                .sign(Algorithm.HMAC256("@GH$%#HJ&@"));//添加签名 指定的算法
        System.out.println(token);
    }

    @Test
  public  void t2(){
        //创建签名解析对象
        JWTVerifier build = JWT.require(Algorithm.HMAC256("@GH$%#HJ&@")).build();
        //通过token进行签名解析
        DecodedJWT verify = build.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTU1MzU2MjcsInVzZXJJZCI6MTAsInVzZXJuYW1lIjoi6Zi_5aiBIn0.kFqszvI0PV4C3dUukw7QV67LesUWwah14n1fGQ96ezA");
        //获取解析后相对应的值
        System.out.println(verify.getClaim("userId"));
        System.out.println(verify.getClaim("username"));

        System.out.println(verify.getExpiresAt());
        System.out.println(verify.getHeader());

    }
}

程序二

工具类

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Calendar;
import java.util.Map;

public class JWTUtils {
    //授权码
    private static final String SING="@^DH%#($%H";

    public static String getToken(Map<String,String> map){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.MINUTE,10);
        //创建JWT
        JWTCreator.Builder builder = JWT.create();

        //payload 通过foreach进行传递
        map.forEach((k,v)->{
            builder.withClaim(k,v);
        });
        //指定签名
        String toKen = builder.withExpiresAt(instance.getTime()).sign(Algorithm.HMAC256(SING));
        return toKen;

    }

    /**
     *验证toKen 同时返回用户信息
     * @param toKen
     */
    public static DecodedJWT verify(String toKen){
        return JWT.require(Algorithm.HMAC256(SING)).build().verify(toKen);
    }

}

程序三

拦截器 在springboot中的使用

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
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;

//拦截器
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","算法不一致");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg","token无效");
        }
        //没有成功我们就需要把错误信息响应到上面
        map.put("state",false);//设置状态
        //将map作为json jackson
        String json = new ObjectMapper().writeValueAsString(token);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("***")//其他保护接口
                .excludePathPatterns("/user/**");//所有的用户方形
    }
}