zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

add jwt

Browse Source
This commit is contained in:
Looly
2021-06-10 22:54:45 +08:00
parent f07a452e3a
commit 93b383c2b7
27 changed files with 1390 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
hutool-jwt/pom.xml
View File

@@ -14,6 +14,11 @@
<name>${project.artifactId}</name>
<description>Hutool JWT生成、解析和验证实现</description>
<properties>
<!-- versions -->
<bouncycastle.version>1.68</bouncycastle.version>
</properties>
<dependencies>
<dependency>
<groupId>cn.hutool</groupId>
@@ -25,5 +30,11 @@
<artifactId>hutool-crypto</artifactId>
<version>${project.parent.version}</version>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15to18</artifactId>
<version>${bouncycastle.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

40
hutool-jwt/src/main/java/cn/hutool/jwt/Claims.java
View File

@@ -1,19 +1,25 @@
package cn.hutool.jwt;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.Map;
/**
* Claims 认证，简单的JSONObject包装
*
* @author looly
* @since 5.7.0
*/
public class Claims implements Serializable {
private static final long serialVersionUID = 1L;
private final JSONObject claimJSON;
private JSONObject claimJSON;
public Claims() {
this.claimJSON = new JSONObject();
@@ -34,6 +40,28 @@ public class Claims implements Serializable {
claimJSON.set(name, value);
}
/**
* 加入多个Claims属性
* @param headerClaims 多个Claims属性
*/
protected void putAll(Map<String, ?> headerClaims){
if (MapUtil.isNotEmpty(headerClaims)) {
for (Map.Entry<String, ?> entry : headerClaims.entrySet()) {
setClaim(entry.getKey(), entry.getValue());
}
}
}
/**
* 获取指定名称属性
*
* @param name 名称
* @return 属性
*/
public Object getClaim(String name) {
return this.claimJSON.getObj(name);
}
/**
* 获取Claims的JSON字符串形式
*
@@ -42,4 +70,14 @@ public class Claims implements Serializable {
public String getClaimsJson() {
return this.claimJSON.toString();
}
/**
* 解析JWT JSON
*
* @param tokenPart JWT JSON
* @param charset 编码
*/
public void parse(String tokenPart, Charset charset) {
this.claimJSON = JSONUtil.parseObj(Base64.decodeStr(tokenPart, charset));
}
}

194
hutool-jwt/src/main/java/cn/hutool/jwt/JWT.java
View File

@@ -1,11 +1,18 @@
package cn.hutool.jwt;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.jwt.signers.AlgorithmUtil;
import cn.hutool.jwt.signers.JWTSigner;
import cn.hutool.jwt.signers.JWTSignerUtil;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Map;
/**
* JSON Web Token (JWT)，基于JSON的开放标准（(RFC 7519)用于在网络应用环境间传递声明。<br>
@@ -31,6 +38,26 @@ public class JWT {
private Charset charset;
private JWTSigner signer;
private List<String> tokens;
/**
* 创建空的JWT对象
*
* @return {@link JWT}
*/
public static JWT create() {
return new JWT();
}
/**
* 创建并解析JWT对象
*
* @return {@link JWT}
*/
public static JWT of(String token) {
return new JWT(token);
}
/**
* 构造
*/
@@ -40,6 +67,28 @@ public class JWT {
this.charset = CharsetUtil.CHARSET_UTF_8;
}
/**
* 构造
*/
public JWT(String token) {
this();
parse(token);
}
/**
* 解析JWT内容
*
* @param token JWT token
* @return this
*/
public JWT parse(String token) {
final List<String> tokens = splitToken(token);
this.tokens = tokens;
this.header.parse(tokens.get(0), this.charset);
this.payload.parse(tokens.get(1), this.charset);
return this;
}
/**
* 设置编码
*
@@ -51,6 +100,27 @@ public class JWT {
return this;
}
/**
* 设置密钥，默认算法是：HS256(HmacSHA256)
*
* @param key 密钥
* @return this
*/
public JWT setKey(byte[] key) {
return setSigner(JWTSignerUtil.hs256(key));
}
/**
* 设置签名算法
*
* @param algorithmId 签名算法ID，如HS256
* @param key 密钥
* @return this
*/
public JWT setSigner(String algorithmId, byte[] key) {
return setSigner(JWTSignerUtil.createSigner(algorithmId, key));
}
/**
* 设置签名算法
*
@@ -62,16 +132,140 @@ public class JWT {
return this;
}
/**
* 获取头信息
*
* @param name 头信息名称
* @return 头信息
*/
public Object getHeader(String name) {
return this.header.getClaim(name);
}
/**
* 设置JWT头信息
*
* @param name 头名
* @param value 头
* @return this
*/
public JWT setHeader(String name, Object value) {
this.header.setClaim(name, value);
return this;
}
/**
* 增加JWT头信息
*
* @param headers 头信息
* @return this
*/
public JWT addHeaders(Map<String, ?> headers) {
this.header.addHeaders(headers);
return this;
}
/**
* 获取载荷信息
*
* @param name 载荷信息名称
* @return 载荷信息
*/
public Object getPayload(String name) {
return this.payload.getClaim(name);
}
/**
* 设置JWT载荷信息
*
* @param name 载荷名
* @param value 头
* @return this
*/
public JWT setPayload(String name, Object value) {
this.payload.setClaim(name, value);
return this;
}
/**
* 增加JWT载荷信息
*
* @param payloads 载荷信息
* @return this
*/
public JWT addPayloads(Map<String, ?> payloads) {
this.payload.addPayloads(payloads);
return this;
}
/**
* 签名生成JWT字符串
*
* @return JWT字符串
*/
public String sign() {
return sign(this.signer);
}
/**
* 签名生成JWT字符串
*
* @param signer JWT签名器
* @return JWT字符串
*/
public String sign(JWTSigner signer) {
Assert.notNull(signer, () -> new JWTException("No Signer provided!"));
// 检查头信息中是否有算法信息
final String claim = (String) this.header.getClaim(JWTHeader.ALGORITHM);
if (StrUtil.isBlank(claim)) {
this.header.setClaim(JWTHeader.ALGORITHM,
AlgorithmUtil.getId(signer.getAlgorithm()));
}
final String headerBase64 = Base64.encodeUrlSafe(this.header.getClaimsJson(), charset);
final String payloadBase64 = Base64.encodeUrlSafe(this.payload.getClaimsJson(), charset);
final String sign = signer.sign(headerBase64, payloadBase64);
return StrUtil.format("{}.{}.{}", headerBase64, payloadBase64, sign);
}
/**
* 验证JWT Token是否有效
*
* @return 是否有效
*/
public boolean verify() {
return verify(this.signer);
}
/**
* 验证JWT Token是否有效
*
* @param signer 签名器（签名算法）
* @return 是否有效
*/
public boolean verify(JWTSigner signer) {
Assert.notNull(signer, () -> new JWTException("No Signer provided!"));
final List<String> tokens = this.tokens;
if(CollUtil.isEmpty(tokens)){
throw new JWTException("No token to verify!");
}
return signer.verify(tokens.get(0), tokens.get(1), tokens.get(2));
}
/**
* 将JWT字符串拆分为3部分，无加密算法则最后一部分是""
*
* @param token JWT Token
* @return 三部分内容
*/
private static List<String> splitToken(String token) {
final List<String> tokens = StrUtil.split(token, CharUtil.DOT);
if (3 != tokens.size()) {
throw new JWTException("The token was expected 3 parts, but got {}.", tokens.size());
}
return tokens;
}
}

34
hutool-jwt/src/main/java/cn/hutool/jwt/JWTException.java Normal file
View File

@@ -0,0 +1,34 @@
package cn.hutool.jwt;
import cn.hutool.core.exceptions.ExceptionUtil;
import cn.hutool.core.util.StrUtil;
/**
* JWT异常
*
* @author looly
* @since 5.7.0
*/
public class JWTException extends RuntimeException {
private static final long serialVersionUID = 1L;
public JWTException(Throwable e) {
super(ExceptionUtil.getMessage(e), e);
}
public JWTException(String message) {
super(message);
}
public JWTException(String messageTemplate, Object... params) {
super(StrUtil.format(messageTemplate, params));
}
public JWTException(String message, Throwable cause) {
super(message, cause);
}
public JWTException(Throwable throwable, String messageTemplate, Object... params) {
super(StrUtil.format(messageTemplate, params), throwable);
}
}

17
hutool-jwt/src/main/java/cn/hutool/jwt/JWTHeader.java
View File

@@ -6,6 +6,7 @@ import java.util.Map;
* JWT头部信息
*
* @author looly
* @since 5.7.0
*/
public class JWTHeader extends Claims {
private static final long serialVersionUID = 1L;
@@ -28,6 +29,13 @@ public class JWTHeader extends Claims {
*/
public static String KEY_ID = "kid";
/**
* 构造，初始化默认(typ=JWT)
*/
public JWTHeader() {
setClaim(TYPE, "JWT");
}
/**
* 增加“kid”头信息
*
@@ -46,14 +54,7 @@ public class JWTHeader extends Claims {
* @return this
*/
public JWTHeader addHeaders(Map<String, ?> headerClaims) {
if (headerClaims == null) {
return this;
}
for (Map.Entry<String, ?> entry : headerClaims.entrySet()) {
setClaim(entry.getKey(), entry.getValue());
}
putAll(headerClaims);
return this;
}
}

12
hutool-jwt/src/main/java/cn/hutool/jwt/JWTPayload.java
View File

@@ -16,6 +16,7 @@ import java.util.Map;
* 详细介绍见：https://www.jianshu.com/p/576dbf44b2ae
*
* @author looly
* @since 5.7.0
*/
public class JWTPayload extends Claims {
private static final long serialVersionUID = 1L;
@@ -134,15 +135,8 @@ public class JWTPayload extends Claims {
* @param payloadClaims 载荷信息
* @return this
*/
public JWTPayload addPayload(Map<String, ?> payloadClaims) {
if (payloadClaims == null) {
return this;
}
for (Map.Entry<String, ?> entry : payloadClaims.entrySet()) {
setClaim(entry.getKey(), entry.getValue());
}
public JWTPayload addPayloads(Map<String, ?> payloadClaims) {
putAll(payloadClaims);
return this;
}
}

97
hutool-jwt/src/main/java/cn/hutool/jwt/JWTUtil.java Normal file
View File

@@ -0,0 +1,97 @@
package cn.hutool.jwt;
import cn.hutool.jwt.signers.JWTSigner;
import java.util.Map;
/**
* JSON Web Token (JWT)工具类
*/
public class JWTUtil {
/**
* 创建HS256(HmacSHA256) JWT Token
*
* @param payload 荷载信息
* @param key HS256(HmacSHA256)密钥
* @return JWT Token
*/
public static String createToken(Map<String, Object> payload, byte[] key) {
return createToken(null, payload, key);
}
/**
* 创建HS256(HmacSHA256) JWT Token
*
* @param headers 头信息
* @param payload 荷载信息
* @param key HS256(HmacSHA256)密钥
* @return JWT Token
*/
public static String createToken(Map<String, Object> headers, Map<String, Object> payload, byte[] key) {
return JWT.create()
.addHeaders(headers)
.addPayloads(payload)
.setKey(key)
.sign();
}
/**
* 创建JWT Token
*
* @param payload 荷载信息
* @param signer 签名算法
* @return JWT Token
*/
public static String createToken(Map<String, Object> payload, JWTSigner signer) {
return createToken(null, payload, signer);
}
/**
* 创建JWT Token
*
* @param headers 头信息
* @param payload 荷载信息
* @param signer 签名算法
* @return JWT Token
*/
public static String createToken(Map<String, Object> headers, Map<String, Object> payload, JWTSigner signer) {
return JWT.create()
.addHeaders(headers)
.addPayloads(payload)
.setSigner(signer)
.sign();
}
/**
* 解析JWT Token
*
* @param token token
* @return {@link JWT}
*/
public JWT parseToken(String token) {
return JWT.of(token);
}
/**
* 验证JWT Token有效性
*
* @param token JWT Token
* @param key HS256(HmacSHA256)密钥
* @return 是否有效
*/
public boolean verify(String token, byte[] key) {
return JWT.of(token).setKey(key).verify();
}
/**
* 验证JWT Token有效性
*
* @param token JWT Token
* @param signer 签名器
* @return 是否有效
*/
public boolean verify(String token, JWTSigner signer) {
return JWT.of(token).verify(signer);
}
}

76
hutool-jwt/src/main/java/cn/hutool/jwt/signers/AlgorithmUtil.java Normal file
View File

@@ -0,0 +1,76 @@
package cn.hutool.jwt.signers;
import cn.hutool.core.map.BiMap;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.crypto.asymmetric.SignAlgorithm;
import cn.hutool.crypto.digest.HmacAlgorithm;
import java.util.HashMap;
/**
* 算法工具类，算法和JWT算法ID对应表
*
* @author looly
* @since 5.7.0
*/
public class AlgorithmUtil {
private static final BiMap<String, String> map;
static {
map = new BiMap<>(new HashMap<>());
map.put("HS256", HmacAlgorithm.HmacSHA256.getValue());
map.put("HS384", HmacAlgorithm.HmacSHA384.getValue());
map.put("HS512", HmacAlgorithm.HmacSHA512.getValue());
map.put("RS256", SignAlgorithm.SHA256withRSA.getValue());
map.put("RS384", SignAlgorithm.SHA384withRSA.getValue());
map.put("RS512", SignAlgorithm.SHA512withRSA.getValue());
map.put("ES256", SignAlgorithm.SHA256withECDSA.getValue());
map.put("ES384", SignAlgorithm.SHA384withECDSA.getValue());
map.put("ES512", SignAlgorithm.SHA512withECDSA.getValue());
map.put("PS256", SignAlgorithm.SHA256withRSA_PSS.getValue());
map.put("PS384", SignAlgorithm.SHA384withRSA_PSS.getValue());
map.put("PS512", SignAlgorithm.SHA512withRSA_PSS.getValue());
}
/**
* 获取算法，用户传入算法ID返回算法名，传入算法名返回本身
* @param idOrAlgorithm 算法ID或算法名
* @return 算法名
*/
public static String getAlgorithm(String idOrAlgorithm){
return ObjectUtil.defaultIfNull(getAlgorithmById(idOrAlgorithm), idOrAlgorithm);
}
/**
* 获取算法ID，用户传入算法名返回ID，传入算法ID返回本身
* @param idOrAlgorithm 算法ID或算法名
* @return 算法ID
*/
public static String getId(String idOrAlgorithm){
return ObjectUtil.defaultIfNull(getIdByAlgorithm(idOrAlgorithm), idOrAlgorithm);
}
/**
* 根据JWT算法ID获取算法
*
* @param id JWT算法ID
* @return 算法
*/
private static String getAlgorithmById(String id) {
return map.get(id.toUpperCase());
}
/**
* 根据算法获取JWT算法ID
*
* @param algorithm 算法
* @return JWT算法ID
*/
private static String getIdByAlgorithm(String algorithm) {
return map.getInverse().get(algorithm);
}
}

75
hutool-jwt/src/main/java/cn/hutool/jwt/signers/AsymmetricJWTSigner.java Normal file
View File

@@ -0,0 +1,75 @@
package cn.hutool.jwt.signers;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.asymmetric.Sign;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* 非对称加密JWT签名封装
*
* @author looly
* @since 5.7.0
*/
public class AsymmetricJWTSigner implements JWTSigner {
private Charset charset = CharsetUtil.CHARSET_UTF_8;
private final Sign sign;
/**
* 构造
*
* @param algorithm 算法字符串表示
* @param key 公钥{@link PublicKey}或私钥{@link PrivateKey}，公钥用于验证签名，私钥用于产生签名
*/
public AsymmetricJWTSigner(String algorithm, Key key) {
final PublicKey publicKey = key instanceof PublicKey ? (PublicKey) key : null;
final PrivateKey privateKey = key instanceof PrivateKey ? (PrivateKey) key : null;
this.sign = new Sign(algorithm, privateKey, publicKey);
}
/**
* 构造
*
* @param algorithm 算法字符串表示
* @param keyPair 密钥对
*/
public AsymmetricJWTSigner(String algorithm, KeyPair keyPair) {
this.sign = new Sign(algorithm, keyPair);
}
/**
* 设置编码
*
* @param charset 编码
* @return 编码
*/
public AsymmetricJWTSigner setCharset(Charset charset) {
this.charset = charset;
return this;
}
@Override
public String sign(String headerBase64, String payloadBase64) {
return Base64.encodeUrlSafe(sign.sign(StrUtil.format("{}.{}", headerBase64, payloadBase64)));
}
@Override
public boolean verify(String headerBase64, String payloadBase64, String signBase64) {
return sign.verify(
StrUtil.bytes(StrUtil.format("{}.{}", headerBase64, payloadBase64), charset),
Base64.decode(signBase64));
}
@Override
public String getAlgorithm() {
return this.sign.getSignature().getAlgorithm();
}
}

69
hutool-jwt/src/main/java/cn/hutool/jwt/signers/HMacJWTSigner.java Normal file
View File

@@ -0,0 +1,69 @@
package cn.hutool.jwt.signers;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.digest.HMac;
import java.nio.charset.Charset;
import java.security.Key;
/**
* HMac算法签名实现
*
* @author looly
* @since 5.7.0
*/
public class HMacJWTSigner implements JWTSigner {
private Charset charset = CharsetUtil.CHARSET_UTF_8;
private final HMac hMac;
/**
* 构造
*
* @param algorithm HMAC签名算法
* @param key 密钥
*/
public HMacJWTSigner(String algorithm, byte[] key) {
this.hMac = new HMac(algorithm, key);
}
/**
* 构造
*
* @param algorithm HMAC签名算法
* @param key 密钥
*/
public HMacJWTSigner(String algorithm, Key key) {
this.hMac = new HMac(algorithm, key);
}
/**
* 设置编码
*
* @param charset 编码
* @return 编码
*/
public HMacJWTSigner setCharset(Charset charset) {
this.charset = charset;
return this;
}
@Override
public String sign(String headerBase64, String payloadBase64) {
return hMac.digestHex(StrUtil.format("{}.{}", headerBase64, payloadBase64), charset);
}
@Override
public boolean verify(String headerBase64, String payloadBase64, String signBase64) {
final String sign = sign(headerBase64, payloadBase64);
return hMac.verify(
StrUtil.bytes(sign, charset),
StrUtil.bytes(signBase64, charset));
}
@Override
public String getAlgorithm() {
return this.hMac.getAlgorithm();
}
}

24
hutool-jwt/src/main/java/cn/hutool/jwt/signers/JWTSigner.java
View File

@@ -9,9 +9,27 @@ public interface JWTSigner {
/**
* 签名
* @param header JWT头的JSON字符串
* @param payload JWT载荷的JSON字符串
*
* @param headerBase64 JWT头的JSON字符串的Base64表示
* @param payloadBase64 JWT载荷的JSON字符串Base64表示
* @return 签名结果，即JWT的第三部分
*/
String sign(String header, String payload);
String sign(String headerBase64, String payloadBase64);
/**
* 验签
*
* @param headerBase64 JWT头的JSON字符串Base64表示
* @param payloadBase64 JWT载荷的JSON字符串Base64表示
* @param signBase64 被验证的签名Base64表示
* @return 签名是否一致
*/
boolean verify(String headerBase64, String payloadBase64, String signBase64);
/**
* 获取算法
*
* @return 算法
*/
String getAlgorithm();
}

164
hutool-jwt/src/main/java/cn/hutool/jwt/signers/JWTSignerUtil.java Normal file
View File

@@ -0,0 +1,164 @@
package cn.hutool.jwt.signers;
import cn.hutool.core.lang.Assert;
import java.security.Key;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* JWT签名器工具类
*
* @author looly
* @since 5.7.0
*/
public class JWTSignerUtil {
/**
* 无签名
*
* @return 无签名的签名器
*/
public static JWTSigner none() {
return NoneJWTSigner.NONE;
}
//------------------------------------------------------------------------- HSxxx
/**
* HS256(HmacSHA256)签名器
*
* @return 签名器
*/
public static JWTSigner hs256(byte[] key) {
return createSigner("HS256", key);
}
/**
* HS384(HmacSHA384)签名器
*
* @return 签名器
*/
public static JWTSigner hs384(byte[] key) {
return createSigner("HS384", key);
}
/**
* HS512(HmacSHA512)签名器
*
* @return 签名器
*/
public static JWTSigner hs512(byte[] key) {
return createSigner("HS512", key);
}
//------------------------------------------------------------------------- RSxxx
/**
* RS256(SHA256withRSA)签名器
*
* @return 签名器
*/
public static JWTSigner rs256(Key key) {
return createSigner("RS256", key);
}
/**
* RS384(SHA384withRSA)签名器
*
* @return 签名器
*/
public static JWTSigner rs384(Key key) {
return createSigner("RS384", key);
}
/**
* RS512(SHA512withRSA)签名器
*
* @return 签名器
*/
public static JWTSigner rs512(Key key) {
return createSigner("RS512", key);
}
//------------------------------------------------------------------------- ESxxx
/**
* ES256(SHA256withECDSA)签名器
*
* @return 签名器
*/
public static JWTSigner es256(Key key) {
return createSigner("ES256", key);
}
/**
* ES384(SHA383withECDSA)签名器
*
* @return 签名器
*/
public static JWTSigner es384(Key key) {
return createSigner("ES384", key);
}
/**
* ES512(SHA512withECDSA)签名器
*
* @return 签名器
*/
public static JWTSigner es512(Key key) {
return createSigner("ES512", key);
}
/**
* 创建签名器
*
* @param algorithmId 算法ID，见{@link AlgorithmUtil}
* @param key 密钥
* @return 签名器
*/
public static JWTSigner createSigner(String algorithmId, byte[] key) {
Assert.notNull(key, "Signer key must be not null!");
if (null == algorithmId || NoneJWTSigner.ID_NONE.equals(algorithmId)) {
return none();
}
return new HMacJWTSigner(AlgorithmUtil.getAlgorithm(algorithmId), key);
}
/**
* 创建签名器
*
* @param algorithmId 算法ID，见{@link AlgorithmUtil}
* @param keyPair 密钥对
* @return 签名器
*/
public static JWTSigner createSigner(String algorithmId, KeyPair keyPair) {
Assert.notNull(keyPair, "Signer key pair must be not null!");
if (null == algorithmId || NoneJWTSigner.ID_NONE.equals(algorithmId)) {
return none();
}
return new AsymmetricJWTSigner(AlgorithmUtil.getAlgorithm(algorithmId), keyPair);
}
/**
* 创建签名器
*
* @param algorithmId 算法ID，见{@link AlgorithmUtil}
* @param key 密钥
* @return 签名器
*/
public static JWTSigner createSigner(String algorithmId, Key key) {
Assert.notNull(key, "Signer key must be not null!");
if (null == algorithmId || NoneJWTSigner.ID_NONE.equals(algorithmId)) {
return NoneJWTSigner.NONE;
}
if (key instanceof PrivateKey || key instanceof PublicKey) {
return new AsymmetricJWTSigner(AlgorithmUtil.getAlgorithm(algorithmId), key);
}
return new HMacJWTSigner(AlgorithmUtil.getAlgorithm(algorithmId), key);
}
}

31
hutool-jwt/src/main/java/cn/hutool/jwt/signers/NoneJWTSigner.java Normal file
View File

@@ -0,0 +1,31 @@
package cn.hutool.jwt.signers;
import cn.hutool.core.util.StrUtil;
/**
* 无需签名的JWT签名器
*
* @author looly
* @since 5.7.0
*/
public class NoneJWTSigner implements JWTSigner {
public static final String ID_NONE = "none";
public static NoneJWTSigner NONE = new NoneJWTSigner();
@Override
public String sign(String headerBase64, String payloadBase64) {
return StrUtil.EMPTY;
}
@Override
public boolean verify(String headerBase64, String payloadBase64, String signBase64) {
return StrUtil.isEmpty(signBase64);
}
@Override
public String getAlgorithm() {
return ID_NONE;
}
}

121
hutool-jwt/src/test/java/cn/hutool/jwt/JWTSignerTest.java Normal file
View File

@@ -0,0 +1,121 @@
package cn.hutool.jwt;
import cn.hutool.crypto.KeyUtil;
import cn.hutool.jwt.signers.AlgorithmUtil;
import cn.hutool.jwt.signers.JWTSigner;
import cn.hutool.jwt.signers.JWTSignerUtil;
import org.junit.Assert;
import org.junit.Test;
public class JWTSignerTest {
@Test
public void hs256Test(){
String id = "hs256";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKey(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void hs384Test(){
String id = "hs384";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKey(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void hs512Test(){
String id = "hs512";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKey(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void rs256Test(){
String id = "rs256";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void rs384Test(){
String id = "rs384";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void rs512Test(){
String id = "rs512";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void es256Test(){
String id = "es256";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void es384Test(){
String id = "es384";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void es512Test(){
String id = "es512";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void ps256Test(){
String id = "ps256";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
@Test
public void ps384Test(){
String id = "ps384";
final JWTSigner signer = JWTSignerUtil.createSigner(id, KeyUtil.generateKeyPair(AlgorithmUtil.getAlgorithm(id)));
Assert.assertEquals(AlgorithmUtil.getAlgorithm(id), signer.getAlgorithm());
signAndVerify(signer);
}
private static void signAndVerify(JWTSigner signer){
JWT jwt = JWT.create()
.setPayload("sub", "1234567890")
.setPayload("name", "looly")
.setPayload("admin", true)
.setSigner(signer);
String token = jwt.sign();
Assert.assertTrue(JWT.of(token).setSigner(signer).verify());
}
}

76
hutool-jwt/src/test/java/cn/hutool/jwt/JWTTest.java Normal file
View File

@@ -0,0 +1,76 @@
package cn.hutool.jwt;
import cn.hutool.jwt.signers.JWTSignerUtil;
import org.junit.Assert;
import org.junit.Test;
public class JWTTest {
@Test
public void createHs256Test(){
byte[] key = "1234567890".getBytes();
JWT jwt = JWT.create()
.setPayload("sub", "1234567890")
.setPayload("name", "looly")
.setPayload("admin", true)
.setKey(key);
String rightToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9." +
"eyJzdWIiOiIxMjM0NTY3ODkwIiwiYWRtaW4iOnRydWUsIm5hbWUiOiJsb29seSJ9." +
"536690902d931d857d2f47d337ec81048ee09a8e71866bcc8404edbbcbf4cc40";
String token = jwt.sign();
Assert.assertEquals(token, token);
Assert.assertTrue(JWT.of(rightToken).setKey(key).verify());
}
@Test
public void parseTest(){
String rightToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9." +
"eyJzdWIiOiIxMjM0NTY3ODkwIiwiYWRtaW4iOnRydWUsIm5hbWUiOiJsb29seSJ9." +
"536690902d931d857d2f47d337ec81048ee09a8e71866bcc8404edbbcbf4cc40";
final JWT jwt = JWT.of(rightToken);
//header
Assert.assertEquals("JWT", jwt.getHeader(JWTHeader.TYPE));
Assert.assertEquals("HS256", jwt.getHeader(JWTHeader.ALGORITHM));
Assert.assertNull(jwt.getHeader(JWTHeader.CONTENT_TYPE));
//payload
Assert.assertEquals("1234567890", jwt.getPayload("sub"));
Assert.assertEquals("looly", jwt.getPayload("name"));
Assert.assertEquals(true, jwt.getPayload("admin"));
}
@Test
public void createNoneTest(){
JWT jwt = JWT.create()
.setPayload("sub", "1234567890")
.setPayload("name", "looly")
.setPayload("admin", true)
.setSigner(JWTSignerUtil.none());
String rightToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9." +
"eyJzdWIiOiIxMjM0NTY3ODkwIiwiYWRtaW4iOnRydWUsIm5hbWUiOiJsb29seSJ9.";
String token = jwt.sign();
Assert.assertEquals(token, token);
Assert.assertTrue(JWT.of(rightToken).setSigner(JWTSignerUtil.none()).verify());
}
/**
* 必须定义签名器
*/
@Test(expected = JWTException.class)
public void needSignerTest(){
JWT jwt = JWT.create()
.setPayload("sub", "1234567890")
.setPayload("name", "looly")
.setPayload("admin", true);
jwt.sign();
}
}