use crate::error::{GarrisonError, GarrisonResult};
use crate::protocol::jwt::JwtHandler;
use serde::Serialize;
use std::collections::BTreeMap;
use std::sync::Arc;
pub const BACKCHANNEL_LOGOUT_EVENT_URI: &str = "http://schemas.openid.net/event/backchannel-logout";
pub const LOGOUT_TOKEN_TTL_SECS: i64 = 120;
#[derive(Debug, Clone, Serialize)]
pub struct LogoutTokenClaims {
pub iss: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub sub: Option<String>,
pub aud: String,
pub iat: i64,
pub exp: i64,
pub jti: String,
pub events: BTreeMap<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sid: Option<String>,
}
pub struct LogoutTokenIssuer {
handler: Arc<JwtHandler>,
issuer: String,
}
impl LogoutTokenIssuer {
pub fn new(handler: Arc<JwtHandler>, issuer: impl Into<String>) -> Self {
Self {
handler,
issuer: issuer.into(),
}
}
pub fn issue(
&self,
client_id: &str,
sub: Option<&str>,
sid: Option<&str>,
) -> GarrisonResult<String> {
let iat = unix_now_secs()?;
let exp = iat
.checked_add(LOGOUT_TOKEN_TTL_SECS)
.ok_or_else(|| GarrisonError::InvalidParam("logout-token-ttl-overflow".to_string()))?;
let events = BTreeMap::from([(
BACKCHANNEL_LOGOUT_EVENT_URI.to_string(),
serde_json::json!({}),
)]);
let claims = LogoutTokenClaims {
iss: self.issuer.clone(),
sub: sub.map(str::to_string),
aud: client_id.to_string(),
iat,
exp,
jti: uuid::Uuid::new_v4().to_string(),
events,
sid: sid.map(str::to_string),
};
self.handler.sign_claims(&claims)
}
}
fn unix_now_secs() -> GarrisonResult<i64> {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.map_err(|e| GarrisonError::Internal(format!("system-clock-error::{}", e)))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::protocol::jwt::JwtHandler;
const SECRET: &str = "0123456789abcdef0123456789abcdef";
fn issuer() -> LogoutTokenIssuer {
LogoutTokenIssuer::new(Arc::new(JwtHandler::new(SECRET)), "https://op.example.com")
}
fn decode_claims(token: &str, secret: &[u8]) -> serde_json::Value {
use jsonwebtoken::{decode, Algorithm, DecodingKey, Validation};
let mut validation = Validation::new(Algorithm::HS256);
validation.validate_exp = false;
validation.validate_aud = false;
validation.required_spec_claims.clear();
decode::<serde_json::Value>(token, &DecodingKey::from_secret(secret), &validation)
.expect("解码应成功")
.claims
}
#[test]
fn logout_token_carries_events_and_no_identity_claims_beyond_subject() {
let token = issuer()
.issue("client-a", Some("alice"), None)
.expect("签发应成功");
let claims = decode_claims(&token, SECRET.as_bytes());
let events = claims["events"].as_object().expect("events 应为对象");
assert!(
events.contains_key(BACKCHANNEL_LOGOUT_EVENT_URI),
"events 必须含 backchannel-logout 事件 URI,实际: {events:?}"
);
assert!(
events[BACKCHANNEL_LOGOUT_EVENT_URI].is_object(),
"事件载荷应为对象"
);
assert_eq!(events.len(), 1, "不得夹带其他事件");
assert_eq!(claims["iss"], "https://op.example.com");
assert_eq!(claims["aud"], "client-a");
assert_eq!(claims["sub"], "alice");
assert!(
claims["jti"].as_str().is_some_and(|j| !j.is_empty()),
"jti 必须存在且非空"
);
assert_eq!(
claims["exp"].as_i64().unwrap() - claims["iat"].as_i64().unwrap(),
LOGOUT_TOKEN_TTL_SECS
);
for forbidden in ["login_id", "device", "nonce"] {
assert!(
claims.get(forbidden).is_none(),
"logout token 不得携带身份 claim `{forbidden}`,实际: {claims}"
);
}
assert!(claims.get("sid").is_none(), "sid 未提供时不得出现");
}
#[test]
fn logout_token_without_subject_omits_sub() {
let token = issuer().issue("client-a", None, None).expect("签发应成功");
let claims = decode_claims(&token, SECRET.as_bytes());
assert!(claims.get("sub").is_none(), "sub=None 时不得序列化 sub");
}
#[test]
fn logout_token_includes_sid_when_provided() {
let token = issuer()
.issue("client-a", Some("alice"), Some("sess-42"))
.expect("签发应成功");
let claims = decode_claims(&token, SECRET.as_bytes());
assert_eq!(claims["sid"], "sess-42");
}
#[test]
fn logout_token_signature_binds_issuer_key() {
let token = issuer()
.issue("client-a", Some("alice"), None)
.expect("签发应成功");
let mut validation = jsonwebtoken::Validation::new(jsonwebtoken::Algorithm::HS256);
validation.validate_exp = false;
validation.validate_aud = false;
validation.required_spec_claims.clear();
let wrong_key = jsonwebtoken::DecodingKey::from_secret(b"wrong-secret-wrong-secret-32b");
assert!(
jsonwebtoken::decode::<serde_json::Value>(&token, &wrong_key, &validation).is_err(),
"错误密钥验签必须失败"
);
}
}