内嵌jwt工具类)
Posted 我认不到你
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了内嵌jwt工具类)相关的知识,希望对你有一定的参考价值。
JWT 基础概念详解,工具类和使用方法放在最后
什么是 JWT?
JWT (JSON Web Token) 是目前最流行的跨域认证解决方案,是一种基于 Token 的认证授权机制。 从 JWT 的全称可以看出,JWT 本身也是 Token,一种规范化之后的 JSON 结构的 Token。
JWT 自身包含了身份验证所需要的所有信息,因此,我们的服务器不需要存储 Session 信息。这显然增加了系统的可用性和伸缩性,大大减轻了服务端的压力。
jwt生成的token如下(例子):
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRlIjoxNjY4NjczOTM4LCJib29sIjp0cnVlLCJkb3VibGUiOjExMi4yMjIsIkxvbmciOjExMiwicm9zZSI6ImFkbWluIiwiaW50ZWdlciI6MTExMSwiZXhwIjoxNjY4Njc0ODM4LCJpYXQiOjE2Njg2NzM5MzgsInVzZXJJZCI6IjEyMzQ1NiJ9.ryTEhOnX9B_vIhfMdgWVPeCBN8Y5mjNoQC-ba8tOXj8
目前我们不需要了解这个很长的 token 的意思,我们只要了解他是由三部分组成,用
.
进行分割,里面拥有信息(自定义参数、私钥、生成时间、过期时间、 token 算法等),由后端生成传递给前端(登录时,账号密码对了,后端(后端不保留 token 值)就生成个 token 给前端(这个token可以携带自己定义的参数,如:用户id(userId))),然后前端把 token 保存起来(仅在前端保存 token 就行了),每次请求时带上这个 token ,我们可以根据后台的 jwt 算法与 jwt 私钥参数(这些我都写在工具类里,拿这个工具类来解析这个 token 就行),对前端再次传过来的这段 token 进行解密,并得到自己需要的参数(如:userId ),那么就可以拿到这个 userId 操作数据库。一、例子如下:
//下面这段代码只是一个参照,没有实现token生成的代码,只是告诉我们jwt是干嘛的 public static void main(String[] args) throws InterruptedException //我们可以自定义一个map,并把map传进token里面 Map<String,Object> map = new HashMap<>(); //可以加很多的参数,包括但不限于以下两种 map.put("userId","123456"); map.put("rose","admin"); // sign() 是一个当前文件的静态方法,之后调用的所有方法都是当前文件的方法,封装了一个工具类,在最后面,我会给大家,目前先理解着 String token = sign(map); //把map丢进去,生成token System.out.println(token); //输出token System.out.println(verify(token));//验证token是否正确 String dd = getClaims(token).get("userId").asString(); //使用方法 System.out.println(dd); // 获取 userId ,后端根据这个token就可以拿到 userId 了,那么就可以拿着这个id去增删改数据库了 System.out.println("获取签发token时间:" +getIssuedAt(token)); System.out.println("获取过期时间:"+getExpiresAt(token)); System.out.println("检查是否已过期:"+isExpired(token)); System.out.println("获取头"+getHeaderByBase64(token)); System.out.println("获取负荷"+getPayloadByBase64(token));
二、我的项目中的使用案例:(写的有点差,大佬们看看就行)
登录传递token:
@Override public R login(LoginDTO loginDTO) User loginUser = new User(); loginUser.setUserName(loginDTO.getUserName()) .setPassword(loginDTO.getPassword()); try //根据账号密码拿到用户信息 User user = this.baseMapper.selectOne( new LambdaQueryWrapper<User>() .eq(User::getUserName, loginUser.getUserName()) // 这是我毕设,目前还在开发中,前端是vue写的,vue太难了,就直接明文传输了,在后端加密跟数据库匹配,体现我的确是知道密码是要加密的,但前端太难,懒得做了 .eq(User::getPassword, MD5Util.md5(loginUser.getPassword()))); if (user!=null) // 把两个参数加入到map中 Map<String,Object> map = new HashMap<>(2); map.put("userId",user.getUserId()); map.put("jurisdiction",user.getJurisdiction()); // 把map丢给jwt处理,拿到token返回 String token = Auth0JwtUtils.sign(map); Map<String , String> map2 = new HashMap<>(1); map2.put("token",token); // 因为我的vue模板要k-v键值对的方式传递token,所以我也懒得改,直接返个map给前端就行了 return R.Success(map2); catch (NoSuchAlgorithmException e) log.error(e.getMessage()); return R.Failed("账号密码错误");
根据前端返回的token获取用户信息:
@Override // 获取用户信息的 serviceImpl public R getUserInfo(String token) try // 判断token是否正确且在有效期范围内 if (Auth0JwtUtils.verify(token)&&!Auth0JwtUtils.isExpired(token)) // 根据token,获取到 jurisdiction(权限)和 userId 用户的id Integer jurisdiction = Auth0JwtUtils.getInteger(token,"jurisdiction"); Integer userId = Auth0JwtUtils.getInteger(token,"userId"); // 根据 userId 查询数据库 User user = this.baseMapper.selectOne(new LambdaQueryWrapper<User>().eq(User::getUserId, userId)); Map<String , Object> map = new HashMap<>(10); // 写了个枚举来遍历权限 for (JurisdictionEnum value : JurisdictionEnum.values()) if (value.getJurisdiction().equals(jurisdiction)) map.put("role",value.getName()); map.put("roles",value.getX()); break; // 挨个装起来 map.put("sex",user.getSex()); map.put("introduction",user.getIntroduction()); map.put("avatar",user.getImage()); map.put("phone",user.getPhone()); map.put("name",user.getRealName()); // 返回给前端 return R.Success(map); catch (Exception e) log.error(e.getMessage()); return R.Failed();
可以看出,JWT 更符合设计 RESTful API 时的「Stateless(无状态)」原则 。
并且, 使用 JWT 认证可以有效避免 CSRF 攻击,因为 JWT 一般是存在在 localStorage 中,使用 JWT 进行身份验证的过程中是不会涉及到 Cookie 的。
下面是 RFC 7519open in new window 对 JWT 做的较为正式的定义。
JSON Web Token (JWT) is a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is used as the payload of a JSON Web Signature (JWS) structure or as the plaintext of a JSON Web Encryption (JWE) structure, enabling the claims to be digitally signed or integrity protected with a Message Authentication Code (MAC) and/or encrypted. ——JSON Web Token (JWT)open in new window
JWT 由哪些部分组成?
JWT 本质上就是一组字串,通过(.
)切分成三个为 Base64 编码的部分:
- Header : 描述 JWT 的元数据,定义了生成签名的算法以及
Token
的类型。 - Payload : 用来存放实际需要传递的数据
- Signature(签名) :服务器通过 Payload、Header 和一个密钥(Secret)使用 Header 里面指定的签名算法(默认是 HMAC SHA256)生成。
JWT 通常是这样的:xxxxx.yyyyy.zzzzz
。
示例:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
你可以在 jwt.ioopen in new window 这个网站上对其 JWT 进行解码,解码之后得到的就是 Header、Payload、Signature 这三部分。
Header 和 Payload 都是 JSON 格式的数据,Signature 由 Payload、Header 和 Secret(密钥)通过特定的计算公式和加密算法得到。
Header
Header 通常由两部分组成:
typ
(Type):令牌类型,也就是 JWT。alg
(Algorithm) :签名算法,比如 HS256。
示例:
"alg": "HS256",
"typ": "JWT"
JSON 形式的 Header 被转换成 Base64 编码,成为 JWT 的第一部分。
Payload
Payload 也是 JSON 格式数据,其中包含了 Claims(声明,包含 JWT 的相关信息)。
Claims 分为三种类型:
- Registered Claims(注册声明) :预定义的一些声明,建议使用,但不是强制性的。
- Public Claims(公有声明) :JWT 签发方可以自定义的声明,但是为了避免冲突,应该在 IANA JSON Web Token Registryopen in new window 中定义它们。
- Private Claims(私有声明) :JWT 签发方因为项目需要而自定义的声明,更符合实际项目场景使用。
下面是一些常见的注册声明:
iss
(issuer):JWT 签发方。iat
(issued at time):JWT 签发时间。sub
(subject):JWT 主题。aud
(audience):JWT 接收方。exp
(expiration time):JWT 的过期时间。nbf
(not before time):JWT 生效时间,早于该定义的时间的 JWT 不能被接受处理。jti
(JWT ID):JWT 唯一标识。
示例:
"uid": "ff1212f5-d8d1-4496-bf41-d2dda73de19a",
"sub": "1234567890",
"name": "John Doe",
"exp": 15323232,
"iat": 1516239022,
"scope": ["admin", "user"]
Payload 部分默认是不加密的,一定不要将隐私信息存放在 Payload 当中!!!
JSON 形式的 Payload 被转换成 Base64 编码,成为 JWT 的第二部分。
Signature
Signature 部分是对前两部分的签名,作用是防止 JWT(主要是 payload) 被篡改。
这个签名的生成需要用到:
- Header + Payload。
- 存放在服务端的密钥(一定不要泄露出去)。
- 签名算法。
签名的计算公式如下:
HMACSHA256(
base64UrlEncode(header) + "." +
base64UrlEncode(payload),
secret)
算出签名以后,把 Header、Payload、Signature 三个部分拼成一个字符串,每个部分之间用"点"(.
)分隔,这个字符串就是 JWT 。
如何基于 JWT 进行身份验证?
在基于 JWT 进行身份验证的的应用程序中,服务器通过 Payload、Header 和 Secret(密钥)创建 JWT 并将 JWT 发送给客户端。客户端接收到 JWT 之后,会将其保存在 Cookie 或者 localStorage 里面,以后客户端发出的所有请求都会携带这个令牌。
简化后的步骤如下:
- 用户向服务器发送用户名、密码以及验证码用于登陆系统。
- 如果用户用户名、密码以及验证码校验正确的话,服务端会返回已经签名的 Token,也就是 JWT。
- 用户以后每次向后端发请求都在 Header 中带上这个 JWT 。
- 服务端检查 JWT 并从中获取用户相关信息。
两点建议:
- 建议将 JWT 存放在 localStorage 中,放在 Cookie 中会有 CSRF 风险。
- 请求服务端并携带 JWT 的常见做法是将其放在 HTTP Header 的
Authorization
字段中(Authorization: Bearer Token
)。
spring-security-jwt-guideopen in new window 就是一个基于 JWT 来做身份认证的简单案例,感兴趣的可以看看。
如何防止 JWT 被篡改?
有了签名之后,即使 JWT 被泄露或者截获,黑客也没办法同时篡改 Signature 、Header 、Payload。
这是为什么呢?因为服务端拿到 JWT 之后,会解析出其中包含的 Header、Payload 以及 Signature 。服务端会根据 Header、Payload、密钥再次生成一个 Signature。拿新生成的 Signature 和 JWT 中的 Signature 作对比,如果一样就说明 Header 和 Payload 没有被修改。
不过,如果服务端的秘钥也被泄露的话,黑客就可以同时篡改 Signature 、Header 、Payload 了。黑客直接修改了 Header 和 Payload 之后,再重新生成一个 Signature 就可以了。
密钥一定保管好,一定不要泄露出去。JWT 安全的核心在于签名,签名安全的核心在密钥。
如何加强 JWT 的安全性?
- 使用安全系数高的加密算法。
- 使用成熟的开源库,没必要造轮子。
- JWT 存放在 localStorage 中而不是 Cookie 中,避免 CSRF 风险。
- 一定不要将隐私信息存放在 Payload 当中。
- 密钥一定保管好,一定不要泄露出去。JWT 安全的核心在于签名,签名安全的核心在密钥。
- Payload 要加入
exp
(JWT 的过期时间),永久有效的 JWT 不合理。并且,JWT 的过期时间不易过长。 - and so on
好了,讲了这么多,其实我也记不全,直接拿JWT工具类来用就行,但稍微理解下原理的话,那么就可以应对各种各样的问题了不是
maven包:
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.9.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>
工具类:
package com.zhao.utils;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
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 lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
*@author:Tlimited
*/
@Slf4j
public class Auth0JwtUtils
//过期时间 15分钟
private static final long EXPIRE_TIME = 15* 60 * 1000;
//私钥
private static final String TOKEN_SECRET = "privateKey";
/**
* 生成签名,15分钟过期
* 根据内部改造,支持6中类型,Integer,Long,Boolean,Double,String,Date
* @param map
* @return
*/
public static String sign(Map<String,Object> map)
try
// 设置过期时间
Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
// 私钥和加密算法
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
// 设置头部信息
Map<String, Object> header = new HashMap<>(2);
header.put("typ", "jwt");
// 返回token字符串
JWTCreator.Builder builder = JWT.create()
.withHeader(header)
.withIssuedAt(new Date()) //发证时间
.withExpiresAt(date); //过期时间
// .sign(algorithm); //密钥
// map.entrySet().forEach(entry -> builder.withClaim( entry.getKey(),entry.getValue()));
map.entrySet().forEach(entry ->
if (entry.getValue() instanceof Integer)
builder.withClaim( entry.getKey(),(Integer)entry.getValue());
else if (entry.getValue() instanceof Long)
builder.withClaim( entry.getKey(),(Long)entry.getValue());
else if (entry.getValue() instanceof Boolean)
builder.withClaim( entry.getKey(),(Boolean) entry.getValue());
else if (entry.getValue() instanceof String)
builder.withClaim( entry.getKey(),String.valueOf(entry.getValue()));
else if (entry.getValue() instanceof Double)
builder.withClaim( entry.getKey(),(Double)entry.getValue());
else if (entry.getValue() instanceof Date)
builder.withClaim( entry.getKey(),(Date)entry.getValue());
);
return builder.sign(algorithm);
catch (Exception e)
log.error(e.getMessage());
return null;
/**
* 检验token是否正确
* @param **token**
* @return
*/
public static boolean verify(String token)
try
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
JWTVerifier verifier = JWT.require(algorithm).build();
verifier.verify(token
package com.util.jwt;
import com.google.common.collect.Maps;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.apache.tomcat.util.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.SecretKey;
import java.util.Date;
import java.util.Map;
/**
* @author: HuGoldWater
* @description:
*/
public class JwtUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(JwtUtil.class);
/**
* 秘钥
* - 默认:123456
*/
private String secret = "123456";
/**
* 有效期,单位秒
* - 默认2周
*/
private Long expirationTimeInSecond = 1626021786L;
/**
* 从token中获取claim
*
* @param token token
* @return claim
*/
public Claims getClaimsFromToken(String token) {
try {
return Jwts.parser()
.setSigningKey(this.secret.getBytes())
.parseClaimsJws(token)
.getBody();
} catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | IllegalArgumentException e) {
LOGGER.error("token解析错误", e);
throw new IllegalArgumentException("Token invalided.");
}
}
/**
* 获取token的过期时间
*
* @param token token
* @return 过期时间
*/
public Date getExpirationDateFromToken(String token) {
return getClaimsFromToken(token)
.getExpiration();
}
/**
* 判断token是否过期
*
* @param token token
* @return 已过期返回true,未过期返回false
*/
private Boolean isTokenExpired(String token) {
Date expiration = getExpirationDateFromToken(token);
return expiration.before(new Date());
}
/**
* 计算token的过期时间
*
* @return 过期时间
*/
private Date getExpirationTime() {
return new Date(System.currentTimeMillis() + this.expirationTimeInSecond * 1000);
}
/**
* 为指定用户生成token
*
* @param claims 用户信息
* @return token
*/
public String generateToken(Map<String, Object> claims) {
Date createdTime = new Date();
Date expirationTime = this.getExpirationTime();
byte[] keyBytes = secret.getBytes();
SecretKey key = Keys.hmacShaKeyFor(keyBytes);
return Jwts.builder()
.setClaims(claims)
.setIssuedAt(createdTime)
.setExpiration(expirationTime)
// 你也可以改用你喜欢的算法
// 支持的算法详见:https://github.com/jwtk/jjwt#features
.signWith(key, SignatureAlgorithm.HS256)
.compact();
}
/**
* 判断token是否非法
*
* @param token token
* @return 未过期返回true,否则返回false
*/
public Boolean validateToken(String token) {
return !isTokenExpired(token);
}
public static void main(String[] args) {
// 1. 初始化
JwtUtil jwtOperator = new JwtUtil();
jwtOperator.expirationTimeInSecond = 1209600L;
jwtOperator.secret = "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt";
// 2.设置用户信息
Map<String, Object> objectObjectHashMap = Maps.newHashMap();
objectObjectHashMap.put("id", "1");
// 测试1: 生成token
String token = jwtOperator.generateToken(objectObjectHashMap);
// 会生成类似该字符串的内容: eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJpYXQiOjE1NjU1ODk4MTcsImV4cCI6MTU2Njc5OTQxN30.27_QgdtTg4SUgxidW6ALHFsZPgMtjCQ4ZYTRmZroKCQ
System.out.println(token);
// 将我改成上面生成的token!!!
String someToken = "eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJpYXQiOjE2MjUxNTc4NjgsImV4cCI6MTYyNjM2NzQ2OH0.wNeIceDm7IombYsa13Cq4EOdz_RNq1GcGOm8UMlTWHk";
// 测试2: 如果能token合法且未过期,返回true
Boolean validateToken = jwtOperator.validateToken(someToken);
System.out.println(validateToken);
// 测试3: 获取用户信息
Claims claims = jwtOperator.getClaimsFromToken(someToken);
System.out.println(claims);
// 将我改成你生成的token的第一段(以.为边界)
String encodedHeader = "eyJhbGciOiJIUzI1NiJ9";
// 测试4: 解密Header
byte[] header = Base64.decodeBase64(encodedHeader.getBytes());
System.out.println(new String(header));
// 将我改成你生成的token的第二段(以.为边界)
String encodedPayload = "eyJpZCI6IjEiLCJpYXQiOjE2MjUxNTc4NjgsImV4cCI6MTYyNjM2NzQ2OH0";
// 测试5: 解密Payload
byte[] payload = Base64.decodeBase64(encodedPayload.getBytes());
System.out.println(new String(payload));
// 测试6: 这是一个被篡改的token,因此会报异常,说明JWT是安全的
jwtOperator.validateToken("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJpYXQiOjE1NjU1ODk3MzIsImV4cCI6MTU2Njc5OTMzMn0.nDv25ex7XuTlmXgNzGX46LqMZItVFyNHQpmL9UQf-aUx");
}
}
eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJpYXQiOjE2MjUxNTc5MDgsImV4cCI6MTYyNjM2NzUwOH0.bR8aQKFed1pvf7yLCuJIsi6i7tuAm5Aoyy4HCePTOPo
true
{id=1, iat=1625157868, exp=1626367468}
{"alg":"HS256"}
{"id":"1","iat":1625157868,"exp":1626367468}
Exception in thread "main" io.jsonwebtoken.security.SignatureException: JWT signature does not match locally computed signature. JWT validity cannot be asserted and should not be trusted.
at io.jsonwebtoken.impl.DefaultJwtParser.parse(DefaultJwtParser.java:383)
at io.jsonwebtoken.impl.DefaultJwtParser.parse(DefaultJwtParser.java:513)
at io.jsonwebtoken.impl.DefaultJwtParser.parseClaimsJws(DefaultJwtParser.java:573)
at com.util.jwt.JwtUtil.getClaimsFromToken(JwtUtil.java:43)
at com.util.jwt.JwtUtil.getExpirationDateFromToken(JwtUtil.java:58)
at com.util.jwt.JwtUtil.isTokenExpired(JwtUtil.java:69)
at com.util.jwt.JwtUtil.validateToken(JwtUtil.java:113)
at com.util.jwt.JwtUtil.main(JwtUtil.java:154)
来源:
https://www.itmuch.com/other/jwt-util/