use super::*;
use crate::error::GarrisonError;
const NBF_RETRY_WAIT_SECS: u64 = 35;
const NBF_RETRY_ATTEMPTS: usize = 3;
pub(crate) fn verify_ok(handler: &JwtHandler, token: &str) -> GarrisonJwtClaims {
for attempt in 0..NBF_RETRY_ATTEMPTS {
match handler.verify(token) {
Ok(claims) => return claims,
Err(GarrisonError::InvalidToken(msg)) if msg.contains("jwt-not-yet-valid") => {
if attempt + 1 < NBF_RETRY_ATTEMPTS {
std::thread::sleep(std::time::Duration::from_secs(NBF_RETRY_WAIT_SECS));
} else {
panic!("verify 在墙钟回跳重试后仍 nbf 未生效: {msg}");
}
},
Err(e) => panic!("verify 失败(非 nbf 回跳场景,不重试): {e:?}"),
}
}
unreachable!("重试循环内必然 return 或 panic")
}
fn refresh_ok(handler: &JwtHandler, token: &str, timeout: i64) -> String {
for attempt in 0..NBF_RETRY_ATTEMPTS {
match handler.refresh(token, timeout) {
Ok(new_token) => return new_token,
Err(GarrisonError::InvalidToken(msg)) if msg.contains("jwt-not-yet-valid") => {
if attempt + 1 < NBF_RETRY_ATTEMPTS {
std::thread::sleep(std::time::Duration::from_secs(NBF_RETRY_WAIT_SECS));
} else {
panic!("refresh 在墙钟回跳重试后仍 nbf 未生效: {msg}");
}
},
Err(e) => panic!("refresh 失败(非 nbf 回跳场景,不重试): {e:?}"),
}
}
unreachable!("重试循环内必然 return 或 panic")
}
#[test]
fn claims_serializes_full_fields() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: Some("web".to_string()),
jti: Some("test-jti".to_string()),
nbf: Some(1700000000),
amr: None,
auth_time: None,
tid: None,
};
let json = serde_json::to_string(&claims).unwrap();
assert!(json.contains("\"sub\":\"1001\""));
assert!(json.contains("\"iat\":1700000000"));
assert!(json.contains("\"exp\":1700003600"));
assert!(json.contains("\"login_id\":\"1001\""));
assert!(json.contains("\"device\":\"web\""));
assert!(json.contains("\"jti\":\"test-jti\""));
assert!(json.contains("\"nbf\":1700000000"));
}
#[test]
fn claims_device_none_serializes_as_null() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: None,
jti: None,
nbf: None,
amr: None,
auth_time: None,
tid: None,
};
let json = serde_json::to_string(&claims).unwrap();
assert!(json.contains("\"device\":null"));
assert!(!json.contains("jti"), "jti=None 时不应序列化 jti 字段");
assert!(!json.contains("nbf"), "nbf=None 时不应序列化 nbf 字段");
}
#[test]
fn claims_jti_none_skipped_in_json() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: None,
jti: None,
nbf: None,
amr: None,
auth_time: None,
tid: None,
};
let json = serde_json::to_string(&claims).unwrap();
assert!(!json.contains("jti"));
assert!(!json.contains("nbf"));
}
#[test]
fn sign_generates_unique_jti() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let t1 = handler.sign("1001", 3600).unwrap();
let t2 = handler.sign("1001", 3600).unwrap();
assert_ne!(t1, t2, "jti 应保证同一秒内签发的 token 唯一");
let c1 = verify_ok(&handler, &t1);
let c2 = verify_ok(&handler, &t2);
assert!(c1.jti.is_some(), "sign 生成的 token 应包含 jti");
assert!(c2.jti.is_some());
assert_ne!(c1.jti, c2.jti, "两个 token 的 jti 应不同");
}
#[test]
fn claims_without_jti_deserializes() {
let json =
r#"{"sub":"1001","iat":1700000000,"exp":1700003600,"login_id":"1001","device":"web"}"#;
let claims: GarrisonJwtClaims = serde_json::from_str(json).unwrap();
assert_eq!(claims.sub, "1001");
assert_eq!(claims.jti, None, "无 jti 字段时应反序列化为 None");
}
#[test]
fn claims_deserializes() {
let json =
r#"{"sub":"1001","iat":1700000000,"exp":1700003600,"login_id":"1001","device":"web"}"#;
let claims: GarrisonJwtClaims = serde_json::from_str(json).unwrap();
assert_eq!(claims.sub, "1001");
assert_eq!(claims.iat, 1700000000);
assert_eq!(claims.exp, 1700003600);
assert_eq!(claims.login_id, "1001");
assert_eq!(claims.device, Some("web".to_string()));
}
#[test]
fn new_defaults_to_hs256() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
assert_eq!(handler.algorithm, Algorithm::HS256);
assert_eq!(handler.secret, "0123456789abcdef0123456789abcdef");
assert!(handler.device.is_none());
}
#[test]
fn with_algorithm_switches_to_hs512() {
let handler =
JwtHandler::new("0123456789abcdef0123456789abcdef").with_algorithm(Algorithm::HS512);
assert_eq!(handler.algorithm, Algorithm::HS512);
}
#[test]
fn with_device_sets_device() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef").with_device("ios-app");
assert_eq!(handler.device, Some("ios-app".to_string()));
}
#[test]
fn sign_returns_three_segment_jwt() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
let parts: Vec<&str> = token.split('.').collect();
assert_eq!(parts.len(), 3, "JWT 应由三段组成");
assert!(!parts[0].is_empty());
assert!(!parts[1].is_empty());
assert!(!parts[2].is_empty());
}
#[test]
fn sign_rejects_empty_secret() {
let handler = JwtHandler::new("");
let result = handler.sign("1001", 3600);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(msg)) => assert!(msg.contains("secret")),
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn sign_rejects_negative_timeout() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let result = handler.sign("1001", -1);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(msg)) => assert!(msg.contains("timeout")),
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn sign_with_device_includes_device_in_claims() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef").with_device("ios-app");
let token = handler.sign("1001", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.device, Some("ios-app".to_string()));
}
#[test]
fn verify_valid_token_returns_claims() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.sub, "1001");
assert_eq!(claims.login_id, "1001");
assert!(claims.exp > claims.iat);
}
#[test]
fn verify_tampered_payload_fails() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
let parts: Vec<&str> = token.split('.').collect();
let tampered = format!("{}.{}.{}", parts[0], "ZmFrZS1wYXlsb2Fk", parts[2]);
let result = handler.verify(&tampered);
assert!(result.is_err());
}
#[test]
fn verify_wrong_secret_fails() {
let signer = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = signer.sign("1001", 3600).unwrap();
let verifier = JwtHandler::new("fedcba9876543210fedcba9876543210");
let result = verifier.verify(&token);
assert!(result.is_err());
}
#[test]
fn verify_expired_token_returns_expired_error() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: now - 20,
exp: now - 10, login_id: "1001".to_string(),
device: None,
jti: Some(uuid::Uuid::new_v4().to_string()),
nbf: Some(now - 20),
amr: None,
auth_time: None,
tid: None,
};
let header = jsonwebtoken::Header::new(Algorithm::HS256);
let key = jsonwebtoken::EncodingKey::from_secret(b"0123456789abcdef0123456789abcdef");
let token = jsonwebtoken::encode(&header, &claims, &key).unwrap();
let result = handler.verify(&token);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::ExpiredToken(_)) => {},
other => panic!("期望 ExpiredToken,实际: {:?}", other),
}
}
#[test]
fn verify_algorithm_mismatch_fails() {
let signer =
JwtHandler::new("0123456789abcdef0123456789abcdef").with_algorithm(Algorithm::HS512);
let token = signer.sign("1001", 3600).unwrap();
let verifier = JwtHandler::new("0123456789abcdef0123456789abcdef"); let result = verifier.verify(&token);
assert!(result.is_err());
}
#[test]
fn verify_future_nbf_returns_invalid_token() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: now,
exp: now + 3600,
login_id: "1001".to_string(),
device: None,
jti: Some(uuid::Uuid::new_v4().to_string()),
nbf: Some(now + 10), amr: None,
auth_time: None,
tid: None,
};
let header = jsonwebtoken::Header::new(Algorithm::HS256);
let key = jsonwebtoken::EncodingKey::from_secret(b"0123456789abcdef0123456789abcdef");
let token = jsonwebtoken::encode(&header, &claims, &key).unwrap();
let result = handler.verify(&token);
assert!(result.is_err(), "未来 nbf 应被拒绝: {:?}", result.ok());
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("nbf") || msg.contains("ImmatureSignature") || msg.contains("未生效"),
"错误消息应包含 nbf/ImmatureSignature/未生效,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken,实际: {:?}", other),
}
}
#[test]
fn verify_present_nbf_returns_ok() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert!(claims.nbf.is_some(), "sign 应设置 nbf");
}
#[test]
fn verify_past_nbf_returns_ok() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: now - 10,
exp: now + 3600,
login_id: "1001".to_string(),
device: None,
jti: Some(uuid::Uuid::new_v4().to_string()),
nbf: Some(now - 10), amr: None,
auth_time: None,
tid: None,
};
let header = jsonwebtoken::Header::new(Algorithm::HS256);
let key = jsonwebtoken::EncodingKey::from_secret(b"0123456789abcdef0123456789abcdef");
let token = jsonwebtoken::encode(&header, &claims, &key).unwrap();
let result = handler.verify(&token);
assert!(result.is_ok(), "nbf = 过去应通过校验: {:?}", result.err());
}
#[test]
fn verify_token_without_nbf_field_returns_ok() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
let claims_json = serde_json::json!({
"sub": "1001",
"iat": now,
"exp": now + 3600,
"login_id": "1001",
"device": null,
"jti": uuid::Uuid::new_v4().to_string()
});
let header = jsonwebtoken::Header::new(Algorithm::HS256);
let key = jsonwebtoken::EncodingKey::from_secret(b"0123456789abcdef0123456789abcdef");
let token = jsonwebtoken::encode(&header, &claims_json, &key).unwrap();
let result = handler.verify(&token);
assert!(result.is_ok(), "无 nbf 字段应通过校验: {:?}", result.err());
let claims = result.unwrap();
assert!(claims.nbf.is_none(), "无 nbf 字段时 claims.nbf 应为 None");
}
#[test]
fn refresh_issues_new_valid_token() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
let new_token = refresh_ok(&handler, &token, 7200);
assert_ne!(token, new_token);
let claims = verify_ok(&handler, &new_token);
assert_eq!(claims.login_id, "1001");
}
#[test]
fn refresh_invalid_token_fails() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let result = handler.refresh("invalid.token.here", 3600);
assert!(result.is_err());
}
#[test]
fn sign_accepts_login_id_numeric() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001".to_string(), 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.login_id, "1001");
}
#[test]
fn sign_rejects_short_secret() {
let handler = JwtHandler::new("short-key"); let result = handler.sign("1001", 3600);
assert!(result.is_err(), "短密钥 sign 应返回错误");
match result.err() {
Some(GarrisonError::Config(msg)) => {
assert!(
msg.contains("jwt-secret-too-short"),
"错误应包含 jwt-secret-too-short,实际: {}",
msg
);
},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn verify_rejects_short_secret() {
let handler = JwtHandler::new("short-key"); let result = handler.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMDAxIn0.fake");
assert!(result.is_err(), "短密钥 verify 应返回错误");
match result.err() {
Some(GarrisonError::Config(msg)) => {
assert!(
msg.contains("jwt-secret-too-short"),
"错误应包含 jwt-secret-too-short,实际: {}",
msg
);
},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn sign_accepts_exactly_32_byte_secret() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef"); let token = handler.sign("1001", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.login_id, "1001");
}
#[test]
fn verify_rejects_none_algorithm_token() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let none_token = "eyJhbGciOiAibm9uZSIsICJ0eXAiOiAiSldUIn0.eyJzdWIiOiAidXNlcjEyMyIsICJsb2dpbl9pZCI6ICJ1c2VyMTIzIiwiZXhwIjo5OTk5OTk5OTk5LCJpYXQiOjE3MDAwMDAwMDB9.";
let result = handler.verify(none_token);
assert!(result.is_err(), "alg=none token 必须被拒绝");
}
#[test]
fn verify_rejects_algorithm_swap_token() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let swapped = "eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9.eyJzdWIiOiAidXNlcjEyMyIsICJsb2dpbl9pZCI6ICJ1c2VyMTIzIiwiZXhwIjo5OTk5OTk5OTk5LCJpYXQiOjE3MDAwMDAwMDB9.ZmFrZXNpZ24";
let result = handler.verify(swapped);
assert!(
result.is_err(),
"header alg 与配置算法不符的 token 必须被拒绝"
);
}
#[test]
fn verify_rejects_cross_algorithm_replay() {
let secret = "0123456789abcdef0123456789abcdef";
let hs256_handler = JwtHandler::new(secret);
let hs512_handler = JwtHandler::new(secret).with_algorithm(Algorithm::HS512);
let token = hs256_handler.sign("user123", 3600).unwrap();
let result = hs512_handler.verify(&token);
assert!(
result.is_err(),
"HS256 签发的 token 送 HS512 handler 必须被拒绝"
);
}
#[test]
fn verify_rejects_tampered_payload() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("user123", 3600).unwrap();
let parts: Vec<&str> = token.split('.').collect();
assert_eq!(parts.len(), 3);
let mut payload = base64_decode_urlsafe(parts[1]);
payload[4] ^= 0x01;
let tampered = format!(
"{}.{}.{}",
parts[0],
base64_encode_urlsafe(&payload),
parts[2]
);
let result = handler.verify(&tampered);
assert!(result.is_err(), "篡改 payload 后的 token 必须被拒绝");
let _ = verify_ok(&handler, &token);
}
fn base64_decode_urlsafe(s: &str) -> Vec<u8> {
use base64::Engine;
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(s)
.expect("测试辅助 base64 解码")
}
fn base64_encode_urlsafe(data: &[u8]) -> String {
use base64::Engine;
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(data)
}
const TEST_RSA_PRIVATE_PEM: &str = "-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDMQoXOvmvs4kpj
nYshns5CYyNziLt/xBQBZtlkzY3KUuHtJMz9zK0TTz0DbhCnDCWF8tpWqxHBTtON
pMnnC6bTN4Wg/PWDn67hub23b4xAKq5qH45RmWn4a0TGTUyQktebjlCiWBlMCo43
j7FLyvGrOx3SmyUUaI5vh02Pf5Swg2CCQ69ht3L58jM6lp+jILJ4gEjNC2hmaWgH
bbYhTX5qCaPgZTndfgPXX9wkDG8jhpgRpfwmSuJ4aRiRrjvgycWuPccryX7aXiBU
c5H8rdKVgnjPTzSL8h3P/2tpZkNj5OFBZKTgmdPuwF87Mjlbr7Oi2xpCIpNpnyF1
L8G/mIIRAgMBAAECggEAY2vnzIOEbceRtN4cuC8fr1GpElXWCfELWclRfI7O+tGP
9YlpnAmxnsn9ZTuAMIcphoL4QqI+4Kw5LeMtgV/7AikuyncGG9ywV1+819ocVqlP
vwkAEXjOi2PPFITQhThsaOODHRorqgcjRSkUf9NXAWUjdX0dtcrUtbWSi4vqeGWC
O0Ni/9iWJYFjAgHu+XJgYXZtn7sJGe30PuIFmiKHfHuuM9alo6SubQ3UU80B+hQm
N4VVuYN+dYmGsekp+Ofj65mq2+WAyvHE2V9OB92L+yVY0uKZ428eXdN9ydp8kVqh
yOW2yLTq6sBNBOi/F/DMim6QrIzn6zpp0hXyc97d1wKBgQD+2qQOQ+urTE1ymdXT
C/os5kMrjsYd/rfcMaBbl4XmDE/PjlJg1Z6yVBGMmvM/shjTslcV8kgKyKf+aHm1
b3ckgu9PLtoYGX0yjeHbYCidwkjJPz8sy5pIFHslY/bGhV5RqsSPJo1aX2En0c4R
3cJHGGGn2YguQuWSOU94VTKgowKBgQDNLaS9Q08j/tiozEY23oH9i5p5iSwxc3It
hS/UwLYNFad6byRiDgVlvx+sVHZfLBsmNMlHEY+oMGocctqGAC8+a0pvtaLnU12/
GI61axWfAlCJrYs3CBOKwOH3hBM04mqPUb2ySHdlzPawpIr55jMkohuXXyw/22je
pK7iIPHZuwKBgQC+/Gi/TAUbjQXpIQHNtAcaiMDDrq4nolB00jfjC81LVeSlnXl8
mfngmAHCxggOrs/OLbL3fmagtji2/eJfppW5penjBDBqqQda0Fr2xLwLZaKYNi6I
ylfnNnoGzkAMC7xgJUJCKNj7ZcjwR1lPqElEcDAW0n0sdfOGvi4g9nAHUwKBgGIB
E1dz9zFyYXr/V+qNjfnV3QuAgiN8yWUE4Tv2cP7/AOhyfiZ4HAvlpvNhxMjhAHbX
b+0KblwgBA9irQ6kt+xQw1VopU9perX0vPXbGJDDQkUBKCY5LVxxlX3tEF+KZuve
V4X5J07xAESP0/JaCsPMyvEa/L/jxcvTTdWlduBRAoGBAPx2MMqUGXa+UZ+a0cyF
tW0xGglEWCX+e2vSNf31v4FyoGxNi6h2ap2OWEddpGttS+UbOzO9BlzcCtYJvPwW
lRVGEQXEoVyslCUwTlV8LmtrJS6Xl9YwRHmmajJMH6GJTk/CToOLIvj2bOMxHW5A
dzWfBsm+KAfTJuqbV7VnJL3G
-----END PRIVATE KEY-----
";
#[test]
fn rsa_pem_rs256_sign_verify_roundtrip() {
let handler = JwtHandler::new("placeholder-secret-not-used")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::RS256)
.unwrap();
let token = handler.sign("user123", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.login_id, "user123");
}
#[test]
fn rsa_pem_rs384_rs512_sign_verify_roundtrip() {
for alg in [Algorithm::RS384, Algorithm::RS512] {
let handler = JwtHandler::new("placeholder-secret-not-used")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(alg)
.unwrap();
let token = handler.sign("user123", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.login_id, "user123");
}
}
#[test]
fn rsa_pem_invalid_pem_fails_fast() {
let result = JwtHandler::new("placeholder").with_rsa_private_pem("not-a-pem");
assert!(result.is_err(), "非法 PEM 必须在构造期报错");
}
#[test]
fn rsa_pem_rejects_hs_algorithm() {
let handler = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap();
let err = match handler.try_with_algorithm(Algorithm::HS256) {
Err(e) => e,
Ok(_) => panic!("RSA 密钥配 HS256 应被拒绝"),
};
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("jwt-key-algorithm-mismatch")),
"RSA 密钥配 HS256 应报 jwt-key-algorithm-mismatch,实际: {:?}",
err
);
}
#[test]
fn rsa_key_material_debug_redacts_pem() {
let handler = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap();
let debug = format!("{:?}", handler.key_material);
assert!(
!debug.contains("PRIVATE KEY") && !debug.contains("MIIEvg"),
"KeyMaterial Debug 输出不得包含 PEM 内容,实际: {}",
debug
);
}
const TEST_EC_PRIVATE_PEM: &str = "-----BEGIN PRIVATE KEY-----
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgHu89Emnr1D+OpkZF
T2f/jZRjQNl9Q6AyVEnsI2rH+tihRANCAARSS8Qlg3TwbmWk6ICPdeHxy/X0LARI
FTcfYH6rUSsxJH2JD7Adnx1iw7UhnOZXVf8YOnDrqaXJkQcXNWPSUBqA
-----END PRIVATE KEY-----
";
#[test]
fn ec_pem_es256_sign_verify_roundtrip() {
let handler = JwtHandler::new("placeholder-secret-not-used")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::ES256)
.unwrap();
let token = handler.sign("user123", 3600).unwrap();
let claims = handler.verify(&token).unwrap();
assert_eq!(claims.login_id, "user123");
}
#[test]
fn ec_pem_invalid_pem_fails_fast() {
let result = JwtHandler::new("placeholder").with_ec_pem("not-a-pem");
assert!(result.is_err(), "非法 EC PEM 必须在构造期报错");
}
#[test]
fn ec_pem_rejects_hs_algorithm() {
let handler = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap();
let result = handler.try_with_algorithm(Algorithm::HS256);
assert!(result.is_err(), "EC 密钥配 HS256 应被拒绝");
}
const TEST_EC_P384_PRIVATE_PEM: &str = "-----BEGIN PRIVATE KEY-----
MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDA7FBewvmXSGqCaqiUM
8WJE3UDFs8aHiXNcnz4TzkYW5FHiZKVufY2cGbuu68R71VGhZANiAAQN57zuQF41
RG768ifH35dHUGaCy0FFgEq/LpAQHQGafVI/DVkmz21C4uezJg4dId/PhuhhXgiR
kNTRzfBIl0uPVyBJA2hncDTiVcKiOHfdyZ678wwtTNpxsnL3oEm1h+8=
-----END PRIVATE KEY-----
";
#[test]
fn ec_pem_es384_sign_verify_roundtrip() {
let handler = JwtHandler::new("placeholder-secret-not-used")
.with_ec_pem(TEST_EC_P384_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::ES384)
.unwrap();
let token = handler.sign("user123", 3600).unwrap();
let claims = handler.verify(&token).unwrap();
assert_eq!(claims.login_id, "user123");
}
const TEST_ED_PRIVATE_PEM: &str = "-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIOChr1YQD9KWBWWGBLFFjHQiHx9+OznRi69Gh25Uhv8H
-----END PRIVATE KEY-----
";
#[test]
fn ed_pem_eddsa_sign_verify_roundtrip() {
let handler = JwtHandler::new("placeholder-secret-not-used")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::EdDSA)
.unwrap();
let token = handler.sign("user123", 3600).unwrap();
let claims = handler.verify(&token).unwrap();
assert_eq!(claims.login_id, "user123");
}
#[test]
fn ed_pem_invalid_pem_fails_fast() {
let result = JwtHandler::new("placeholder").with_ed_pem("not-a-pem");
assert!(result.is_err(), "非法 Ed PEM 必须在构造期报错");
}
#[test]
fn asymmetric_empty_secret_placeholder_sign_verify_symmetric() {
let handler = JwtHandler::new("")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::EdDSA)
.unwrap();
let token = handler
.sign("user123", 3600)
.expect("空 secret 占位 + EdDSA 的 sign 不应误拒");
let claims = handler
.verify(&token)
.expect("空 secret 占位 + EdDSA 的 verify 不应误拒(修复前 Err(jwt-secret-empty))");
assert_eq!(claims.login_id, "user123");
}
#[test]
fn cross_key_type_tokens_always_rejected() {
let hs = JwtHandler::new("0123456789abcdef0123456789abcdef");
let hs_token = hs.sign("user123", 3600).unwrap();
let rsa = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::RS256)
.unwrap();
let rsa_token = rsa.sign("user123", 3600).unwrap();
let ec = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::ES256)
.unwrap();
let ec_token = ec.sign("user123", 3600).unwrap();
let ed = JwtHandler::new("placeholder")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::EdDSA)
.unwrap();
assert!(
rsa.verify(&hs_token).is_err(),
"HS token 送 RS handler 必须被拒绝"
);
assert!(
ec.verify(&hs_token).is_err(),
"HS token 送 EC handler 必须被拒绝"
);
assert!(
ed.verify(&hs_token).is_err(),
"HS token 送 Ed handler 必须被拒绝"
);
assert!(
hs.verify(&rsa_token).is_err(),
"RS token 送 HS handler 必须被拒绝"
);
assert!(
ec.verify(&rsa_token).is_err(),
"RS token 送 EC handler 必须被拒绝"
);
assert!(
ed.verify(&rsa_token).is_err(),
"RS token 送 Ed handler 必须被拒绝"
);
assert!(
hs.verify(&ec_token).is_err(),
"EC token 送 HS handler 必须被拒绝"
);
assert!(
hs.verify(ed.sign("user123", 3600).unwrap().as_str())
.is_err(),
"Ed token 送 HS handler 必须被拒绝"
);
assert!(rsa.verify(&rsa_token).is_ok());
assert!(ec.verify(&ec_token).is_ok());
assert!(hs.verify(&hs_token).is_ok());
}
#[test]
fn sign_claims_signs_custom_claims_verifiable_with_same_secret() {
use serde::Serialize;
#[derive(Serialize)]
struct Probe {
iss: String,
aud: String,
}
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler
.sign_claims(&Probe {
iss: "https://op.example.com".to_string(),
aud: "client-a".to_string(),
})
.expect("sign_claims 应成功");
let parts: Vec<&str> = token.split('.').collect();
assert_eq!(parts.len(), 3, "JWT 应由三段组成");
let mut validation = jsonwebtoken::Validation::new(jsonwebtoken::Algorithm::HS256);
validation.validate_exp = false;
validation.validate_aud = false;
validation.required_spec_claims.clear();
let payload = jsonwebtoken::decode::<serde_json::Value>(
&token,
&jsonwebtoken::DecodingKey::from_secret(b"0123456789abcdef0123456789abcdef"),
&validation,
)
.expect("同密钥解码应成功");
assert_eq!(payload.claims["iss"], "https://op.example.com");
assert_eq!(payload.claims["aud"], "client-a");
}
#[test]
fn sign_claims_rejects_empty_secret() {
use serde::Serialize;
#[derive(Serialize)]
struct Probe {
iss: String,
}
let handler = JwtHandler::new("");
let result = handler.sign_claims(&Probe {
iss: "https://op.example.com".to_string(),
});
match result.err() {
Some(GarrisonError::Config(msg)) => assert!(msg.contains("secret")),
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn claims_amr_auth_time_serialize_and_deserialize() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: None,
jti: None,
nbf: None,
amr: Some(vec!["pwd".to_string(), "otp".to_string()]),
auth_time: Some(1700000000),
tid: None,
};
let json = serde_json::to_string(&claims).unwrap();
assert!(
json.contains(r#""amr":["pwd","otp"]"#),
"amr 应按 RFC 8176 输出字符串数组,实际: {}",
json
);
assert!(
json.contains(r#""auth_time":1700000000"#),
"auth_time 应输出 Unix 秒,实际: {}",
json
);
let parsed: GarrisonJwtClaims = serde_json::from_str(&json).unwrap();
assert_eq!(parsed.amr, Some(vec!["pwd".to_string(), "otp".to_string()]));
assert_eq!(parsed.auth_time, Some(1700000000));
}
#[test]
fn claims_amr_none_skipped_in_json() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: None,
jti: None,
nbf: None,
amr: None,
auth_time: None,
tid: None,
};
let json = serde_json::to_string(&claims).unwrap();
assert!(!json.contains("amr"), "amr=None 不应序列化,实际: {}", json);
assert!(
!json.contains("auth_time"),
"auth_time=None 不应序列化,实际: {}",
json
);
}
#[test]
fn claims_without_amr_fields_deserialize_as_none() {
let json =
r#"{"sub":"1001","iat":1700000000,"exp":1700003600,"login_id":"1001","device":"web"}"#;
let claims: GarrisonJwtClaims = serde_json::from_str(json).unwrap();
assert_eq!(claims.amr, None, "无 amr 字段应反序列化为 None");
assert_eq!(claims.auth_time, None, "无 auth_time 字段应反序列化为 None");
}
#[test]
fn claims_tid_none_skipped_and_legacy_payload_parses_as_none() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: None,
jti: None,
nbf: None,
amr: None,
auth_time: None,
tid: None,
};
let json = serde_json::to_string(&claims).unwrap();
assert!(!json.contains("tid"), "tid=None 不应序列化,实际: {}", json);
let parsed: GarrisonJwtClaims = serde_json::from_str(&json).unwrap();
assert_eq!(parsed.tid, None);
let legacy =
r#"{"sub":"1001","iat":1700000000,"exp":1700003600,"login_id":"1001","device":"web"}"#;
let legacy_claims: GarrisonJwtClaims = serde_json::from_str(legacy).unwrap();
assert_eq!(legacy_claims.tid, None, "旧格式载荷无 tid 应解析为 None");
}
#[test]
fn claims_tid_roundtrips_when_present() {
let claims = GarrisonJwtClaims {
sub: "1001".to_string(),
iat: 1700000000,
exp: 1700003600,
login_id: "1001".to_string(),
device: None,
jti: None,
nbf: None,
amr: None,
auth_time: None,
tid: Some(7),
};
let json = serde_json::to_string(&claims).unwrap();
assert!(
json.contains(r#""tid":7"#),
"tid 应输出十进制 i64,实际: {}",
json
);
let parsed: GarrisonJwtClaims = serde_json::from_str(&json).unwrap();
assert_eq!(parsed.tid, Some(7));
}
#[test]
fn sign_without_tenant_omits_tid_and_verifies() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
let payload = token.split('.').nth(1).unwrap();
let json = URL_SAFE_NO_PAD
.decode(payload)
.map(|b| String::from_utf8(b).unwrap())
.unwrap();
assert!(
!json.contains("\"tid\""),
"无租户签发载荷不应含 tid,实际: {}",
json
);
let claims = handler.verify(&token).unwrap();
assert_eq!(claims.tid, None);
}
#[test]
fn sign_with_tid_roundtrips_through_verify() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef").with_tid(7);
let token = handler.sign("1001", 3600).unwrap();
let claims = verify_ok(&handler, &token);
assert_eq!(claims.tid, Some(7), "with_tid 签发应写 tid claim");
assert_eq!(claims.login_id, "1001", "既有 claim 不受 tid 接线影响");
}
#[test]
fn sign_with_amr_and_auth_time_maps_claims() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler
.sign_with_amr(
"1001",
3600,
&["pwd".to_string(), "otp".to_string(), "webauthn".to_string()],
Some(1700000000),
)
.unwrap();
let claims = handler.verify(&token).unwrap();
assert_eq!(
claims.amr,
Some(vec![
"pwd".to_string(),
"otp".to_string(),
"webauthn".to_string()
])
);
assert_eq!(claims.auth_time, Some(1700000000));
}
#[test]
fn sign_without_amr_omits_claims_and_still_verifies() {
let handler = JwtHandler::new("0123456789abcdef0123456789abcdef");
let token = handler.sign("1001", 3600).unwrap();
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
let payload = token.split('.').nth(1).unwrap();
let json = URL_SAFE_NO_PAD
.decode(payload)
.map(|b| String::from_utf8(b).unwrap())
.unwrap();
assert!(
!json.contains("\"amr\""),
"未接线时载荷不应含 amr,实际: {}",
json
);
assert!(!json.contains("\"auth_time\""));
let claims = handler.verify(&token).unwrap();
assert_eq!(claims.amr, None);
assert_eq!(claims.auth_time, None);
}
const TEST_RSA_PKCS1_PRIVATE_PEM: &str = "-----BEGIN RSA PRIVATE KEY-----
MIIEpQIBAAKCAQEAx6M/FqpYLvQqKelZMKmfWuQXzOOoGcy8cP7LHV0W1I1qnx1v
nYynQNItKsmZ6WZYkSQUjA0ZzBwfBtH9aJRPWJD4UqCuMXne2EJydtuNsYbNW1kl
ypobLiPEak9BzjQDe/NO6WDsAP5N1MuB167bJhCXRNGkwpVUCVotUjk4m4Zr5EVu
vp5JSKsMYK29n04Seb9+HvIpuV7wWr9LWGC3HcC2E+X83chGcBVx6i28oQPQszVE
MnmjnLPPtu6iGNNBbs4b1oucUg7u4e/2sdwiYXx5XIAitvWoQpSRtDVSIl5V5fp8
LbiuoPqy8aQX3aJNXYblqQXiQ2yx3OcmV3UyOwIDAQABAoIBABN0umpIEa4Jx64r
+rA+Z7Rg9FzYdwKErHzKqBrlfpsaaSC2qrENCyPLF/HKkgBoJAuJG6OGh1QYDYIJ
pwuxIIZ+ImVTGYbi3K/w0dz5iraZb5wOdRtop2t4uuStcrlY4loLHU6rTnTOU+GA
L9hIRz1Pcp6XW9pG2VjL/Ay+XODzLWNwdJU3ZwqQkF/8GbMs3bJ4OhzTYijDE+j7
GmRIA79ZI55eqKZBr73vLy5VI63mGI/ktKW3Usfwqm/Ulp7Ox4l9t/RFkQHNtAVB
1zHhhlNnfGC4w94Y8vFMhY/AU+fEJ08ChLaW4vxFIeuaFt29ZvcTBe22tyI6YSXN
+OQTCFkCgYEA/mWwNfeAdVT6XoJQKGxbZ1KHktDgiXYizgd4sWO0QpUdzDVoa372
Qrdl9V6Fx13Js2pj3vTuJIlInuzrq4NIgCOXRsZun6hoqzAlZjg718n/XABOx4/c
z5qrLJW29KShADHTFjDsi5KKt12ZqHWf507LQJQUr+FMXKwodlxMGCcCgYEAyOU8
12SjFpvOs9vciIWxgFUx4jRRE1Se6GfBwbN8J+xxkxzOVMVLipxPkSqvsXvANVVu
0EftWvOyR6fcd4zeT5ywgGlQR64mc6xtCUqpdjQDovu2CsFB7ZvJ20Sn0rm9Nicx
ymMZ6XP/v0QyvQLAwdMsJzyY0sqZFUDQDgzhLc0CgYEAtYSFSNyC0jWCN/EvlMhM
J9shVUapECw1BWEbYydLNb8EdfMdwKXkvRHzNDLvraNkChq9jBaj3Xn/UTanqceQ
8a1zgVKRGGan2I4QAXHacUx2YoTtsUMbQR6RSMzCsKjPID5s6YabIbO8Or4Up7jW
EcuNB1UhtaVCQVWtwVZ2DT0CgYEAicE/TgdxGZCvVX+eonLiezhwI0dyjMnKyVxU
bUlxCkNEwfbPuSssmJiEqutVXGOaMjgp62JW7LYMerwtHkEXNAoisXsFlJFjRpBm
mCd9OlOCZuEpPAi294KLEPLsDUBV8WtA5iG8Y+up4/KUxCy+FmqCbUlNFcXc4Mj3
oZrNUcUCgYEA6Bi7enYoTbWCkSo0NtJ9gcXg5Yb+QQ/SJty7PFD8rKrCY0nTB52e
Bd3jPAqUJiKPnNiN9aL8l+zmx4wLhsZBP2L1j1B/QEJjAHmWDeckdV8nPSbik9i7
5dutLlFkZR4+7pAMV3WwVglnoPjR7HhvL9DCxweeSxBHvOhzEdtSx68=
-----END RSA PRIVATE KEY-----
";
const TEST_EC_NO_PUB_PEM: &str = "-----BEGIN PRIVATE KEY-----
ME0CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEMzAxAgEBBCCi+olhcIeXdliGiFfC
hhSoxgLJoyTjnNhg/4ZvBAAdAKAKBggqhkjOPQMBBw==
-----END PRIVATE KEY-----
";
use base64::Engine as _;
#[test]
fn export_public_jwk_rsa_pkcs8() {
let handler = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap();
let jwk = handler.export_public_jwk_parts().unwrap();
match jwk {
Some(JwkPublicKey::Rsa { n, e }) => {
assert_eq!(e, "AQAB", "RSA 公钥指数 65537 的 base64url 为 AQAB");
let n_bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&n)
.expect("n 必须是合法 base64url");
assert_eq!(n_bytes.len(), 256, "RSA-2048 模数应为 256 字节");
assert!(
!n.contains('=') && !n.contains('+') && !n.contains('/'),
"JWK 口径必须 base64url 无 padding"
);
},
other => panic!("RSA 密钥应导出 Rsa JWK,实际: {other:?}"),
}
}
#[test]
fn export_public_jwk_rsa_pkcs1_traditional() {
let handler = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PKCS1_PRIVATE_PEM)
.unwrap();
let jwk = handler.export_public_jwk_parts().unwrap();
match jwk {
Some(JwkPublicKey::Rsa { n, e }) => {
let n_bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&n)
.expect("n 必须是合法 base64url");
assert_eq!(n_bytes.len(), 256, "RSA-2048 模数应为 256 字节");
assert_eq!(e, "AQAB");
},
other => panic!("PKCS#1 RSA 应导出 Rsa JWK,实际: {other:?}"),
}
}
#[test]
fn export_public_jwk_ec_p256_embedded_pubkey() {
let handler = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap();
match handler.export_public_jwk_parts().unwrap() {
Some(JwkPublicKey::Ec { crv, x, y }) => {
assert_eq!(crv, "P-256");
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&x)
.unwrap()
.len(),
32,
"P-256 x 坐标应为 32 字节"
);
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&y)
.unwrap()
.len(),
32,
"P-256 y 坐标应为 32 字节"
);
},
other => panic!("EC P-256 应导出 Ec JWK,实际: {other:?}"),
}
}
#[test]
fn export_public_jwk_ec_p256_scalar_mult_when_pubkey_absent() {
let handler = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_NO_PUB_PEM)
.unwrap();
match handler.export_public_jwk_parts().unwrap() {
Some(JwkPublicKey::Ec { crv, x, y }) => {
assert_eq!(crv, "P-256", "P-256 OID 应分派到 P-256 标量乘法");
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&x)
.unwrap()
.len(),
32
);
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&y)
.unwrap()
.len(),
32
);
},
other => panic!("无内嵌公钥的 EC 应经标量乘法导出 Ec JWK,实际: {other:?}"),
}
}
#[test]
fn export_public_jwk_ec_p384_embedded_pubkey() {
let handler = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_P384_PRIVATE_PEM)
.unwrap();
match handler.export_public_jwk_parts().unwrap() {
Some(JwkPublicKey::Ec { crv, x, y }) => {
assert_eq!(crv, "P-384");
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&x)
.unwrap()
.len(),
48,
"P-384 x 坐标应为 48 字节"
);
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&y)
.unwrap()
.len(),
48
);
},
other => panic!("EC P-384 应导出 Ec JWK,实际: {other:?}"),
}
}
#[test]
fn export_public_jwk_ed25519_okp() {
let handler = JwtHandler::new("placeholder")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap();
match handler.export_public_jwk_parts().unwrap() {
Some(JwkPublicKey::Okp { x }) => {
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&x)
.unwrap()
.len(),
32,
"Ed25519 公钥应为 32 字节"
);
},
other => panic!("Ed25519 应导出 Okp JWK,实际: {other:?}"),
}
}
#[test]
fn export_public_jwk_hs_returns_none() {
let handler = JwtHandler::new("symmetric-secret");
assert!(handler.export_public_jwk_parts().unwrap().is_none());
}
#[test]
fn key_material_debug_redacts_ec_and_ed() {
let ec = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap();
let s = format!("{:?}", ec.key_material);
assert!(s.contains("EcPem(<redacted>"), "EC Debug 应脱敏: {s}");
assert!(!s.contains("MIGHAgEA"), "不得泄露 PEM 内容: {s}");
let ed = JwtHandler::new("placeholder")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap();
let s = format!("{:?}", ed.key_material);
assert!(s.contains("EdPem(<redacted>"), "Ed Debug 应脱敏: {s}");
assert!(!s.contains("MC4CAQ"), "不得泄露 PEM 内容: {s}");
}
#[test]
fn from_algorithm_parts_builds_each_algorithm() {
assert!(JwtHandler::from_algorithm_parts("HS256", "secret", None, None, None).is_ok());
assert!(JwtHandler::from_algorithm_parts("HS384", "secret", None, None, None).is_ok());
assert!(JwtHandler::from_algorithm_parts("HS512", "secret", None, None, None).is_ok());
assert!(JwtHandler::from_algorithm_parts(
"RS256",
"placeholder",
Some(TEST_RSA_PRIVATE_PEM),
None,
None
)
.is_ok());
assert!(JwtHandler::from_algorithm_parts(
"ES256",
"placeholder",
None,
Some(TEST_EC_PRIVATE_PEM),
None
)
.is_ok());
assert!(JwtHandler::from_algorithm_parts(
"EdDSA",
"placeholder",
None,
None,
Some(TEST_ED_PRIVATE_PEM)
)
.is_ok());
}
#[test]
fn from_algorithm_parts_rejects_unknown_algorithm() {
let err = match JwtHandler::from_algorithm_parts("HS1024", "secret", None, None, None) {
Err(e) => e,
Ok(_) => panic!("未知算法应被拒绝"),
};
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("config-jwt-algorithm-unsupported")),
"未知算法应报 config-jwt-algorithm-unsupported,实际: {err:?}"
);
}
#[test]
fn from_algorithm_parts_asymmetric_requires_pem() {
assert!(JwtHandler::from_algorithm_parts("RS256", "placeholder", None, None, None).is_err());
assert!(JwtHandler::from_algorithm_parts("ES256", "placeholder", None, None, None).is_err());
assert!(JwtHandler::from_algorithm_parts("EdDSA", "placeholder", None, None, None).is_err());
}
#[test]
fn verify_expired_token_maps_to_expired_token_error() {
use crate::protocol::jwt::GarrisonJwtClaims;
use jsonwebtoken::{encode, EncodingKey, Header};
let handler = JwtHandler::new("expired-token-secret-0123456789abcdef")
.try_with_algorithm(Algorithm::HS256)
.unwrap();
let now = chrono::Utc::now().timestamp();
let claims = GarrisonJwtClaims {
sub: "user-exp".to_string(),
iat: now - 7_200,
exp: now - 3_600,
login_id: "user-exp".to_string(),
device: None,
jti: Some("expired-jti".to_string()),
nbf: Some(now - 7_200),
amr: None,
auth_time: None,
tid: None,
};
let token = encode(
&Header::new(jsonwebtoken::Algorithm::HS256),
&claims,
&EncodingKey::from_secret("expired-token-secret-0123456789abcdef".as_bytes()),
)
.unwrap();
let err = handler.verify(&token).unwrap_err();
assert!(
matches!(err, GarrisonError::ExpiredToken(ref m) if m.contains("jwt-expired")),
"过期 token 应报 ExpiredToken(jwt-expired),实际: {err:?}"
);
}
const TEST_EC_P384_NO_PUB_PEM: &str = "-----BEGIN PRIVATE KEY-----
MFcCAQAwEAYHKoZIzj0CAQYFK4EEACIEQDA+AgEBBDCrSR9PoTneWpSyQK4o7cZ9
KOjYI78wO42PYSfhcB9CSltc9XIsGYxelq9j5ZyfZxOgBwYFK4EEACI=
-----END PRIVATE KEY-----
";
#[test]
fn key_material_debug_hs_variant() {
let handler = JwtHandler::new("hs-secret-0123456789abcdef-0123456789");
let s = format!("{:?}", handler.key_material);
assert_eq!(s, "KeyMaterial::Hs", "Hs Debug 应为固定字面量: {s}");
}
#[test]
fn export_public_jwk_ec_p384_scalar_mult_when_pubkey_absent() {
let handler = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_P384_NO_PUB_PEM)
.unwrap();
match handler.export_public_jwk_parts().unwrap() {
Some(JwkPublicKey::Ec { crv, x, y }) => {
assert_eq!(crv, "P-384", "P-384 OID 应分派到 P-384 标量乘法");
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&x)
.unwrap()
.len(),
48
);
assert_eq!(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(&y)
.unwrap()
.len(),
48
);
},
other => panic!("无内嵌公钥的 P-384 应经标量乘法导出 Ec JWK,实际: {other:?}"),
}
}
#[test]
fn sign_with_amr_works_for_asymmetric_materials() {
let rsa = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::RS256)
.unwrap();
let token = rsa
.sign_with_amr(
"user-amr",
3600,
&["pwd".to_string(), "otp".to_string()],
Some(1_700_000_000),
)
.unwrap();
assert_eq!(verify_ok(&rsa, &token).login_id, "user-amr");
let ec = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::ES256)
.unwrap();
let token = ec
.sign_with_amr("user-amr-ec", 3600, &["webauthn".to_string()], None)
.unwrap();
assert_eq!(verify_ok(&ec, &token).login_id, "user-amr-ec");
let ed = JwtHandler::new("placeholder")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap()
.try_with_algorithm(Algorithm::EdDSA)
.unwrap();
let token = ed
.sign_with_amr("user-amr-ed", 3600, &["pwd".to_string()], None)
.unwrap();
assert_eq!(verify_ok(&ed, &token).login_id, "user-amr-ed");
}
#[test]
fn sign_negative_timeout_rejected() {
let handler = JwtHandler::new("negative-timeout-secret-0123456789")
.try_with_algorithm(Algorithm::HS256)
.unwrap();
let err = match handler.sign("user-neg", -1) {
Err(e) => e,
Ok(t) => panic!("负 timeout 应被拒绝,实际签发: {t:?}"),
};
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("jwt-timeout-negative")),
"应报 jwt-timeout-negative,实际: {err:?}"
);
}
#[test]
fn private_pem_accessors_per_material() {
let hs = JwtHandler::new("hs-secret-0123456789abcdef-0123456789");
assert!(hs.private_pem().is_none(), "Hs 无私钥 PEM");
let rsa = JwtHandler::new("placeholder")
.with_rsa_private_pem(TEST_RSA_PRIVATE_PEM)
.unwrap();
assert!(rsa.private_pem().unwrap().contains("BEGIN"));
let ec = JwtHandler::new("placeholder")
.with_ec_pem(TEST_EC_PRIVATE_PEM)
.unwrap();
assert!(ec.private_pem().unwrap().contains("BEGIN"));
let ed = JwtHandler::new("placeholder")
.with_ed_pem(TEST_ED_PRIVATE_PEM)
.unwrap();
assert!(ed.private_pem().unwrap().contains("BEGIN"));
}
#[test]
fn sign_empty_secret_rejected() {
let handler = JwtHandler::new("");
let err = match handler.sign("user-empty", 3600) {
Err(e) => e,
Ok(t) => panic!("空密钥应被拒绝,实际签发: {t:?}"),
};
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("jwt-secret-empty")),
"应报 jwt-secret-empty,实际: {err:?}"
);
}
#[test]
fn sign_short_secret_rejected() {
let handler = JwtHandler::new("short-secret");
let err = match handler.sign("user-short", 3600) {
Err(e) => e,
Ok(t) => panic!("过短密钥应被拒绝,实际签发: {t:?}"),
};
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("jwt-secret-too-short")),
"应报 jwt-secret-too-short,实际: {err:?}"
);
}