0
0

【JWT】解密JWT：让您的Web应用程序更安全、更高效的神秘令牌

🥳🥳Welcome Huihui's Code World ! !🥳🥳

接下来看看由辉辉所写的关于JWT+ElementUI的相关操作吧

一.JWT是什么

    JWT是指JSON Web Token，是用于在网络应用间安全地传递信息的一种基于JSON的简洁、自包含的标准。JWT通常由三部分组成：头部（Header），载荷（Payload）和签名（Signature）

🔺头部通常包含了令牌的类型和所使用的加密算法

 {"typ":"JWT","alg":"HS256"}
      这个json中的typ属性，用来标识整个token字符串是一个JWT字符串；它的alg属性，用来说明这个JWT签发的时候所使用的签名和摘要算法
      typ跟alg属性的全称其实是type跟algorithm，分别是类型跟算法的意思。之所以都用三个字母来表示，也是基于JWT最终字串大小的考虑，
      同时也是跟JWT这个名称保持一致，这样就都是三个字符了…typ跟alg是JWT中标准中规定的属性名称

🔺载荷包含了一些声明（claims），例如用户的身份信息、权限等

❗❗注意：

{"sub":"123","name":"Tom","admin":true}
      payload用来承载要传递的数据，它的json结构实际上是对JWT要传递的数据的一组声明，这些声明被JWT标准称为claims，
      它的一个“属性值对”其实就是一个claim(要求)，
      每一个claim的都代表特定的含义和作用     

      注1：英文“claim”就是要求的意思
      注2：如上面结构中的sub代表这个token的所有人，存储的是所有人的ID；name表示这个所有人的名字；admin表示所有人是否管理员的角色。
           当后面对JWT进行验证的时候，这些claim都能发挥特定的作用
      注3：根据JWT的标准，这些claims可以分为以下三种类型：
           A. Reserved claims(保留)
              它的含义就像是编程语言的保留字一样，属于JWT标准里面规定的一些claim。JWT标准里面定义好的claim有：
              iss(Issuser)：代表这个JWT的签发主体； 
              sub(Subject)：代表这个JWT的主体，即它的所有人； 
              aud(Audience)：代表这个JWT的接收对象； 
              exp(Expiration time)：是一个时间戳，代表这个JWT的过期时间； 
              nbf(Not Before)：是一个时间戳，代表这个JWT生效的开始时间，意味着在这个时间之前验证JWT是会失败的； 
              iat(Issued at)：是一个时间戳，代表这个JWT的签发时间； 
              jti(JWT ID)：是JWT的唯一标识。 
           
           B. Public claims，略（不重要）

           C. Private claims(私有)
              这个指的就是自定义的claim，比如前面那个示例中的admin和name都属于自定的claim。这些claim跟JWT标准规定的claim区别在于：JWT规定的claim，
              JWT的接收方在拿到JWT之后，都知道怎么对这些标准的claim进行验证；而private claims不会验证，除非明确告诉接收方要对这些claim进行验证以及规则才行

              按照JWT标准的说明：保留的claims都是可选的，在生成payload不强制用上面的那些claim，你可以完全按照自己的想法来定义payload的结构，不过这样搞根本没必要：
              第一是，如果把JWT用于认证， 那么JWT标准内规定的几个claim就足够用了，甚至只需要其中一两个就可以了，假如想往JWT里多存一些用户业务信息，
              比如角色和用户名等，这倒是用自定义的claim来添加；第二是，JWT标准里面针对它自己规定的claim都提供了有详细的验证规则描述，
              每个实现库都会参照这个描述来提供JWT的验证实现，所以如果是自定义的claim名称，那么你用到的实现库就不会主动去验证这些claim

🔺JWT的签名部分用于验证该令牌的真实性和完整性

       签名是把header和payload对应的json结构进行base64url编码之后得到的两个串用英文句点号拼接起来，然后根据header里面alg指定的签名算法生成出来的。
       算法不同，签名结果不同。以alg: HS256为例来说明前面的签名如何来得到。
       按照前面alg可用值的说明，HS256其实包含的是两种算法：HMAC算法和SHA256算法，前者用于生成摘要，后者用于对摘要进行数字签名。这两个算法也可以用HMACSHA256来统称

JWT工作原理

  1. 用户通过提供有效的凭证（如用户名和密码）进行身份验证。
  2. 服务器验证凭证，并生成一个JWT。
  3. 服务器将该JWT发送给客户端。
  4. 客户端在后续的请求中将JWT放入请求的头部或参数中发送给服务器。
  5. 服务器验证JWT的签名和有效期，如果验证成功则处理请求

