springboot jwt 学习

最新推荐文章于 2024-06-20 09:50:11 发布
最新推荐文章于 2024-06-20 09:50:11 发布
阅读量370 收藏 1
点赞数
分类专栏： # spring全家桶 文章标签： java jwt
未经允许，不可转载 by张小三
本文链接：https://blog.csdn.net/qq_38313548/article/details/113834447
版权
  • JWT组成
    格式：标头（header）.有效载荷（payload）.签名(signature)
    注意：jwt中不要放敏感数据，例如密码和身份证号等…
    • JWT组成部分说明
      header: 由令牌类型和使用的签名算法两部分组成，用base64编码处理。
      payload： 其中包含声明，即相关实体数据（例如登录用户的非敏感数据），用base64编码处理。
      **signature：**使用base64编码后的header和payload以及系统提供的密钥组成，并使用header中的算法进行签名。保证jwt未被篡改。

整和Spring boot项目

  1. 创建springboot 项目（此处省略）。加入JWT的依赖，如下:
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.10.3</version>
        </dependency>
  1. 在test目录下创建一个测试类。在测试类中写生成token的方法：
     @Test
    void createToken() {
    @Test
    void createToken() {
        /**生成token*/
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MINUTE,2); //2分钟之后的时间

        //HashMap mapHeader = new HashMap();
        String token= JWT.create()
                //.withHeader(mapHeader) //header部分，可省略，省略时默认使用 HMAC256
                .withClaim("userId",3)  //payload部分
                .withClaim("username","张三") //payload部分
                .withExpiresAt(cal.getTime()) //令牌过期时间
                .sign(Algorithm.HMAC256("zhangxiaosan")); //signature签名部分,其中的参数zhangxiaosan为密钥,此密钥不可对外公开
        System.out.println("生成的token:"+token);
    }
  1. 在测试类中写验证token的方法。
  @Test
    void checkToken(){
        /**验证token*/
        String token= "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MTM1NDk5MDAsInVzZXJJZCI6MywidXNlcm5hbWUiOiLlvKDkuIkifQ.gGFrk0i492Gg83-2D4FBZsfnqhwsBJCgX0tIcju_qqg";
        try {
            //创建验证对象 HMAC256
            JWTVerifier jWTVerifier = JWT.require(Algorithm.HMAC256("zhangxiaosan")).build();
            DecodedJWT verify = jWTVerifier.verify(token);
            System.out.println("verify:" + verify.getClaim("userId").asInt());
            System.out.println("verify:" + verify.getClaim("username").asString());
            System.out.println("verify:" + verify.getExpiresAt());
        }catch (AlgorithmMismatchException e){
            System.out.println("算法不匹配");
        }catch (TokenExpiredException e){
            System.out.println("token已失效");
        }catch (JWTDecodeException e){
            System.out.println("解码失败，token无效");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

先运行步骤2得到密钥，在将步骤3中的token替换运行后得到以下结果：即验证通过。
在这里插入图片描述

将上述的代码封装成工具类

创建文件JWTUtil.java，用于封装jwt需要的方法。

package com.jwt.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

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

public class JwtUtil {
    private final  static String SING = "zhangxiaosan";
    private final  static Integer DEFAULT_EXPIRES_TIME = 7 ;
    /**
     * 生成token
     * @param map Map<String,String> 存放在token中的payload中的数据
     * @return  token String 生成的token
     */
    public static String createToken(Map<String,String> map){
        /**生成token*/
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE,DEFAULT_EXPIRES_TIME); //7天之后的时间
        JWTCreator.Builder builder = JWT.create();
        /*将存在payload部分的数据Map遍历存放*/
        map.forEach((k,v)->{
            if (v != null) {
                builder.withClaim(k, v);
            }
        });
        builder.withExpiresAt(cal.getTime()); //令牌过期时间
        String token = builder.sign(Algorithm.HMAC256(SING));//signature签名部分,其中的参数为密钥，开始生成token
        return token;
    }

    /**
     * 验证签名
     * @param  token String  需要验证的token
     * @return resMap Map 验证结果Map  {"code":"0000","msg":"成功"}
     * */
    public static Map verifyToken(String token){
        Map map = new HashMap();
        try {
            DecodedJWT verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
            map.put("code","0000");
            map.put("msg","成功");
            map.put("data",verify);
        }catch (AlgorithmMismatchException e){
            map.put("code","1001");
            map.put("msg","验证算法不匹配");
            map.put("data",null);
        }catch (TokenExpiredException e){
            map.put("code","1002");
            map.put("msg","token已失效");
            map.put("data",null);
        }catch (JWTDecodeException e) {
            map.put("code","1003");
            map.put("msg","解码失败，token无效");
            map.put("data",null);
        }catch (Exception e){
            map.put("code","1000");
            map.put("msg","验证异常");
            map.put("data",null);
        }
        return map;
    }

    /**
     * 根据token获取payload中的数据
     * @param  token String  需要获取数据的token
     * */
    public static DecodedJWT getDateByToken(String token){
        Map map = verifyToken(token);
        Object data = map.get("data");
        if (data == null){
            return null;
        }
        return (DecodedJWT) data;
    }


}

今天，安全大佬龙傲天给我发了一细列优秀的文章：

  1. JWT介绍及其安全性分析
  2. jas502n/JWT_Brute: JWT_Brute
  3. 攻击JWT的一些方法
  4. Json Web Token历险记

然后若有所思。然后就更新了一下上面的JWT工具类。
生成token后将token字符串用DES对称加密，验证时候用DES解密，这样前端拿到的就是加密后的token串了。
注意：StringUtil只是判断字符传是否为空

修改后的工具类如下：

package com.jwt.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 张小三
 * @create 2021-05-27 17:02
 * @verson 1.0.0
 */
public class JwtUtil2 {
    private final  static String SING = "zhangxiaosan_sign";
    private final  static String KEY = "zhangxiaosan_key";

    /**
     * 生成token
     * 默认过期时间为30分钟
     * @param map Map<String,String> 存放在token中的payload中的数据
     * @return  token String 生成的token
     */
    public static String createToken(Map<String,String> map){
        /**生成token*/
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MINUTE,30); //30分钟之后的时间
        JWTCreator.Builder builder = JWT.create();
        /*将存在payload部分的数据Map遍历存放*/
        map.forEach((k,v)->{
            if (v != null) {
                builder.withClaim(k, v);
            }
        });
        builder.withExpiresAt(cal.getTime()); //令牌过期时间
        String token = builder.sign(Algorithm.HMAC256(SING));//signature签名部分,其中的参数为密钥，开始生成token
        return DesUtil.encryptDes(KEY, token).replaceAll("\\r\\n","");
    }
    /***
     * 生成自定义过期时间token
     * @param map Map<String,String> 存放在token中的payload中的数据
     * @param time Integer  自定义的过期时间，单位为分钟
     * @return
     */
    public static String createTokenCustomExpireTime(Map<String,String> map,Integer time){
        /**生成token*/
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MINUTE,time); //
        JWTCreator.Builder builder = JWT.create();
        /*将存在payload部分的数据Map遍历存放*/
        map.forEach((k,v)->{
            if (v != null) {
                builder.withClaim(k, v);
            }
        });
        builder.withExpiresAt(cal.getTime()); //令牌过期时间
        String token = builder.sign(Algorithm.HMAC256(SING));//signature签名部分,其中的参数为密钥，开始生成token
        return DesUtil.encryptDes(KEY, token).replaceAll("\\r\\n","");
    }


    /**
     * 验证签名
     * @param  token String  需要验证的token
     * @return resMap Map 验证结果Map  {"code":"0000","msg":"成功"}
     * */
    public static Map verifyToken(String token){
        Map map = new HashMap();
        if(StringUtil.isEmpty(token)){
            map.put("code","0001");
            map.put("msg","token不能为空");
            map.put("data",null);
        }else{
            try {
                String tokenStr = DesUtil.decryptDES(KEY, token);
                DecodedJWT verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(tokenStr);
                map.put("code","0000");
                map.put("msg","成功");
                map.put("data",verify);
            }catch (AlgorithmMismatchException e){
                map.put("code","1001");
                map.put("msg","验证算法不匹配");
                map.put("data",null);
            }catch (TokenExpiredException e){
                map.put("code","1002");
                map.put("msg","token已失效");
                map.put("data",null);
            }catch (JWTDecodeException e) {
                map.put("code","1003");
                map.put("msg","解码失败，token无效");
                map.put("data",null);
            }catch (Exception e){
                map.put("code","1000");
                map.put("msg","验证失败");
                map.put("data",null);
            }
        }
        return map;
    }

    /**
     * 根据token获取payload中的数据
     * @param  token String  需要获取数据的token
     * */
    public static DecodedJWT getDateByToken(String token){
        Map map = verifyToken(token);
        Object data = map.get("data");
        if (data == null){
            return null;
        }
        return (DecodedJWT) data;
    }

    /**
     * 判断token的过期时间
     * @param token String token值
     */
    public static String getExpireTime(String token){
        if(StringUtil.isEmpty(token)) return "token不能为空";
        DecodedJWT dateByToken = getDateByToken(token);
        Map<String, Claim> claims = dateByToken.getClaims();
        Claim exp = claims.get("exp");
        Date date = exp.asDate();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(date);
    }
}

