JWT详解与使用
JWT是什么
JWT简称JSON Web Token,也就是通过JSON形式作为Web应用中的令牌,用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。
认证流程
首先，前端通过Web表单将自己的用户名和密码发送到后端的接口。这一过程一般是一个HTTP POST请求。建议的方式是通过SSL加密的传输（https协议），从而避免敏感信息被嗅探。
后端核对用户名和密码成功后，将用户的id等其他信息作为JWT Payload（负载），将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。形成的JWT就是一个形同lll.zzz.xxx的字符串。 token head.payload.singurater
后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage或sessionStorage上，退出登录时前端删除保存的JWT即可。
前端在每次请求时将JWT放入HTTP Header中的Authorization位。(解决XSS和XSRF问题) HEADER
后端检查是否存在，如存在验证JWT的有效性。例如，检查签名是否正确；检查Token是否过期；检查Token的接收方是否是自己（可选）。
验证通过后后端使用JWT中包含的用户信息进行其他逻辑操作，返回相应结果。
jwt优势
- 输出是三个由点分隔的Base64-URL字符串，可以在HTML和HTTP环境中轻松传递这些字符串，与基于XML的标准（例如SAML）相比，它更紧凑
- 简洁(Compact)可以通过URL, POST 参数或者在 HTTP header 发送，因为数据量小，传输速度快
- 自包含(Self-contained)负载中包含了所有用户所需要的信息，避免了多次查询数据库
令牌组成
- 1.标头(Header)
- 2.有效载荷(Payload)
- 3.签名(Signature)
- 因此，JWT通常如下所示:xxxxx.yyyyy.zzzzz Header.Payload.Signature
header 和 payload 都是用base64来加密的，他们的本体是json数据，咱们看到的只是用base64加密后的header里包含的内容是 jwt的类型和加密算法
payload里包含的是 非敏感信息，例如：用户id，账号…等等用户的信息，就是不要放密码，为了安全。
1.Header
-
标头通常由两部分组成：令牌的类型（即JWT）和所使用的签名算法，例如HMAC SHA256或RSA。它会使用 Base64 编码组成 JWT 结构的第一部分。
-
注意:Base64是一种可读性算法，不是加密算法，也就是说，它是可以被翻译回原来的样子来的。它并不是一种加密过程。
{
"alg": "HS256",
"typ": "JWT"
}
2.Payload
- 令牌的第二部分是有效负载，其中包含声明。存放了一些非敏感信息
- （通常是用户）和其他数据的声明。同样的，它会使用 Base64 编码组成 JWT 结构的第二部分
{
"sub": "1234567890",
"name": "John Doe",
"admin": true
}
3.Signature
- 前面两部分都是使用 Base64 进行编码的，即前端可以解开知道里面的信息。Signature 需要使用编码后的 header 和 payload以及我们提供的一个密钥，然后使用 header 中指定的签名算法（HS256）进行签名。签名的作用是保证 JWT 没有被篡改过。
- 如:
HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload),secret);
4.签名目的
- 最后一步签名的过程，实际上是对头部以及负载内容进行签名，防止内容被窜改。如果有人对头部以及负载的内容解码之后进行修改，再进行编码，最后加上之前的签名组合形成新的JWT的话，那么服务器端会判断出新的头部和负载形成的签名和JWT附带上的签名是不一样的。如果要对新的头部和负载进行签名，在不知道服务器加密时用的密钥的话，得出来的签名也是不一样的。
5.信息安全问题
- 在这里大家一定会问一个问题：Base64是一种编码，是可逆的，那么我的信息不就被暴露了吗？
- 是的。所以，在JWT中，不应该在负载里面加入任何敏感的数据。在上面的例子中，我们传输的是用户的User ID。这个值实际上不是什么敏感内容，一般情况下被知道也是安全的。但是像密码这样的内容就不能被放在JWT中了。如果将用户的密码放在了JWT中，那么怀有恶意的第三方通过Base64解码就能很快地知道你的密码了。因此JWT适合用于向Web应用传递一些非敏感信息。JWT还经常用于设计用户认证和授权系统，甚至实现Web应用的单点登录。
jwt与jjwt
JJWT 旨在成为最易于使用和理解的库，用于在 JVM 和 Android 上创建和验证 JSON Web 令牌 (JWT)。
JJWT 是完全基于JWT、 JWS、JWE、 JWK和JWA RFC 规范的纯 Java 实现，并且在Apache 2.0 许可条款下开源。
该库由Les Hazlewood创建，由贡献者社区 支持和维护。
我们还添加了一些不属于规范的便利扩展，例如 JWS 压缩和声明强制。
使用步骤
1.java-jwt
1.1 引入依赖
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</dependency>
1.2 JwtUtils工具类
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.InvalidClaimException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
import java.util.HashMap;
/**
* @author liu kang
* @date 2021/8/22 22:07
* @Description:
*/
public class JwtUtils {
private static Logger log = LoggerFactory.getLogger(JwtUtils.class);
private static final String SECRET = "23&(^$j478-//*3.";
/**
* 生成token
*
* @param payloadMap 载荷
* @param expireMinutes 过期时间分钟
* @return
*/
public static String generateToken(HashMap<String, String> payloadMap, Long expireMinutes) {
JWTCreator.Builder builder = JWT.create();
// 载荷
payloadMap.forEach(builder::withClaim);
// 过期时间
expireMinutes = System.currentTimeMillis() + expireMinutes * 60 * 1000;
// 在什么时候过期
builder.withExpiresAt(new Date(expireMinutes));
// 签名(加密)
return builder.sign(Algorithm.HMAC256(SECRET));
}
/**
* 校验token
*
* @param token
* @return
*/
public static Boolean verifyToken(String token) {
// 使用SHA256加密
try {
JWT.require(Algorithm.HMAC256(SECRET)).build().verify(token);
} catch (TokenExpiredException | InvalidClaimException | AlgorithmMismatchException | SignatureVerificationException e) {
log.error("token校验失败：{}", e.getMessage());
return false;
}
return true;
}
/**
* 获取token中载荷内容
*
* @param key
* @return
*/
public static String getTokenInnerValue(String token, String key) {
return JWT.decode(token).getClaim(key).asString();
}
}
2.JJWT使用
依赖
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>0.11.2</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>0.11.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>0.11.2</version>
<scope>runtime</scope>
</dependency>
2.1 工具类(jwt+自定义密钥)
import io.jsonwebtoken.*;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import io.jsonwebtoken.security.SignatureException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.security.Key;
import java.util.Date;
import java.util.Map;
/**
* @Description:
* @Author party-abu
* @Date 2022/1/29 23:43
*/
public class JwtUtils {
private static final Logger log = LoggerFactory.getLogger(JwtUtils.class);
/**
* 不同的加密算法对密钥长度有范围限制
* <p>
* HS256是 HMAC-SHA-256，这会生成长度为 256 位（32 字节）的摘要，因此要求您使用长度至少为 32 字节的密钥。HS256
* <p>
* HS384是 HMAC-SHA-384，这会生成长度为 384 位（48 字节）的摘要，因此要求您使用长度至少为 48 字节的密钥。HS384
* <p>
* HS512是 HMAC-SHA-512，这会生成长度为 512 位（64 字节）的摘要，因此要求您使用长度至少为 64 字节的密钥。HS512
*/
private static final String SECRET = "21104324j4FDFDSFSDFDSFDSSFSDFD33rmf1d5s6fcdsfcsdfd";
/**
* 生成token
*
* @param claims
* @param expireHours
* @return
*/
public static String generateToken(Map<String, Object> claims, Long expireHours) {
Date expiredTime = new Date(System.currentTimeMillis() + expireHours * 3600000);
return Jwts.builder()
// 载荷内容
.setClaims(claims)
// 签发时间
.setIssuedAt(new Date())
// 密钥
.signWith(getSecretKey(), SignatureAlgorithm.HS256)
// 过期时间
.setExpiration(expiredTime)
.compact();
}
/**
* 解析token
*
* @param token
* @return
*/
public static Claims parseToken(String token) {
return Jwts.parserBuilder()
.setSigningKey(getSecretKey())
.build()
.parseClaimsJws(token)
.getBody();
}
/**
* 校验token是否合法
*
* @param token
* @return
*/
public static boolean validateToken(String token) {
try {
Jwts.parserBuilder()
.setSigningKey(getSecretKey())
.build()
.parseClaimsJws(token);
} catch (ExpiredJwtException
| UnsupportedJwtException
| MalformedJwtException
| SignatureException
| IllegalArgumentException e) {
log.error("校验token失败！{}", e.getMessage());
return false;
}
return true;
}
/**
* token是否已过期
*
* @param token
* @return true：已过期，false：未过期
*/
public static boolean isExpire(String token) {
Date expirationDate = Jwts.parserBuilder()
.setSigningKey(getSecretKey())
.build()
.parseClaimsJws(token)
.getBody()
.getExpiration();
return expirationDate.before(new Date());
}
/**
* 获取base64Url进行编码后的密钥
*
* @return
*/
private static Key getSecretKey() {
return Keys.hmacShaKeyFor(Decoders.BASE64URL.decode(SECRET));
}
}
2.2 jwt+rsa
-
rsa工具类
import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.security.*; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; import java.util.Base64; /** * Rsa工具类 */ public class RsaUtils { private static final int DEFAULT_KEY_SIZE = 2048; /** * 从文件中读取公钥 * * @param filename 公钥保存路径，相对于classpath * @return PublicKey 公钥对象 * @throws Exception */ public static PublicKey getPublicKey(String filename) throws Exception { byte[] bytes = readFile(filename); return getPublicKey(bytes); } /** * 从文件中读取密钥 * * @param filename 私钥保存路径，相对于classpath * @return PrivateKey 私钥对象 * @throws Exception */ public static PrivateKey getPrivateKey(String filename) throws Exception { byte[] bytes = readFile(filename); return getPrivateKey(bytes); } /** * 获取公钥 * 公钥的字节形式。 * * @param bytes 公钥的字节形式 * @return * @throws Exception */ private static PublicKey getPublicKey(byte[] bytes) throws Exception { bytes = Base64.getDecoder().decode(bytes); X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes); KeyFactory factory = KeyFactory.getInstance("RSA"); return factory.generatePublic(spec); } /** * 获取密钥 * * @param bytes 私钥的字节形式 * @return * @throws Exception */ private static PrivateKey getPrivateKey(byte[] bytes) throws NoSuchAlgorithmException, InvalidKeySpecException { bytes = Base64.getDecoder().decode(bytes); PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes); KeyFactory factory = KeyFactory.getInstance("RSA"); return factory.generatePrivate(spec); } /** * 根据密文，生存rsa公钥和私钥,并写入指定文件 * * @param publicKeyFilename 公钥文件路径 * @param privateKeyFilename 私钥文件路径 * @param secret 生成密钥的密文 */ public static void generateKeyPair(String publicKeyFilename, String privateKeyFilename, String secret, int keySize) throws Exception { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); SecureRandom secureRandom = new SecureRandom(secret.getBytes()); keyPairGenerator.initialize(Math.max(keySize, DEFAULT_KEY_SIZE), secureRandom); KeyPair keyPair = keyPairGenerator.genKeyPair(); // 获取公钥并写出 byte[] publicKeyBytes = keyPair.getPublic().getEncoded(); publicKeyBytes = Base64.getEncoder().encode(publicKeyBytes); writeFile(publicKeyFilename, publicKeyBytes); // 获取私钥并写出 byte[] privateKeyBytes = keyPair.getPrivate().getEncoded(); privateKeyBytes = Base64.getEncoder().encode(privateKeyBytes); writeFile(privateKeyFilename, privateKeyBytes); } private static byte[] readFile(String fileName) throws Exception { return Files.readAllBytes(new File(fileName).toPath()); } private static void writeFile(String destPath, byte[] bytes) throws IOException { File dest = new File(destPath); if (!dest.exists()) { dest.createNewFile(); Files.write(dest.toPath(), bytes); } } }
2.3 jwt工具类
import io.jsonwebtoken.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Date;
import java.util.Map;
/**
* @Description:
* @Author party-abu
* @Date 2022/1/29 23:43
*/
public class JwtUtils02 {
private static final Logger log = LoggerFactory.getLogger(JwtUtils02.class);
/**
* 私钥加密
*
* @param claims
* @param privateKey
* @param expireHours
* @return
*/
public static String generateToken(Map<String, Object> claims, PrivateKey privateKey, Long expireHours) {
return Jwts.builder()
.setClaims(claims)
.signWith(privateKey, SignatureAlgorithm.RS256)
.setExpiration(new Date(System.currentTimeMillis() + expireHours * 3600000))
.compact();
}
/**
* 公钥解密
*
* @param token
* @param publicKey
* @return
*/
public static Claims parseToken(String token, PublicKey publicKey) {
return Jwts.parserBuilder()
.setSigningKey(publicKey)
.build()
.parseClaimsJws(token)
.getBody();
}
/**
* 校验token是否合法
*
* @param token
* @param publicKey
* @return
*/
public static boolean validateToken(String token, PublicKey publicKey) {
try {
Jwts.parserBuilder()
.setSigningKey(publicKey)
.build()
.parseClaimsJws(token);
} catch (ExpiredJwtException
| UnsupportedJwtException
| MalformedJwtException
| IllegalArgumentException e) {
log.error("校验token失败！{}", e.getMessage());
return false;
}
return true;
}
/**
* token是否已过期
*
* @param token
* @return true：已过期，false：未过期
*/
public static boolean isExpire(String token, PublicKey publicKey) {
Date expirationDate = Jwts.parserBuilder()
.setSigningKey(publicKey)
.build()
.parseClaimsJws(token)
.getBody()
.getExpiration();
return expirationDate.before(new Date());
}
}