JWT验证过程

    它验证的方法其实很简单，只要把header做base64url解码，就能知道JWT用的什么算法做的签名，然后用这个算法，再次用同样的逻辑对header和payload做一次签名，
     并比较这个签名是否与JWT本身包含的第三个部分的串是否完全相同，只要不同，就可以认为这个JWT是一个被篡改过的串，自然就属于验证失败了。
接收方生成签名的时候必须使用跟JWT发送方相同的密钥
   

   注1：在验证一个JWT的时候，签名认证是每个实现库都会自动做的，但是payload的认证是由使用者来决定的。因为JWT里面可能会包含一个自定义claim，
        所以它不会自动去验证这些claim，以jjwt-0.7.0.jar为例：
        A 如果签名认证失败会抛出如下的异常：
          io.jsonwebtoken.SignatureException: JWT signature does not match locally computed signature. JWT validity cannot be asserted and should not be trusted.
       即签名错误，JWT的签名与本地计算机的签名不匹配 
        B JWT过期异常
          io.jsonwebtoken.ExpiredJwtException: JWT expired at 2017-06-13T11:55:56Z. Current time: 2017-06-13T11:55:57Z, a difference of 1608 milliseconds.  Allowed

   注2：认证失败，返回401 Unauthorized响应

   注3：认证服务作为一个Middleware HOOK 对请求进行拦截，首先在cookie中查找Token信息，如果没有找到，则在HTTP Authorization Head中查找

JWT刷新

▲登陆成功后，将生成的JWT令牌通过响应头返回给客户端
▲WEB APP项目每次请求后台数据时(将JWT令牌从请求头中带过来)，
⚪验证通过，刷新JWT，并保存在响应头返回给客户端，有效时间30分钟

 JwtFilter

  注1：修改CorsFilter添加允许的新的请求头“jwt”
  注2：原来在默认的请求上， 浏览器只能访问以下默认的 响应头
       Cache-Control
       Content-Language
       Content-Type
       Expires
       Last-Modified
       Pragma
       如果想让浏览器能访问到其他的 响应头的话 需要在服务器上设置 Access-Control-Expose-Headers
       Access-Control-Expose-Headers : 'jwt' 

       // CorsFilter 允许客户端，发一个新的请求头jwt
       resp.setHeader("Access-Control-Allow-Headers", "Origin,X-Requested-With, Content-            Type, Accept, jwt");

  注3：axios从响应头获得jwt令牌并保存到vuex
       这里有个问题如何获得项目中Vue的根实例，解决方案：修改main.js
       window.vm = new Vue({...});

二.为什么要使用JWT

    JWT使用基于密钥的签名算法来验证其真实性，因此只有持有密钥的服务器才能正确地生成和验证JWT。这样可以确保JWT在传输过程中不会被篡改。由于JWT是自包含的，服务器可以仅使用JWT本身就可以进行验证，无需查找数据库或其他存储。这使得JWT成为一种轻量且高效的身份验证和授权解决方案**【JWT的精髓在于：“去中心化”，数据是保存在客户端的】**
  1. 简化的身份验证：JWT可以在用户身份验证后生成并传递给客户端，客户端将其存储，以便后续的请求可以使用它。相比于传统的基于会话或令牌的身份验证方式，JWT的自包含特性使得服务器不需要在后端存储会话数据或在数据库中查找令牌。这使得服务器更加轻量级且可扩展。
  2. 跨域通信：由于JWT是基于标准的JSON格式，它可以在不同的域名之间进行安全的跨域通信。这对于构建分布式的微服务架构或使用前后端分离的应用特别有用。
  3. 安全性：JWT使用密钥对令牌进行签名，确保令牌在传输过程中不会被篡改。由于令牌是由服务器生成的，并且只有服务器能够验证签名，因此JWT具有较高的安全级别，能够有效地防止钓鱼、中间人攻击和数据篡改等安全威胁。
  4. 可扩展性：JWT的载荷部分可以存储自定义的声明信息，例如用户的角色、权限、过期时间等。这使得JWT非常灵活，可以根据需求添加额外的信息。同时，由于JWT是基于标准的JSON格式，很容易与现有的JSON工具库进行集成。
  5. 无状态性：由于JWT是自包含的，服务器不需要在每个请求中查询数据库或其他存储来验证令牌。这使得服务器可以无状态地处理请求，减轻了服务器的负担，提高了应用的可伸缩性和性能

