JWT令牌

最新推荐文章于 2024-03-10 22:06:45 发布
最新推荐文章于 2024-03-10 22:06:45 发布
阅读量737 收藏 1
点赞数
分类专栏： 常见概念 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51106567/article/details/131544700
版权

5. JWT令牌

5.1 JWT令牌概念

JWT (JSON Web Token) 是一种用于在网络应用程序之间安全传输信息的开放标准（RFC 7519）。JWT 令牌是一种轻量级的令牌，它包含了一些关键信息，比如用户身份、权限等，并使用数字签名进行验证，以确保该信息在传输过程中不被篡改或伪造。

5.2 JWT令牌构成

JWT 令牌的格式是由 RFC 7519 标准规定的，由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部包含了令牌类型和加密算法等信息，载荷包含了需要传输的信息，例如用户 ID、角色、权限等，签名则是将头部和载荷进行加密后得到的结果，用于验证令牌是否被篡改。

使用 JWT 令牌的好处是可以方便地在不同的应用程序或服务之间共享用户身份信息，而无需每次都进行身份验证。此外，因为 JWT 令牌是基于标准的 JSON 格式，因此易于使用和传输。

假设一个网站需要验证用户身份并授权用户访问某些受保护的资源。使用 JWT 令牌，用户登录后，服务器会生成一个包含用户信息的 JWT 令牌，然后将该令牌返回给客户端。如下所示：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWQiOiIxMjM0NTY3ODkwIiwicm9sZXMiOlsiYWRtaW4iLCJ1c2VyIl19.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
  1. 头部（Header）：eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

- alg 参数表示使用的加密算法，这里是 HMAC-SHA256 算法。

- typ 参数表示令牌类型，这里是 JWT。

{
 "alg": "HS256",
 "typ": "JWT"
}
  1. 载荷（Payload）：eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWQiOiIxMjM0NTY3ODkwIiwicm9sZXMiOlsiYWRtaW4iLCJ1c2VyIl19

-iss: jwt签发者

-sub: jwt所面向的用户

-aud: 接收jwt的一方

-exp: jwt的过期时间，这个过期时间必须要大于签发时间

-nbf: 定义在什么时间之前，该jwt都是不可用的.

-iat: jwt的签发时间

-jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

{
 "sub": "1234567890",//ID
 "name": "John Doe", //角色
 "iat": 1516239022 //权限
}
  1. 签名（Signature）：SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

签名（Signature）部分是对头部和载荷进行数字签名(base64加密)生成的，例如：

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

5.3 JWT令牌的基本使用

5.3.1 基本思路

在实际使用中，通常会使用现有的 JWT 库来生成和解析 JWT 令牌，这些库已经实现了 RFC 7519 标准中的格式和规范，因此可以方便地使用这些库来生成和解析 JWT 令牌。本文主要介绍java-jwt，jjwt等这两种库

基本思路：要分为两种页面，登录页面和其他页面，登录页面用于获取token，只有登录了之后才能访问其他页面。登录之后获取到的token会返回给客服端（或者说前端），下一次（其他页面）发起请求时将token添加到请求头，后端设置拦截器判断请求头中的token是否有值（有值就进一步判断值是否正确），如果没有则说明未登录，即没有权限，有值且正确了就放行。值得一提的是登录页面的请求不用拦截，因为需要获取token。通过解析 JWT 令牌并验证签名，可以获取到载荷部分存储的用户的身份和权限，从而判断是否放行。

5.3.2 java-jwt实现JWT

官网:https://github.com/auth0/java-jwt

以下是一个使用 Java 编写的基本 JWT 登录示例，该示例使用 java-jwt库来生成和解析 **JWT **令牌

  1. 首先，需要在项目中添加 java-jwt依赖
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>4.0.0</version> <!--我使用这个版本时报错了-->
    <version>3.4.0</version>
</dependency>
  1. 然后定义一个简单的用户类 User：
@Data
public class User {
    private Long id;
    private String username;
    private String password;
}
  1. 将JWT主要操作封装
package com.zhaoxi.test.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.stereotype.Component;

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

@Component
public class JwtUtil {
    /** 盐值*/
    private static final String SING="LIUYISHOU@Token666";

