深入解析JWT，从根源上保障你的网络安全

💥 序言

  行走江湖多年，多次辗转面试，JWT是经常被问到的，这也验证了企业对网络安全的重视程度，本篇博客以通俗简洁的图文讲解方式，让JWT印在你的脑海里，在以后企业开发还是面试都能很好的帮到你。

🌾 JWT是什么？

  JWT（JSON Web Token）是一种轻量级的身份验证和授权机制，通常用于在Web应用程序中进行身份验证和授权。它是一种基于JSON的开放标准，可以用于在不同的应用程序之间共享信息，例如用户身份验证信息和授权信息。JWT由三个部分组成：头部、有效载荷、签名。头部包含了JWT的类型和签名算法等信息。有效载荷包含了用户身份验证信息和其他相关信息。签名用于验证JWT的完整性和真实性。JWT通常以一种安全的方式存储在客户端，例如在浏览器的Cookie中或localStorage中。当用户与应用程序进行交互时，可以使用JWT来验证用户的身份和授权。

🍉 为什么使用JWT？

传统模式

传统的认证方式大多基于cookie，会有以下几个弊端：

• 应用在用户认证后需要在服务端记录认证信息，通常这些信息保存在内存中，但随着认证用户数量的增加，将导致服务器负担增加；
• 使用session来进行用户标识，可能会存在安全风险，例如CSRF攻击，并且不易于应用扩展；
• 在前后端解耦的系统中，使用session会增加部署的复杂性，每次请求都需要转发多次，并且如果用户数量较多，会增加服务器负担。
• sessionid信息不够丰富，不易于扩展。如果应用部署在多个节点上，还需要实现session共享机制，不便于集群应用。

JWT模式

基于JWT的方式可以有效解决XSS和XSRF问题，不需要考虑session共享以及跨域机制！
XSS参考地址：https://blog.csdn.net/qq_44857938/article/details/118034947
XSRF参考地址：https://blog.csdn.net/weixin_38597669/article/details/90694407
session共享参考地址：https://blog.csdn.net/huxiang19851114/article/details/114607162

• 应用在用户认证后不需要把用户信息保存在内存中，而是将用户信息编码成JWT TOKEN，返回
• 前端可以把token保存在localStorage或sessionStorage中,退出登录时删除Token
• 每次请求时，前端应把Token放在HTTP请求Header的Authorization字段中，并且后端验证Token的有效性和正确性
• 如果Token被验证通过，后端可以根据Token中的用户信息进行其他权限或业务操作，并返回相应的结果

🍓 组成结构

JWT令牌由Header、Payload、Signature三部分组成，每部分字符串中间用. 拼接。JWT令牌的最终格式是这样的： 第一部分.第二部分.第三部分。

• Header（标头），通常由两部分组成：令牌的类型 和 所用的加密算法，然后将该JSON对象数据进行Base64 URL编码，得到的字符串就是JWT令牌的第一部分。
• Payload（载荷），有效数据存储区，主要定义自定义字段和内置字段数据。通常会把用户信息和令牌过期时间放在这里，同样也是一个JSON对象，里面的key和value可随意设置，然后经过Base64 URL编码后得到JWT令牌的第二部分
• Signature（签名）, 使用头部Header定义的加密算法，对前两部分Base64编码拼接的结果进行加密，加密时的秘钥服务私密保存，加密后的结果在通过Base64Url编码得到JWT令牌的第三部分。

🍎 基础验证

我们通过代码生成这三部分，来验证jwt的组成，以及查看jwt的生成过程！
引入依赖

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

package com.example.mydreams.jwt;

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

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

public class JwtDemo {
    public static void main(String[] args) {
        String token = generateJwtToken();
        System.out.println("生成的JWT的Token为:");
        System.out.println(token);
        //创建验证对象
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("Periqi")).build();
        DecodedJWT verify = jwtVerifier.verify(token);
        System.out.println("验证传入的用户信息为:userId:"+verify.getClaim("userId")+",username:"+verify.getClaim("username")+",过期时间:"+verify.getExpiresAt());
    }

    //生成JWTtoken
    public static String generateJwtToken() {
        HashMap<String,Object> map = new HashMap();
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,1000);
        String token = JWT.create()
                .withHeader(map)    //Header（可以不用设置，因为Header有默认值：{"alg":"HS256", "typ":"JWT" }）
                .withClaim("userId",100)  //payload
                .withClaim("username","码农佩奇") //payload
                .withExpiresAt(instance.getTime())  //指定令牌过期时间
                .sign(Algorithm.HMAC256("Periqi"));  //Signature
        return token;
    }
}

程序运行结果:
生成的JWT的Token为:
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3MDE0NDI0OTYsInVzZXJJZCI6MTAwLCJ1c2VybmFtZSI6IueggeWGnOS9qeWlhyJ9.qAik5UQsDV_mjr10C3cyCqpLBvhI_IXZDRczQQy2mCk
验证传入的用户信息为:userId:100,username:"码农佩奇",过期时间:Fri Dec 01 22:54:56 CST 2023