Desutil.java

package com.jwt.controller;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import java.security.SecureRandom;

/**
 * @author 张小三
 * @create 2021-05-27 17:05
 * @verson 1.0.0
 */
public class DesUtil {
    private static final String  KEY = "zhangxiaosan";
    /**
     * 加密
     * @param key 密钥
     * @param data 加密的字符串
     */
    public static String encryptDes(String key, String data) {
        try {
            if (StringUtil.isEmpty(key)) key = KEY;
            if(StringUtil.isEmpty(data)) return data;
            DESKeySpec desKey = new DESKeySpec(key.getBytes("UTF-8"));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = keyFactory.generateSecret(desKey);
            SecureRandom random = new SecureRandom();
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(1, secretKey, random);
            return toHexString(cipher.doFinal(data.getBytes("UTF-8")));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }



    /**
     * 解密
     * @param key 解密的key  String
     * @param data 传入加密后的数据  String
     * @return String
     *
     */
    public static String decryptDES(String key, String data){
        try {
            if (StringUtil.isEmpty(key)) key = KEY;
            if(StringUtil.isEmpty(data)) return "";
            DESKeySpec desKey = new DESKeySpec(key.getBytes("UTF-8"));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = keyFactory.generateSecret(desKey);
            SecureRandom random = new SecureRandom();
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(2, secretKey, random);
            return new String(cipher.doFinal(toByteArray(data)));
        }  catch (BadPaddingException e) {
            return data;
        } catch (IllegalBlockSizeException e) {
            return data;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }

    private static byte[] toByteArray(String hexString) {
        byte[] bytes = new byte[hexString.length() / 2];

        for(int i = 0; i < hexString.length() / 2; ++i) {
            bytes[i] = (byte)(Character.digit(hexString.charAt(i * 2), 16) << 4 | Character.digit(hexString.charAt(i * 2 + 1), 16));
        }

        return bytes;
    }

    private static String toHexString(byte[] bytes) {
        String hexString = "";
        byte[] var2 = bytes;
        int var3 = bytes.length;
        for(int var4 = 0; var4 < var3; ++var4) {
            byte b = var2[var4];
            hexString = hexString + toHexString(b);
        }
        return hexString;
    }

    private static String toHexString(int i) {
        return 1 == Integer.toHexString(i).length() ? "0" + Integer.toHexString(i) : Integer.toHexString(i);
    }

    private static String toHexString(byte b) {
        return toHexString(toInt(b));
    }
    private static int toInt(byte b) {
        return b & 255;
    }
}

StringUtil.java

package com.jwt.controller;

import java.math.BigDecimal;
import java.util.regex.Pattern;

public class StringUtil {
    public static Boolean isEmpty(String str){
        if (str==null || str.trim().isEmpty() ||  "".equals(str.trim()) || "null".equals(str.trim())){
            return true;
        }
        return false;
    }

    public static  Boolean isNoEmpty(String str){
        return !isEmpty(str);
    }


    /***
     * 判断是否为整数数字
     */
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }
}

使用例子：

