use crate::error::{GarrisonError, GarrisonResult};
use jsonwebtoken::{decode, encode, Algorithm, DecodingKey, EncodingKey, Header, Validation};
use serde::{Deserialize, Serialize};
use std::time::{SystemTime, UNIX_EPOCH};
use subtle::ConstantTimeEq;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(untagged)]
pub enum OidcAudience {
Single(String),
Multi(Vec<String>),
}
impl OidcAudience {
pub fn contains(&self, client_id: &str) -> bool {
match self {
OidcAudience::Single(s) => s == client_id,
OidcAudience::Multi(v) => v.iter().any(|s| s == client_id),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcClaims {
pub iss: String,
pub sub: String,
pub aud: OidcAudience,
pub iat: i64,
pub exp: i64,
pub login_id: String,
pub nonce: String,
}
pub struct OidcHandler {
issuer: String,
audience: String,
secret: String,
algorithm: Algorithm,
}
impl OidcHandler {
pub fn new(
issuer: impl Into<String>,
audience: impl Into<String>,
secret: impl Into<String>,
) -> GarrisonResult<Self> {
let secret = secret.into();
if secret.is_empty() {
return Err(GarrisonError::Config(
"oauth2-client-secret-empty".to_string(),
));
}
Ok(Self {
issuer: issuer.into(),
audience: audience.into(),
secret,
algorithm: Algorithm::HS256,
})
}
pub fn with_algorithm(mut self, algorithm: Algorithm) -> Self {
self.algorithm = algorithm;
self
}
fn require_hmac_algorithm(&self) -> GarrisonResult<()> {
if matches!(
self.algorithm,
Algorithm::HS256 | Algorithm::HS384 | Algorithm::HS512
) {
Ok(())
} else {
Err(GarrisonError::Config(format!(
"oidc-algorithm-unsupported::{:?}",
self.algorithm
)))
}
}
pub fn sign_id_token(
&self,
login_id: impl Into<String>,
nonce: &str,
_scope: &str,
timeout: i64,
) -> GarrisonResult<String> {
let login_id: String = login_id.into();
if timeout < 0 {
return Err(GarrisonError::Config(format!(
"oidc-timeout-negative::{}",
timeout
)));
}
self.require_hmac_algorithm()?;
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|e| GarrisonError::Internal(format!("system-clock-error::{}", e)))?
.as_secs() as i64;
let claims = OidcClaims {
iss: self.issuer.clone(),
sub: login_id.clone(),
aud: OidcAudience::Single(self.audience.clone()),
iat: now,
exp: now + timeout,
login_id,
nonce: nonce.to_string(),
};
let header = Header::new(self.algorithm);
let key = EncodingKey::from_secret(self.secret.as_bytes());
encode(&header, &claims, &key)
.map_err(|e| GarrisonError::Internal(format!("jwt-sign::{}", e)))
}
pub fn verify_id_token(
&self,
id_token: &str,
expected_nonce: &str,
) -> GarrisonResult<OidcClaims> {
self.require_hmac_algorithm()?;
let key = DecodingKey::from_secret(self.secret.as_bytes());
let mut validation = Validation::new(self.algorithm);
validation.validate_exp = true;
validation.leeway = 0;
validation.validate_aud = false;
let decoded = decode::<OidcClaims>(id_token, &key, &validation).map_err(|e| {
let msg = e.to_string();
if msg.contains("ExpiredSignature") {
GarrisonError::ExpiredToken(format!("jwt-expired::{}", e))
} else {
GarrisonError::InvalidToken(format!("jwt-invalid::{}", e))
}
})?;
let claims = decoded.claims;
if claims.iss != self.issuer {
return Err(GarrisonError::InvalidToken(
"oidc-iss-mismatch::".to_string(),
));
}
if !claims.aud.contains(&self.audience) {
return Err(GarrisonError::InvalidToken(
"oidc-aud-mismatch::".to_string(),
));
}
if expected_nonce.is_empty() {
return Err(GarrisonError::OAuth2("oidc-nonce-missing".to_string()));
}
if !bool::from(claims.nonce.as_bytes().ct_eq(expected_nonce.as_bytes())) {
return Err(GarrisonError::OAuth2("nonce mismatch".to_string()));
}
Ok(claims)
}
pub fn discovery_metadata(&self) -> serde_json::Value {
let supported_algs: Vec<&'static str> = match self.algorithm_str() {
"" => Vec::new(),
alg => vec![alg],
};
serde_json::json!({
"issuer": self.issuer,
"authorization_endpoint": format!("{}/authorize", self.issuer),
"token_endpoint": format!("{}/token", self.issuer),
"userinfo_endpoint": format!("{}/userinfo", self.issuer),
"response_types_supported": ["code"],
"subject_types_supported": ["public"],
"id_token_signing_alg_values_supported": supported_algs,
})
}
fn algorithm_str(&self) -> &'static str {
match self.algorithm {
Algorithm::HS256 => "HS256",
Algorithm::HS384 => "HS384",
Algorithm::HS512 => "HS512",
_ => "",
}
}
}
#[cfg(feature = "protocol-zeroize")]
impl Drop for OidcHandler {
fn drop(&mut self) {
use zeroize::Zeroize;
self.secret.zeroize();
}
}
#[cfg(test)]
mod tests {
use super::*;
fn make_handler() -> OidcHandler {
OidcHandler::new(
"https://auth.example.com",
"test-client-id",
"test-secret-key",
)
.expect("创建 OidcHandler 失败")
}
#[test]
fn new_populates_fields() {
let handler = make_handler();
assert_eq!(handler.issuer, "https://auth.example.com");
assert_eq!(handler.audience, "test-client-id");
assert_eq!(handler.algorithm, Algorithm::HS256);
}
#[test]
fn new_empty_secret_returns_config_error() {
let result = OidcHandler::new("issuer", "aud", "");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(_)) => {},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn with_algorithm_switches_to_hs512() {
let handler = make_handler().with_algorithm(Algorithm::HS512);
assert_eq!(handler.algorithm, Algorithm::HS512);
}
#[test]
fn sign_id_token_returns_three_segment_jwt() {
let handler = make_handler();
let token = handler
.sign_id_token("1001", "abc123", "openid profile", 3600)
.unwrap();
let parts: Vec<&str> = token.split('.').collect();
assert_eq!(parts.len(), 3, "id_token 应由三段组成");
}
#[test]
fn sign_and_verify_id_token_roundtrip() {
let handler = make_handler();
let token = handler
.sign_id_token("1001", "nonce-abc", "openid", 3600)
.unwrap();
let claims = handler.verify_id_token(&token, "nonce-abc").unwrap();
assert_eq!(claims.iss, "https://auth.example.com");
assert_eq!(claims.sub, "1001");
assert_eq!(
claims.aud,
OidcAudience::Single("test-client-id".to_string())
);
assert!(claims.aud.contains("test-client-id"));
assert_eq!(claims.login_id, "1001");
assert_eq!(claims.nonce, "nonce-abc");
assert!(claims.exp > claims.iat);
}
#[test]
fn verify_id_token_nonce_mismatch_returns_oauth2_error() {
let handler = make_handler();
let token = handler
.sign_id_token("1001", "correct-nonce", "openid", 3600)
.unwrap();
let result = handler.verify_id_token(&token, "wrong-nonce");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::OAuth2(msg)) => assert!(msg.contains("nonce mismatch")),
other => panic!("期望 OAuth2 错误,实际: {:?}", other),
}
}
#[test]
fn verify_id_token_missing_nonce_rejected() {
let handler = make_handler();
let token = handler
.sign_id_token("1001", "nonce-abc", "openid", 3600)
.unwrap();
let result = handler.verify_id_token(&token, "");
match result.err() {
Some(GarrisonError::OAuth2(msg)) => {
assert!(msg.contains("oidc-nonce-missing"), "实际: {}", msg)
},
other => panic!("期望 OAuth2(nonce-missing),实际: {:?}", other),
}
let empty_nonce_token = handler.sign_id_token("1001", "", "openid", 3600).unwrap();
let result = handler.verify_id_token(&empty_nonce_token, "");
match result.err() {
Some(GarrisonError::OAuth2(msg)) => {
assert!(msg.contains("oidc-nonce-missing"), "实际: {}", msg)
},
other => panic!("空对空 nonce 应拒绝,实际: {:?}", other),
}
let result = handler.verify_id_token(&empty_nonce_token, "real-nonce");
match result.err() {
Some(GarrisonError::OAuth2(msg)) => assert!(msg.contains("nonce mismatch")),
other => panic!("token nonce 缺失应 mismatch 拒绝,实际: {:?}", other),
}
}
#[test]
fn sign_id_token_uses_hs256_by_default() {
let handler = make_handler();
let token = handler
.sign_id_token("1001", "nonce", "openid", 3600)
.unwrap();
let parts: Vec<&str> = token.split('.').collect();
let header_bytes = base64_url_decode(parts[0]);
let header: serde_json::Value = serde_json::from_slice(&header_bytes).unwrap();
assert_eq!(header["alg"], "HS256");
}
#[test]
fn sign_id_token_rejects_negative_timeout() {
let handler = make_handler();
let result = handler.sign_id_token("1001", "nonce", "openid", -1);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(_)) => {},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn verify_id_token_tampered_fails() {
let handler = make_handler();
let token = handler
.sign_id_token("1001", "nonce", "openid", 3600)
.unwrap();
let parts: Vec<&str> = token.split('.').collect();
let tampered = format!("{}.{}.{}", parts[0], "ZmFrZS1wYXlsb2Fk", parts[2]);
let result = handler.verify_id_token(&tampered, "nonce");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误(签名校验失败),实际: {:?}", other),
}
}
#[test]
fn sign_id_token_rejects_asymmetric_algorithm() {
let handler = make_handler().with_algorithm(Algorithm::RS256);
let result = handler.sign_id_token("1001", "nonce", "openid", 3600);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(msg)) => assert!(
msg.contains("oidc-algorithm-unsupported") && msg.contains("RS256"),
"错误消息应包含 oidc-algorithm-unsupported 与 RS256,实际: {}",
msg
),
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn verify_id_token_rejects_asymmetric_algorithm() {
let signer = make_handler();
let token = signer
.sign_id_token("1001", "nonce", "openid", 3600)
.unwrap();
let verifier = make_handler().with_algorithm(Algorithm::RS256);
let result = verifier.verify_id_token(&token, "nonce");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(_)) => {},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn verify_id_token_iss_mismatch_fails() {
let signer = OidcHandler::new("https://correct-issuer", "aud", "secret").unwrap();
let verifier = OidcHandler::new("https://wrong-issuer", "aud", "secret").unwrap();
let token = signer
.sign_id_token("1001", "nonce", "openid", 3600)
.unwrap();
let result = verifier.verify_id_token(&token, "nonce");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => assert!(msg.contains("iss")),
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[test]
fn discovery_metadata_contains_all_required_fields() {
let handler = make_handler();
let metadata = handler.discovery_metadata();
assert_eq!(metadata["issuer"], "https://auth.example.com");
assert!(metadata["authorization_endpoint"]
.as_str()
.unwrap()
.ends_with("/authorize"));
assert!(metadata["token_endpoint"]
.as_str()
.unwrap()
.ends_with("/token"));
assert!(metadata["userinfo_endpoint"]
.as_str()
.unwrap()
.ends_with("/userinfo"));
assert!(
metadata.get("jwks_uri").is_none(),
"HMAC-only handler 不应输出 jwks_uri: {}",
metadata
);
assert!(metadata["response_types_supported"]
.as_array()
.unwrap()
.contains(&serde_json::json!("code")));
assert!(metadata["subject_types_supported"]
.as_array()
.unwrap()
.contains(&serde_json::json!("public")));
assert!(metadata["id_token_signing_alg_values_supported"]
.as_array()
.unwrap()
.contains(&serde_json::json!("HS256")));
}
#[test]
fn discovery_metadata_issuer_matches_handler() {
let handler = OidcHandler::new("https://my-provider.com", "client-1", "secret").unwrap();
let metadata = handler.discovery_metadata();
assert_eq!(metadata["issuer"], "https://my-provider.com");
}
#[test]
fn discovery_metadata_reflects_hs512_algorithm() {
let handler = make_handler().with_algorithm(Algorithm::HS512);
let metadata = handler.discovery_metadata();
assert!(metadata["id_token_signing_alg_values_supported"]
.as_array()
.unwrap()
.contains(&serde_json::json!("HS512")));
}
#[test]
fn verify_id_token_expired_returns_expired_token_error() {
let handler = make_handler();
let token = handler.sign_id_token("1001", "nonce", "openid", 1).unwrap();
std::thread::sleep(std::time::Duration::from_secs(3));
let result = handler.verify_id_token(&token, "nonce");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::ExpiredToken(_)) => {},
other => panic!("期望 ExpiredToken 错误,实际: {:?}", other),
}
}
#[test]
fn verify_id_token_aud_mismatch_fails() {
let signer = OidcHandler::new("https://auth.example.com", "correct-aud", "secret").unwrap();
let verifier = OidcHandler::new("https://auth.example.com", "wrong-aud", "secret").unwrap();
let token = signer
.sign_id_token("1001", "nonce", "openid", 3600)
.unwrap();
let result = verifier.verify_id_token(&token, "nonce");
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => assert!(msg.contains("aud")),
other => panic!("期望 InvalidToken (aud) 错误,实际: {:?}", other),
}
}
#[test]
fn discovery_metadata_non_hmac_algorithm_omits_unknown() {
let handler = make_handler().with_algorithm(Algorithm::RS256);
let metadata = handler.discovery_metadata();
let algs = metadata["id_token_signing_alg_values_supported"]
.as_array()
.unwrap();
assert!(
!algs.contains(&serde_json::json!("unknown")),
"discovery 不得宣告 unknown 伪算法: {}",
metadata
);
assert!(
algs.is_empty(),
"非 HMAC 算法(不可签发)应输出空数组: {}",
metadata
);
assert!(metadata.get("jwks_uri").is_none());
}
fn base64_url_decode(s: &str) -> Vec<u8> {
use base64::Engine;
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(s.as_bytes())
.expect("Base64URL 解码失败")
}
#[test]
fn sign_id_token_accepts_login_id_numeric() {
let handler = OidcHandler::new("https://auth.example.com", "aud-abc", "secret").unwrap();
let token = handler
.sign_id_token("1001".to_string(), "nonce", "openid", 3600)
.unwrap();
let claims = handler.verify_id_token(&token, "nonce").unwrap();
assert_eq!(claims.login_id, "1001");
}
fn sign_token_with_multi_aud(
issuer: &str,
audiences: Vec<&str>,
secret: &str,
nonce: &str,
timeout: i64,
) -> String {
use jsonwebtoken::{Algorithm, EncodingKey, Header};
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
let claims = OidcClaims {
iss: issuer.to_string(),
sub: "1001".to_string(),
aud: OidcAudience::Multi(audiences.into_iter().map(String::from).collect()),
iat: now,
exp: now + timeout,
login_id: "1001".to_string(),
nonce: nonce.to_string(),
};
let header = Header::new(Algorithm::HS256);
let key = EncodingKey::from_secret(secret.as_bytes());
encode(&header, &claims, &key).expect("签发 multi-aud token 失败")
}
#[test]
fn verify_id_token_multi_aud_contains_client_id_succeeds() {
let handler = OidcHandler::new("https://auth.example.com", "client-b", "secret").unwrap();
let token = sign_token_with_multi_aud(
"https://auth.example.com",
vec!["client-a", "client-b", "client-c"],
"secret",
"nonce-xyz",
3600,
);
let claims = handler
.verify_id_token(&token, "nonce-xyz")
.expect("数组形式 aud 包含 client_id 时应校验通过");
assert_eq!(claims.sub, "1001");
assert_eq!(
claims.aud,
OidcAudience::Multi(vec![
"client-a".to_string(),
"client-b".to_string(),
"client-c".to_string(),
])
);
assert!(claims.aud.contains("client-b"));
assert!(!claims.aud.contains("client-d"));
}
#[test]
fn verify_id_token_multi_aud_not_containing_client_id_fails() {
let handler = OidcHandler::new("https://auth.example.com", "client-x", "secret").unwrap();
let token = sign_token_with_multi_aud(
"https://auth.example.com",
vec!["client-a", "client-b"],
"secret",
"nonce-xyz",
3600,
);
let result = handler.verify_id_token(&token, "nonce-xyz");
assert!(result.is_err(), "aud 不包含 client_id 时应校验失败");
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(msg.contains("aud"), "错误消息应包含 aud,实际: {}", msg)
},
other => panic!("期望 InvalidToken (aud 不匹配) 错误,实际: {:?}", other),
}
}
#[test]
fn verify_id_token_single_element_multi_aud_works() {
let handler =
OidcHandler::new("https://auth.example.com", "only-client", "secret").unwrap();
let token = sign_token_with_multi_aud(
"https://auth.example.com",
vec!["only-client"],
"secret",
"nonce",
3600,
);
let claims = handler
.verify_id_token(&token, "nonce")
.expect("单元素数组 aud 应校验通过");
assert!(claims.aud.contains("only-client"));
assert_eq!(
claims.aud,
OidcAudience::Multi(vec!["only-client".to_string()])
);
}
#[test]
fn oidc_audience_serde_roundtrip() {
let single = OidcAudience::Single("client-a".to_string());
let json = serde_json::to_string(&single).unwrap();
assert_eq!(json, r#""client-a""#, "Single 应序列化为 JSON 字符串");
let de: OidcAudience = serde_json::from_str(&json).unwrap();
assert_eq!(de, single);
let multi = OidcAudience::Multi(vec!["client-a".to_string(), "client-b".to_string()]);
let json = serde_json::to_string(&multi).unwrap();
assert_eq!(
json, r#"["client-a","client-b"]"#,
"Multi 应序列化为 JSON 数组"
);
let de: OidcAudience = serde_json::from_str(&json).unwrap();
assert_eq!(de, multi);
}
#[test]
fn oidc_audience_contains_behavior() {
let single = OidcAudience::Single("client-a".to_string());
assert!(single.contains("client-a"));
assert!(!single.contains("client-b"));
let multi = OidcAudience::Multi(vec!["client-a".to_string(), "client-b".to_string()]);
assert!(multi.contains("client-a"));
assert!(multi.contains("client-b"));
assert!(!multi.contains("client-c"));
let empty = OidcAudience::Multi(vec![]);
assert!(!empty.contains("client-a"));
}
}