    //生成令牌
    public static String getToken(Map<String,String> map){
        //获取日历对象
        Calendar calendar=Calendar.getInstance();
        //默认7天过期
        calendar.add(Calendar.DATE,7);
        //新建一个JWT的Builder对象
        JWTCreator.Builder builder = JWT.create();
        //将map集合中的数据设置进payload载荷
        map.forEach((k,v)->{
            builder.withClaim(k, v);
        });
        //设置过期时间和签名
        String sign = builder.withExpiresAt(calendar.getTime()).sign(Algorithm.HMAC256(SING));
        return sign;
    }
    /**
     * 验签并返回DecodedJWT
     * @param token  令牌
     */
    public static DecodedJWT getToken(String token) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(SING);
            DecodedJWT jwt = JWT.require(algorithm).build().verify(token);
            System.out.println("解析令牌成功：" + jwt.getClaims());
            return jwt;
        } catch (Exception ex) {
            System.out.println("解析令牌失败：" + ex.getMessage());
        }
        return null;
    }
}
  1. 定义Controller层接口，其中使用 java-jwt 库生成 JWT 令牌：
package com.zhaoxi.test.controller;

import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.zhaoxi.test.pojo.User;
import com.zhaoxi.test.service.UserService;
import com.zhaoxi.test.utils.JwtUtil;
import com.zhaoxi.test.utils.R;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;

@RestController
@Slf4j
public class UserController {
    @Autowired
    private JwtUtil jwtUtil;
    @Autowired
    private UserService userService;

    @PostMapping("/user/login")//登录后返回token,拦截器不拦截
    public R login(@RequestBody User user){
            //打印输入的用户名和密码
            log.info("用户名：[{}]",user.getUsername());
            log.info("密码：[{}]",user.getPassword());
            //创建map，作为返回值
            HashMap<String, Object> map = new HashMap<>();
            try {
                User login = userService.login(user);
                //存储载荷声明参数map
                HashMap<String, String> plMap = new HashMap<>();
                plMap.put("username", login.getUsername());
                //生成JWT令牌
                String token = jwtUtil.getToken(plMap);
                log.info("token={}",token);
                //通过验证，将相关用户信息及token等存入R，用于返回
                map.put("token",token);
                new R(map,"cg");
            } catch (Exception e) {

            }
        return new R(map,"cg");
    }

    @PostMapping("/user/test")
    public R test(HttpServletRequest request){
        //处理自己的业务逻辑
        //获取请求头中携带的token
        String token = request.getHeader("token");
        //验证token，获取token中的相关信息,这里其实不用验证，因为拦截器已经验证了
        DecodedJWT verify = jwtUtil.getToken(token);
        log.info("用户名：[{}]",verify.getClaim("username").asString());
        log.info("密码：[{}]",verify.getClaim("password").asString());
        return new R("请求成功");

    }
}

service和mapper层忽略，

  1. 定义拦截器
package com.zhaoxi.test.interceptor;

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 com.zhaoxi.test.utils.JwtUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;

import java.util.HashMap;
@Slf4j
public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HashMap<String, Object> map = new HashMap<>();
        //获取存放在请求头中的token
        String token = request.getHeader("token");
        //这里仅仅只是判断有没有token，并没有判断token是否正确，所以详细判断可以之后添加
        log.info("tokenInterceptor={}",token);
        try {
            JwtUtil.getToken(token);   //验证令牌，验证通过则返回true
            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无效！");
        }

        //验证令牌不通过，返回false
        map.put("state",false);
        //将map转化为json，相应给前端
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}
  1. 配置拦截器
package com.zhaoxi.test.config;

import com.zhaoxi.test.interceptor.JWTInterceptor;
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) {
        System.out.println("拦截请求");
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/user/test")          //拦截user接口
                .excludePathPatterns("/user/login");    //放行login接口,login请求是设置jwt值的，不能拦截
    }
}

5.3.2 使用jjwt实现

官网:https://github.com/jwtk/jjwt

  1. 导依赖
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.11.5</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.11.5</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.11.5</version>
            <scope>runtime</scope>
        </dependency>
  1. JWT 工具类
package com.zhaoxi.test.utils;