三.JWT如何使用【工具类】

package com.zking.ssm.jwt;

import java.util.Date;
import java.util.Map;
import java.util.UUID;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

/**
 * JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter
 *
 */
public class JwtUtils {
    /**
     * JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟
     */
    public static final long JWT_WEB_TTL = 30 * 60 * 1000;

    /**
     * 将jwt令牌保存到header中的key
     */
    public static final String JWT_HEADER_KEY = "jwt";

    // 指定签名的时候使用的签名算法，也就是header那部分，jwt已经将这部分内容封装好了。
    private static final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;
    private static final String JWT_SECRET = "f356cdce935c42328ad2001d7e9552a3";// JWT密匙
    private static final SecretKey JWT_KEY;// 使用JWT密匙生成的加密key

    static {
        byte[] encodedKey = Base64.decodeBase64(JWT_SECRET);
        JWT_KEY = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    }

    private JwtUtils() {
    }

    /**
     * 解密jwt，获得所有声明(包括标准和私有声明)
     * 
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJwt(String jwt) {
        Claims claims = Jwts.parser()
                .setSigningKey(JWT_KEY)
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }

    /**
     * 创建JWT令牌，签发时间为当前时间
     * 
     * @param claims
     *            创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
     * @param ttlMillis
     *            JWT的有效时间(单位毫秒)，当前时间+有效时间=过期时间
     * @return jwt令牌
     */
    public static String createJwt(Map<String, Object> claims, 
            long ttlMillis) {
        // 生成JWT的时间，即签发时间 2021-10-30 10:02:00 -> 30 10:32:00
    
        long nowMillis = System.currentTimeMillis();

        
        //链式语法：
        // 下面就是在为payload添加各种标准声明和私有声明了
        // 这里其实就是new一个JwtBuilder，设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
                // 可以在未登陆前作为身份标识使用
                .setId(UUID.randomUUID().toString().replace("-", ""))
                // iss(Issuser)签发者，写死
                .setIssuer("wh")
                // iat: jwt的签发时间
                .setIssuedAt(new Date(nowMillis))
                // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
                // .setSubject("{}")
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(SIGNATURE_ALGORITHM, JWT_KEY)
                // 设置JWT的过期时间
                .setExpiration(new Date(nowMillis + ttlMillis));

        return builder.compact();
    }

    /**
     * 复制jwt，并重新设置签发时间(为当前时间)和失效时间
     * 
     * @param jwt
     *            被复制的jwt令牌
     * @param ttlMillis
     *            jwt的有效时间(单位毫秒)，当前时间+有效时间=过期时间
     * @return
     */
    public static String copyJwt(String jwt, Long ttlMillis) {
        //解密JWT，获取所有的声明（私有和标准）
        //old
        Claims claims = parseJwt(jwt);

        // 生成JWT的时间，即签发时间
        long nowMillis = System.currentTimeMillis();

        // 下面就是在为payload添加各种标准声明和私有声明了
        // 这里其实就是new一个JwtBuilder，设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
                // 可以在未登陆前作为身份标识使用
                //.setId(UUID.randomUUID().toString().replace("-", ""))
                // iss(Issuser)签发者，写死
                // .setIssuer("zking")
                // iat: jwt的签发时间
                .setIssuedAt(new Date(nowMillis))
                // 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
                // .setSubject("{}")
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(SIGNATURE_ALGORITHM, JWT_KEY)
                // 设置JWT的过期时间
                .setExpiration(new Date(nowMillis + ttlMillis));
        return builder.compact();
    }
}