 		//创建放入token种的数据
 		Map map = new HashMap();
        map.put("username","zhangsan");
        
        //创建token
        String token = JwtUtil2.createToken(map);
        System.out.println(token);
	
		//获取token过期时间
        String expireTime = JwtUtil2.getExpireTime(token);
        System.out.println(expireTime);
		
		//验证token
		// 0000 成功  返回存入token的数据
		// 1001 验证算法不匹配
        // 1002 token已失效
        // 1003 解码失败，token无效
        // 1000 验证失败
        Map map1 = JwtUtil2.verifyToken(token);

		//获取token中存放的值
        DecodedJWT dateByToken = JwtUtil2.getDateByToken(token);
        System.out.println(dateByToken.getClaim("username").asString());
小张帅三代
关注
专栏目录
SpringBoot JWT
fantasyfzg的博客
11-30 212
token
SpringBoot开发——整合 JWT 轻松搞定跨站点统一登录
最新发布
bjzhang75的博客
09-03 824
私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息，但不建议添加敏感信息，因为该部分在客户端可解密。但是，假如应用服务器的请求量变得很大，而单台服务器能支撑的请求量是有限的，这个时候就容易出现请求变慢或者OOM。中获取用户的基本信息，既然客户端可以获取，肯定是不能存放敏感信息的，因为浏览器可以直接从token获取用户信息。
SpringBoot集成JWT
John_Dai的博客
03-07 698
一、什么是JWT？ JSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且独立的方法，用于在各方之间安全地将信息作为JSON对象传输。 由于此信息是经过数字签名的，因此可以被验证和信任。 可以使用密钥（使用HMAC算法）或使用RSA或ECDSA的公用/专用密钥对对JWT进行签名。 二、JWT请求流程 1. 用户使用账号和面发出post请求； 2. 服务器使用私钥创建一个jwt； 3. 服务器返回这个jwt给浏览器； 4. 浏览器将该jwt串在请求头中像服务器发送请求；
springboot-JWT
FA的博客
07-23 119
JWT原理 单点登录
Springboot：JWT
沉迷写代码的程序猿的博客
03-22 4243
文章目录Springboot：JWT一、JWT简介1、JWT的优势2、JWT的结构2.1、标头（Header）2.2、有效负荷（Payload）2.3、签名（Signature）二、SpringBoot整合JWT Springboot：JWT 一、JWT简介 JWT，是指JSON Web Token，也就指通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。 1、JWT的优势 在JavaWeb阶段，经常使用ses
Spring Boot + jwt
weixin_63831348的博客
06-20 2952
Spring Boot + jwt
基于springboot+jwt实现刷新token过程解析
08-19
文中通过示例代码详细介绍了基于SpringBoot+JWT实现刷新Token的过程，旨在为读者提供参考学习价值。 标签解析 SpringBoot、JWT、Token 部分内容解析 1. 在线刷新Token 在线刷新Token的方式是指在每次访问资源时，...
SpringBoot集成JWT生成token及校验方法过程解析
08-19
本文主要介绍了SpringBoot集成JWT生成token及校验方法的过程解析，通过示例代码详细介绍了JWT token的生成和校验过程，为读者提供了详细的Reference和学习价值。 一、什么是JWT？ JSON Web Tokens（JWT）是一种...
springboot-jwt-demo.zip
08-18
SpringBoot结合SpringSecurity和JWT（JSON Web Token）的实现是一个常见的Web应用...通过研究此项目，你可以学习到如何配置Spring Security，编写JWT相关的过滤器，以及如何在Spring Boot应用中处理登录、鉴权等操作。
springboot+jwt做登录鉴权（附完整代码）
qq_45821255的博客
09-06 2662
jwt做登录鉴权
Springboot整合JWT,Swagger.zip
07-12
SpringBoot整合JWT与Swagger是现代Web开发中两个重要的技术组件，它们可以极大地提升应用程序的效率和易用性。JWT（Json Web Token）用于安全地在客户端和服务器之间传输信息，而Swagger则是用于构建RESTful API的...
Spring Boot 实现 JWT
云胡
06-21 7786
Web 网站离不开用户认证，这边我们不用 ，而直接使用 。JWT 的背景知识可以看阮一峰老师的这篇文章: JSON Web Token 入门教程JWT 由三个部分组成：在 中添加 配置信息。 2.2 新建 JwtUtil 工具类 新建 目录，在 目录下新建 。将当前 注入到 容器中。，匹配 配置文件的前缀，然后将配置文件里面的数据加载到当前类。 2.3 用户登录创建 token 2.3 拦截器验证 token 如何自定义拦截器可以看我的这篇: Spring Boot 2 配置登录拦截。 三、参考资料
SpringBoot中使用JWT
cxzhq2002的杂记
11-04 1705
JWT是什么我就不说了，这里只说名SpringBoot中怎么用。 首先在pom中天际依赖 1 <dependency> 2 <groupId>org.bitbucket.b_c</groupId> 3 <artifactId>jose4j</artifactId> 4 <version>0.6.5</version> 5 </dependency> 这里我用
Springboot集成jwt
chen的博客
03-16 913
导入依赖 <!--jwt--> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.3</version> </dependency> 编写jwt工具类 TokenUt
SpringBoot学习笔记21——JWT实现登录校验
月月大王的博客
03-25 641
今天记录一下使用JWT实现用户登录校验。 实现的效果是，在的客户端登录时会返回一个token用作客户端后续登录校验，登录之后客户端需要将token放在请求的head中，否则返回的登录失败。话不多说直接上代码。 1.JWT工具类 前面的文章有JWT的一个简单的示例，后来我对它进行了完善，代码如下： package com.youyou.shiro.jwt; import com.auth...
springboot实现JWT
weixin_41849346的博客
09-08 313
pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- JWT依赖 -->
SpringBoot集成Jwt
Xu_Ren的博客
05-07 291
JWT 简介 Json Web Token（JWT），是为了在网络应用环境之间传递声明而执行的一种基于JSON的开放标准（RFC7519），该 token 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者之间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其他业务逻辑所必须声明信息，该token也可以直接被...
springboot+jwt
while(life)++；
05-06 375
流程： 1.用户访问login接口，验证用户身份信息，并生成token绑定用户信息，token返回前端 2.前端把token存入request header中访问后端接口即可成功，否则提示无权访问 代码部分： 1.JwtUtil类 （生成token，校验token等） /* * * @Author qy * <p> JWT工具类 </p> * @Param * @Return */ public class JwtUtil { // Token过期时间30分钟
SpringBoot与JWT结合实现Token权限管理示例
通过该项目，开发者可以学习到如何使用Spring Security进行安全配置，以及如何利用JWT生成和验证token。同时，此项目也展示了如何通过Spring Boot简化配置和部署过程，使得整个安全体系更加简洁高效。以下将详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小张帅三代

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

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

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

打赏作者

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

抵扣说明：

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

余额充值