import com.zhaoxi.test.pojo.User;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Component
public class JwtUtil {
    private SecretKey secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256);
    /**
     * 获得jwt，token
     */
    public String getToken(User user) {
        // 标头
        Map<String, Object> headMap = new HashMap<>();
        headMap.put("type", "JWT");
        headMap.put("alg", "HS256");
        // 自定义信息,payload载荷
        Map<String, Object> cliMap = new HashMap<>();
        cliMap.put("username", user.getUsername());
        cliMap.put("password", user.getPassword());
        // 过期时间
        long l = System.currentTimeMillis() + (1000 * 60 * 2);
        Date date = new Date(l);
        JwtBuilder jwtBuilder = Jwts.builder().setHeader(headMap)
                .setClaims(cliMap)
                .setExpiration(date);

        // 签名，这里有两种方法
        // 第一种，此方法要求key长度必须足够长，否则会报错
//        SecretKey secretKey = Keys.hmacShaKeyFor("esyrgfdfdfdf".getBytes());
//        String jwt = jwtBuilder.signWith(secretKey,SignatureAlgorithm.HS256).compact();
        // 第二种，建议采用此法方法

        String jwt = jwtBuilder.signWith(secretKey).compact();
        return jwt;
    }
    /**
     * 解析jwt，解析token
     */
    boolean verifyJwt(String token) {
        try{
            // 这里的secretKey必须和生成时用的secretKey一样
            Jwt parse = Jwts.parserBuilder().setSigningKey(secretKey).build().parse(token);
            Claims body = (Claims) parse.getBody(); //获取载荷
            Object name = body.get("username");
            Header header = parse.getHeader(); //获取头部
            Object type = header.get("type"); //加密类型
            // 还可以以下面这种方式解析jwt
            // Jws<Claims> claimsJws = Jwts.parserBuilder().setSigningKey(secretKey).build().parseClaimsJws(jwt);
            // Claims body = claimsJws.getBody();
            // JwsHeader header = claimsJws.getHeader();
            return true; //没有报错就说明解析成功
        }catch(Exception e){
            System.out.println("解析令牌失败：" + e.getMessage());
        }
        return false;
    }
}

其他部分省略

5.4 JWT创建异常

  • 令牌过期异常：ExpiredJwtException
  • 签名或jwt错误：SignatureException
  • 令牌过期异常：TokenExpiredException
  • 签名无效或key错误异常：SignatureVerificationException
  • 算法不匹配异常：AlgorithmMismatchException

The Token’s Signature resulted invalid when verified using the Algorithm: HmacSHA256，报此条错误可能是因为java-jwt依赖包与其他依赖冲突

5.5 常见签名算法

如下：