这个工具类中包含了许多方法，下面就是关于这些方法的一一解释以及测试

  1. parseJwt(String jwt): 这个方法用于解析JWT令牌，返回一个Claims对象。Claims对象是一个映射，其中包含了JWT令牌的所有声明。这些声明可以是标准的（例如，发行者、过期时间等）或者是私有的（只在这个类中定义的）@Test public void test1() {// 生成JWT Map<String, Object> claims = new HashMap<String, Object>(); claims.put("username", "zss"); claims.put("age", 18); String jwt = JwtUtils.createJwt(claims, JwtUtils.JWT_WEB_TTL); System.out.println(jwt); Claims parseJwt = JwtUtils.parseJwt(jwt); for (Map.Entry<String, Object> entry : parseJwt.entrySet()) { System.out.println(entry.getKey() + "=" + entry.getValue()); } Date d1 = parseJwt.getIssuedAt(); Date d2 = parseJwt.getExpiration(); System.out.println("令牌签发时间：" + sdf.format(d1)); System.out.println("令牌过期时间：" + sdf.format(d2)); }
  2. createJwt(Map<String, Object> claims, long ttlMillis): 这个方法用于创建一个新的JWT令牌。首先，它使用传入的claims参数和当前时间来创建一个JwtBuilder对象，然后设置JWT的签名算法和密钥，最后设置JWT的过期时间。返回的是生成的JWT字符串@Test public void test2() {// 解析oldJwt String newJwt="eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ3aCIsImV4cCI6MTY5NzE3OTE0OSwiaWF0IjoxNjk3MTc3MzQ5LCJhZ2UiOjE4LCJqdGkiOiJkZTU4YjFjNTI3ODI0OTZiYmY1NjJjZGQzNmFhMGMyZiIsInVzZXJuYW1lIjoienNzIn0.ClAIgMT-6QjqUTqPp1vTZIA2uAHKzh6B6bKHhtIUcN0" ; String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ4dyIsImV4cCI6MTY5NzExNjYyMSwiaWF0IjoxNjk3MTE0ODIxLCJhZ2UiOjE4LCJqdGkiOiI2NGUxZGYzMzRmYjI0ZjJkOWQ4MGVkMGUwYjBiYThiNSIsInVzZXJuYW1lIjoienNzIn0.2QpKTmydrVHjUfwTHP-iewiKcszEx6PlIJp4k5EDJNU" ; Claims parseJwt = JwtUtils.parseJwt(newJwt); for (Map.Entry<String, Object> entry : parseJwt.entrySet()) { System.out.println(entry.getKey() + "=" + entry.getValue()); } Date d1 = parseJwt.getIssuedAt(); Date d2 = parseJwt.getExpiration(); System.out.println("令牌签发时间：" + sdf.format(d1)); System.out.println("令牌过期时间：" + sdf.format(d2)); }
  3. copyJwt(String jwt, Long ttlMillis): 这个方法用于复制一个已存在的JWT令牌，并设置新的有效期。它首先调用parseJwt方法来解析原始的JWT令牌并获取其Claims对象，然后创建一个新的JwtBuilder对象，设置相同的claims、签名算法和密钥，但是设置新的过期时间。最后，返回新生成的JWT字符串
@Test
    public void test3() {// 复制jwt，并延时30秒
        String oldJwt="eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ3aCIsImV4cCI6MTY5NzE3OTE0OSwiaWF0IjoxNjk3MTc3MzQ5LCJhZ2UiOjE4LCJqdGkiOiJkZTU4YjFjNTI3ODI0OTZiYmY1NjJjZGQzNmFhMGMyZiIsInVzZXJuYW1lIjoienNzIn0.ClAIgMT-6QjqUTqPp1vTZIA2uAHKzh6B6bKHhtIUcN0" ;
//        String oldJwt = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjI5MDMzNjAsImlhdCI6MTU2MjkwMTU2MCwiYWdlIjoxOCwianRpIjoiZDVjMzE4Njg0MDcyNDgyZDg1MDE5ODVmMDY3OGQ4NjkiLCJ1c2VybmFtZSI6InpzcyJ9.XDDDRRq5jYq5EdEBHtPm7GcuBz4S0VhDTS1amRCdf48";
        String jwt = JwtUtils.copyJwt(oldJwt, JwtUtils.JWT_WEB_TTL);
        Claims parseJwt = JwtUtils.parseJwt(jwt);
        for (Map.Entry<String, Object> entry : parseJwt.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
        Date d1 = parseJwt.getIssuedAt();
        Date d2 = parseJwt.getExpiration();
        System.out.println("令牌签发时间：" + sdf.format(d1));
        System.out.println("令牌过期时间：" + sdf.format(d2));
    }

**

SIGNATURE_ALGORITHM

: 这个静态常量定义了用于签名JWT的算法。这是一个固定的值，不能更改。这个值通常是"HS256"。**

**

JWT_SECRET

: 这个静态常量存储了用于签名JWT的密钥。在静态初始化块中，这个密钥被从Base64编码的字符串解码为SecretKey对象**

四.案例演示【JWT的强大】

1.没有用jwt

只要我不退出登录，那么我可以开无数个窗口进入主页

2.用了jwt

web.xml

  <!--CrosFilter跨域过滤器-->
  <filter>
    <filter-name>corsFilter</filter-name>
    <filter-class>com.zking.ssm.util.CorsFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>corsFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

过滤器（跨域问题）

package com.zking.ssm.util;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 配置tomcat允许跨域访问
 * 
 * @author Administrator
 *
 */
public class CorsFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        // Access-Control-Allow-Origin就是我们需要设置的域名
        // Access-Control-Allow-Headers跨域允许包含的头。
        // Access-Control-Allow-Methods是允许的请求方式
        httpResponse.setHeader("Access-Control-Allow-Origin", "*");// *,任何域名
        httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
        
        //允许客户端发一个新的请求头jwt
        httpResponse.setHeader("Access-Control-Allow-Headers","responseType,Origin,X-Requested-With, Content-Type, Accept, jwt");
        //允许客户端处理一个新的响应头jwt
        httpResponse.setHeader("Access-Control-Expose-Headers", "jwt,Content-Disposition");
        
        //httpResponse.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
        //httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE");
        
        // axios的ajax会发两次请求，第一次提交方式为：option，直接返回即可
        if ("OPTIONS".equals(req.getMethod())) {
            return;
        }
        filterChain.doFilter(servletRequest, servletResponse);
    }
    @Override
    public void destroy() {

    }
}

JWT验证过滤器

package com.zking.ssm.jwt;

import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import io.jsonwebtoken.Claims;

/**
 * * JWT验证过滤器，配置顺序 ：CorsFilter-->JwtFilter-->struts2中央控制器
 * 
 * @author Administrator
 *
 */

public class JwtFilter implements Filter {

    // 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
    private static String EXCLUDE = "^/user/userLogin?.*$";

    private static Pattern PATTERN = Pattern.compile(EXCLUDE);

    private boolean OFF = false;// true关闭jwt令牌验证功能

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        //获取当前请求路径。只有登录的请求路径不进行校验之外，其他的URL请求路径必须进行JWT令牌校验
        //http://localhost:8080/ssh2/bookAction_queryBookPager.action
        //req.getServletPath()==/bookAction_queryBookPager.action
        String path = req.getServletPath();
        if (OFF || isExcludeUrl(path)) {// 登陆直接放行
                chain.doFilter(request, response);
                return;
        }

        // 从客户端请求头中获得令牌并验证
        //token=头.载荷.签名
        String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
        Claims claims = this.validateJwtToken(jwt);
        //在这里请各位大哥大姐从JWT令牌中提取payload中的声明部分
        //从声明部分中获取私有声明
        //获取私有声明中的User对象 -> Modules
        Boolean flag=false;
        if (null == claims) {
            // resp.setCharacterEncoding("UTF-8");
            resp.sendError(403, "JWT令牌已过期或已失效");
            return;
        } else {
            
            //1.获取已经解析后的payload（私有声明）
            //2.从私有声明中当前用户所对应的权限集合List<String>或者List<Module>
            //3.循环权限(Module[id,url])
            // OK,放行请求 chain.doFilter(request, response);
            // NO,发送错误信息的JSON
            // ObjectMapper mapper=new ObjectMapper()
            // mapper.writeValue(response.getOutputStream(),json)
            
            String newJwt = JwtUtils.copyJwt(jwt, JwtUtils.JWT_WEB_TTL);
            resp.setHeader(JwtUtils.JWT_HEADER_KEY, newJwt);
            chain.doFilter(request, response);
        }
    }

    /**
     * 验证jwt令牌，验证通过返回声明(包括公有和私有)，返回null则表示验证失败
     */
    private Claims validateJwtToken(String jwt) {
        Claims claims = null;
        try {
            if (null != jwt) {
                //该解析方法会验证：1）是否过期 2）签名是否成功
                claims = JwtUtils.parseJwt(jwt);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return claims;
    }

    /**
     * 是否为排除的URL
     * 
     * @param path
     * @return
     */
    private boolean isExcludeUrl(String path) {
        Matcher matcher = PATTERN.matcher(path);
        return matcher.matches();
    }

    // public static void main(String[] args) {
    // String path = "/sys/userAction_doLogin.action?username=zs&password=123";
    // Matcher matcher = PATTERN.matcher(path);
    // boolean b = matcher.matches();
    // System.out.println(b);
    // }

}

state.js

mutations.js

getters.js

请求标头

好啦，今天的分享就到这了，希望能够帮到你呢！😊😊

标签： 安全
本文转载自: https://blog.csdn.net/m0_74315688/article/details/133787263
版权归原作者 是辉辉啦 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【JWT】解密JWT：让您的Web应用程序更安全、更高效的神秘令牌”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航