此处有段代码需要注意一下。理解这个，对于JWT也就理解差不多了。
生成Token
.sign(Algorithm.HMAC256(“Periqi”)); //Signature
我们指定了了签名算法，同时可以传入私钥Periqi字符串
验证的时候，我们同样根据秘钥是生成JWT校验对象来校验token
JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(“Periqi”)).build();
DecodedJWT verify = jwtVerifier.verify(token);

验证失败异常：

• SignatureVerificationException 签名不一致异常
• TokenExpiredException 令牌过期异常
• AlgorithmMismatchException 算法不匹配异常
• InvalidClaimException 失效的payload异常

🍑 企业实战

本次，我们做一个springBoot+JWT基础的案例，不涉及数据库，主要让你明白JWT在企业中的使用流程。
我们的思路是这样的，首先用户输入账号密码登录系统->拦截器->捕获请求头的token,验证用户身份->成功则放行
失败则走登录->需要查询数据库拿用户信息（本次省略）->查到用户信息生成token返回前端，前端下次发请求，请求头带token即可。

引入依赖

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <java.version>17</java.version>
    </properties>
       <!--引入jwt-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

自定义JWT拦截器

package com.example.mydreams.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;

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{
            //此处校验失败会进入异常处理
             JWT.require(Algorithm.HMAC256("peiqi")).build().verify(token);
             return true;
        }catch(Exception e){
            e.printStackTrace();
            map.put("state",false);
            map.put("message","请求失败");
        }
        response.setContentType("text/html;charset=UTF-8");
        response.getWriter().write("请先登录系统！");
        return false;
    }
}

配置拦截器让它生效

package com.example.mydreams.controller;

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("/api/**")//拦截（其他token验证）
                .excludePathPatterns("user/login");//所有用户都放行(登录接口不放行,无法进行登录)
    }
}

编写请求

package com.example.mydreams.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@Slf4j
public class LoginController {


    @GetMapping("user/login")
    public Map<String,Object> login(User user){
        Map<String,Object> map = new HashMap<>();
        //此处应该查询数据库 省略
        if(user!=null&&user.getName().equals("码农佩奇")){
            //认证成功后，生成JWT令牌
            Map<String,String> payload = new HashMap<>();
            payload.put("id","11");
            payload.put("name","码农佩奇");
            String jwtToken = createJwtToken(payload);
            map.put("state",true);
            map.put("message","认证成功");
            map.put("token",jwtToken);//响应jwtToken
        }else{
            map.put("state",false);
            map.put("message","认证失败");
        }
        return map;
    }

    @PostMapping("api/test")
    public Map<String,Object> test(HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        String token = request.getHeader("token");
        try{
            DecodedJWT verify = JWT.require(Algorithm.HMAC256("peiqi")).build().verify(token);
            log.info("用户id:[{}]",verify.getClaim("id").asString());
            log.info("用户name:[{}]",verify.getClaim("name").asString());
            map.put("state",true);
            map.put("message","请求成功");
            return map;
        }catch(Exception e){
            e.printStackTrace();
            map.put("state",false);
            map.put("message","请求失败");
        }
        return map;
    }

    public static String createJwtToken(Map<String,String> map){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,300);
        //生成令牌
        JWTCreator.Builder builder = JWT.create();
        for(Map.Entry<String,String> entry : map.entrySet())
            builder.withClaim(entry.getKey(),entry.getValue());
        builder.withExpiresAt(instance.getTime());
        return builder.sign(Algorithm.HMAC256("peiqi"));
    }
}

验证




图解流程

🌽 总结

1. JWT结构 JWT由三部分组成，分别是头部、载荷和签名。头部用于描述签名算法和类型，载荷用于存储用户信息和过期时间等，签名用于验证Token的合法性和完整性。
2. JWT优点 相比于传统的Session认证方式，JWT具有以下优点：无状态、可扩展、安全性高、跨平台、可自定义负载等。
3. JWT使用场景 JWT适用于前后端分离的Web应用，如SPA单页面应用，APP等场景下。同时，JWT也可以用于微服务架构中的服务认证和授权。
4. JWT安全性 JWT的安全性主要取决于生成的密钥的安全性，一旦密钥泄漏，则可能导致用户身份被恶意冒用。因此，应该使用强密钥和SSL/TLS协议来保障安全性。

相比于传统的Session认证方式，JWT有以下缺点：不支持注销、Token过期机制存在缺陷、Token数量过多可能导致性能问题等。此外，不同的JWT实现方式也可能存在一些问题，需要谨慎选择。

总之，JWT是一种先进的身份认证和授权方式，可以在很多场景下代替传统的Session认证方式。但是，在使用JWT的过程中，需要注意安全性和性能问题。