JWS算法描述
HS256HMAC256带有 SHA-256 的 HMAC
HS384HMAC384带有 SHA-384 的 HMAC
HS512HMAC512带有 SHA-512 的 HMAC
RS256RSA256带有 SHA-256 的 RSASSA-PKCS1-v1_5
RS384RSA384带有 SHA-384 的 RSASSA-PKCS1-v1_5
RS512RSA512带有 SHA-512 的 RSASSA-PKCS1-v1_5
ES256ECDSA256曲线 P-256 和 SHA-256 的 ECDSA
ES384ECDSA384具有曲线 P-384 和 SHA-384 的 ECDSA
ES512ECDSA512曲线 P-521 和 SHA-512 的 ECDSA
嗯兮
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JWT 生成Token及验证
01-22
JWT生成token及验证（过期时间）用于前后断分离，及APP认证，可结合redis使用也可单独使用。
JWT令牌详细解读
。。。。
07-05 2990
什么是JWT令牌 JWT是JSON Web Token的缩写，即JSON Web令牌，是一种自包含令牌。 JWT的使用场景： 一种情况是webapi，类似之前的阿里云播放凭证的功能 另一种情况是多web服务器下实现无状态分布式身份验证 JWT官网有一张图描述了JWT的认证过程 官网 地址 : https://jwt.io/ JWT的作用： JWT 最重要的作用就是对 token信息的防伪作用 JWT的原理： 一个JWT由三个部分组成：JWT头、有效载荷、签名哈希 最后由这三者组
JWT令牌技术
不能再留遗憾了的博客
03-10 1165
JWT令牌技术实现用户登录信息的验证
jwt令牌
姬凝霜
08-02 294
一、简介 JSON Web token简称JWT， 是用于对应用程序上的用户进行身份验证的标记。也就是说, 使用 JWTS 的应用程序不再需要保存有关其用户的 cookie 或其他session数据。此特性便于可伸缩性, 同时保证应用程序的安全。 在身份验证过程中, 当用户使用其凭据成功登录时, 将返回 JSON Web token, 并且必须在本地保存 (通常在本地存储中)。 每当用户要访问受保护的路由或资源 (端点) 时, 用户代理(user agent)必须连同请求一起发送 JWT, 通常在授权标头中
.NET Core 生成JWT令牌源码
最新发布
04-27
单点登录（SSO）：用户在登录一个应用程序后，可以通过JWT令牌在其他应用程序中进行身份验证，实现单点登录的效果。 在.NET Core中，可以使用Microsoft.IdentityModel.Tokens库来处理JWT。该库提供了一些类和方法...
jwthelper：JWT令牌生成器
02-24
JWT令牌生成器 生成私钥（jwt.salt）和jwt令牌的助手 该泊坞窗映像有助于快速创建私钥和JWT令牌。 可用版本 您可以通过“ 页面查看所有可从Docker Hub提取的图像。 以“更改类型”字词开头的Docker标记名称（例如...
jwt-decode, 解码JWT令牌；适用于浏览器应用程序.zip
10-10
jwt-decode, 解码JWT令牌；适用于浏览器应用程序 jwt解码是一个小型浏览器库，可以帮助解码Base64Url编码的JWTs标记。注意：这个库没有验证令牌，任何格式良好的JWT都可以解码。 应该使用 express JWT 。koa JWT 。 ...
jwt-decode:解码JWT令牌； 对浏览器应用程序有用
05-10
jwt-decode是一个小型浏览器库，有助于解码通过Base64Url编码的JWT令牌。 重要信息：该库不会验证令牌，任何格式正确的JWT都可以解码。 您应该使用 ， ， 等在服务器端逻辑中验证令牌。 警告：从版本2升级到版本3 ，...
网关与Jwt令牌.doc
10-16
这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利。 流程上是这样的： ...• 服务器进行验证用户的信息 • 服务器通过验证发送给用户一个token ...
用户登录实现(拦截器,JWT令牌)
05-28
用户登录实现(拦截器,JWT令牌)
tomcat-jwt-security:基于JWT令牌实现安全阀
05-10
该项目旨在将JWT令牌身份验证功能引入Tomcat 8 ，从而将身份验证过滤器实现为Tomcat Valve。 JWT操作基于项目。 对于Tomcat 7，请使用或克隆。 基于Valve的身份验证应该可以与放置在web.xml文件中的Java标准安全...
Spring Boot Security OAuth2 实现支持JWT令牌的授权服务器源码.zip
03-25
Spring Boot Security OAuth2 实现支持JWT令牌的服务器源码
jwt:JWT CLI 和用于编码、解码和使用 JWT 令牌的应用程序
07-24
命令行界面 用 Go 编写的 JWT CLI。 还包括： 用于快速解码 JWT 令牌的单个 html 文件 Web 应用程序：可在在线...JWT 令牌 ./jwt --secret demopass --sign '{"user": "John Doe"}'为生成的令牌指定到期时间 ./jwt --s
JWT 令牌
种一颗十年前的树
02-20 297
JWT 1.1 微服务鉴权 1.2 JWT介绍 JWT --> JSON Web Token 1). 为什么在项目的微服务鉴权中引入JWT令牌 ? 2). JWT令牌的构成 header , payload , signature ; -------> jwt = header.payload.signature JSON Web Token（JWT）是一个非常轻巧的规范。这...
OAuth和jwt令牌
04-24
OAuth（开放授权）是一种用于授权访问第三方应用程序的放标准。它允许用户通过授权服务器授权第三方应用程序访问其受保护的资源，而无需将其凭据直接提供给第三方应用程序。OAuth的工作流程通常涉及三个主要角色：资源所有者（用户）、客户端应用程序（第三方应用程序）和授权服务器。 JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在各方之间安全地传输信息作为JSON对象。JWT通常用作身份验证和授权的令牌。它由三个部分组成：头部、载荷和签名。头部包含描述令牌类型和签名算法的元数据，载荷包含有关主题（用户）和其他声明的信息，签名用于验证令牌的完整性。 OAuth和JWT令牌在身份验证和授权方面有所不同。OAuth主要用于授权访问第三方应用程序，而JWT令牌则用于在各方之间传输信息并进行身份验证。OAuth通过授权服务器颁发访问令牌，而JWT令牌则是由发行者签名并可被验证的令牌。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嗯兮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值