JWT
把书本读薄，简单介绍一下JWT所具备的特征，最好提前了解 “编码”、“摘要” 和 “加密” 的区别。
JWT简介
JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA or ECDSA.
JWT是一种设计令牌的开放标准。（开发标准，就意味着可以有多种实现）
JWT结构
JWT分为3段，用“.”连接，其中：“头部”和“载荷”通过Base64进行编码的，“签名”是将前2段连接在一起，通过加密算法得出的校验码。
HEADER(头部).PAYLOAD(载荷).SIGNATURE(签名)
头部
Base64解码后是一段JSON，用于说明jwt所采用的算法
alg: HS256
typ: JWT
载荷
Base64解码后是一段JSON，用于存储jwt的详细信息，字段只是推荐，并没有强制要求这些字段必须存在
iss：发行人
exp：token的到期时间
sub：主题
aud：用户
nbf：token在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT
签名
“头部” 和 “载荷” 使用Base64编码，编码并不是加密，用户可以随时解码，查看里面的内容。
允许用户看 token 的内容，又不允许他们修改，这就是 “签名” 的作用：防止用户伪造token。
比如：token 过期了，用户偷偷修改了 token 的有效期，这时候，服务器只要把数据再加密一遍，如果加密的结果不一致，就说明token被修改过。
（这里说的加密，可以是摘要算法，也可以使加密算法）
DEMO
自带的加密算法有这么多：none、HS256、HS384、HS512、RS256、RS384、RS512、ES256、ES384、ES512、PS256、PS384、PS512。
挑2个展示效果，对称加密HS256，非对称加密RS256。
Maven依赖
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.17.0</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
HS256
对称加密，加密和解密需要相同的密钥。
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import javax.crypto.SecretKey;
import java.util.Base64;
import java.util.Date;
/**
* @author Mr.css
* @date 2022-01-05 15:03
*/
public class JwtHS256 {
// /**
// * 生成密钥
// *
// * @param key 长度必须是32的倍数
// * @return SecretKey
// * @throws IllegalArgumentException -
// */
// public static SecretKey generateSecretKey(byte[] key) {
// if (key.length % 32 != 0) {
// throw new IllegalArgumentException("key size must be a multiple of 32");
// }
// return new SecretKeySpec(key, "AES");
// }
/**
* 密钥，更复杂地，应该将密钥交由数据库管理
*/
private static SecretKey secretKey = AES.generateSecretKey(MD5.hexBit32("this is a secret key!").getBytes());
/**
* 生成jwt
*
* @param id ID
* @param subject 主题
* @param ttlMillis 超时时间
* @return jwt
*/
public static String encrypt(String id, String subject, long ttlMillis) {
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
JwtBuilder builder = Jwts.builder();
//ID
builder.setId(id);
//主题
builder.setSubject(subject);
// 签发者
builder.setIssuer("system");
// 签发时间
builder.setIssuedAt(now);
// 签名算法以及密匙
builder.signWith(SignatureAlgorithm.HS256, secretKey);
// 设置超时时间
if (ttlMillis >= 0) {
long expMillis = nowMillis + ttlMillis;
Date expDate = new Date(expMillis);
builder.setExpiration(expDate);
}
return builder.compact();
}
/**
* 解析JWT字符串
*
* @param jwt jwt
* @return Claims
*/
public static Claims decrypt(String jwt) {
return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(jwt).getBody();
}
public static void main(String[] args) throws InterruptedException {
//解密
String jwt = encrypt("id", "sub", 3000);
System.out.println(jwt);
//解密
Claims claims = decrypt(jwt);
System.out.println(claims);
//解析头部
System.out.println(
new String(Base64.getDecoder().decode("eyJhbGciOiJIUzI1NiJ9")));
//解析载荷
System.out.println(
new String(Base64.getDecoder().decode("eyJqdGkiOiJpZCIsInN1YiI6InN1YiIsImlzcyI6InN5c3RlbSIsImlhdCI6MTY0MTM3NTc3MywiZXhwIjoxNjQxMzc1Nzc2fQ")));
//5秒之后token失效
Thread.sleep(5000);
claims = decrypt(jwt);
System.out.println(claims);
}
}
RS256
代码上与HS256基本一致。JWT限定了只能用私钥加密，公钥解密。
什么情况下使用RS256？
令牌由其它服务器发出，我们的服务器只负责调用，我们在使用令牌之前，需要验证令牌是可信任的。
（比如：微服务，一个服务器只负责造令牌，其它负责用，使用之前，需要保证令牌是自己人发出来的。）
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.security.*;
import java.util.Date;
/**
* @author Mr.css
* @date 2022-01-05 15:03
*/
public class JwtRS256 {
/**
* 公钥/私钥一般交由数据库管理
*/
private static PublicKey publicKey;
private static PrivateKey privateKey;
// /**
// * 获取密钥对
// *
// * @param initialize 长度，1024
// * @return 密钥对
// */
// public static KeyPair getKeyPair(int initialize) throws GeneralSecurityException {
// KeyPairGenerator keyPairGen;
// keyPairGen = KeyPairGenerator.getInstance("RSA");
// keyPairGen.initialize(initialize);
// return keyPairGen.generateKeyPair();
// }
static {
try {
KeyPair keyPair = RSA.getKeyPair();
publicKey = keyPair.getPublic();
privateKey = keyPair.getPrivate();
} catch (GeneralSecurityException e) {
e.printStackTrace();
}
}
/**
* 生成jwt
*
* @param id ID
* @param subject 主题
* @param ttlMillis 超时时间
* @return jwt
*/
public static String encrypt(String id, String subject, long ttlMillis) {
Date now = new Date();
JwtBuilder builder = Jwts.builder();
//ID
builder.setId(id);
//主题
builder.setSubject(subject);
// 签发者
builder.setIssuer("system");
// 签发时间
builder.setIssuedAt(now);
// 签名算法以及密匙
builder.signWith(SignatureAlgorithm.RS256, privateKey);
// 设置超时时间
if (ttlMillis >= 0) {
long expMillis = now.getTime() + ttlMillis;
Date expDate = new Date(expMillis);
builder.setExpiration(expDate);
}
return builder.compact();
}
/**
* 解析JWT字符串
*
* @param jwt jwt
* @return Claims
*/
public static Claims decrypt(String jwt) {
return Jwts.parser().setSigningKey(publicKey).parseClaimsJws(jwt).getBody();
}
public static void main(String[] args) throws InterruptedException {
//加密
String jwt = encrypt("id", "sub", 3000);
System.out.println(jwt);
//解密
Claims claims = decrypt(jwt);
System.out.println(claims);
//暂停5秒再解密，超时报错
Thread.sleep(5000);
claims = decrypt(jwt);
System.out.println(claims);
}
}
公钥/私钥——字符串和对象的转换
/**
* 获取公钥字符串
*/
public static String getPublicKey(KeyPair keyPair) {
return Base64.encodeString(keyPair.getPublic().getEncoded());
}
/**
* 获取私钥字符串
*/
public static String getPrivateKey(KeyPair keyPair) {
return Base64.encodeString(keyPair.getPrivate().getEncoded());
}
/**
* 获取公钥对象
*
* @param publicKey 公钥字符串
* @return 公钥
* @throws GeneralSecurityException -
*/
public static PublicKey generatePublicKey(String publicKey) throws GeneralSecurityException {
byte[] keyBytes = Base64.decodeString(publicKey);
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory factory = KeyFactory.getInstance("RSA");
return factory.generatePublic(x509EncodedKeySpec);
}
/**
* 获取私钥对象
*
* @param privateKey 私钥字符串
* @return 私钥
* @throws GeneralSecurityException -
*/
public static PrivateKey generatePrivateKey(String privateKey) throws GeneralSecurityException {
byte[] keyBytes = Base64.decodeString(privateKey);
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory factory = KeyFactory.getInstance("RSA");
return factory.generatePrivate(pkcs8EncodedKeySpec);
}
疯狂的妞妞 ：每一天，做什么都好，不要什么都不做！
