use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::Duration;
const HTTP_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
const HTTP_READ_TIMEOUT: Duration = Duration::from_secs(30);
const MAX_BODY_BYTES: usize = 4 * 1024 * 1024;
fn build_safe_http_client() -> GarrisonResult<reqwest::Client> {
reqwest::Client::builder()
.connect_timeout(HTTP_CONNECT_TIMEOUT)
.read_timeout(HTTP_READ_TIMEOUT)
.build()
.map_err(|e| GarrisonError::Network(format!("sso-oidc-http-client-build::{}", e)))
}
fn validate_endpoint_scheme(url: &str, field: &str) -> GarrisonResult<()> {
let reject = || GarrisonError::Config(format!("url-scheme-https-required::{}::{}", field, url));
let scheme_end = url.find("://").ok_or_else(reject)?;
let rest = &url[scheme_end + 3..];
match &url[..scheme_end] {
"https" => Ok(()),
"http" => {
let host_end = rest.find(['/', ':', '?']).unwrap_or(rest.len());
if matches!(&rest[..host_end], "localhost" | "127.0.0.1") {
Ok(())
} else {
Err(reject())
}
},
_ => Err(reject()),
}
}
async fn read_limited_bytes(resp: reqwest::Response) -> GarrisonResult<Vec<u8>> {
let mut buf: Vec<u8> = Vec::new();
let mut resp = resp;
while let Some(chunk) = resp
.chunk()
.await
.map_err(|e| GarrisonError::Network(format!("sso-oidc-body-read::{}", e)))?
{
let new_len = buf
.len()
.checked_add(chunk.len())
.ok_or_else(|| GarrisonError::Network("sso-oidc-body-overflow".to_string()))?;
if new_len > MAX_BODY_BYTES {
return Err(GarrisonError::Network(format!(
"sso-oidc-body-exceeds-limit::{}",
MAX_BODY_BYTES
)));
}
buf.extend_from_slice(&chunk);
}
Ok(buf)
}
async fn read_limited_text(resp: reqwest::Response) -> GarrisonResult<String> {
let bytes = read_limited_bytes(resp).await?;
String::from_utf8(bytes)
.map_err(|e| GarrisonError::Network(format!("sso-oidc-body-utf8::{}", e)))
}
#[cfg(feature = "protocol-jwt")]
const JWKS_CACHE_TTL: Duration = Duration::from_secs(600);
const OIDC_STATE_TTL: Duration = Duration::from_secs(600);
#[cfg(feature = "protocol-jwt")]
const JWKS_CACHE_KEY_PREFIX: &str = "oidc:jwks:";
const OIDC_STATE_KEY_PREFIX: &str = "oidc:state:";
const URLENCODE_SET: &AsciiSet = &NON_ALPHANUMERIC
.remove(b'-')
.remove(b'_')
.remove(b'.')
.remove(b'~');
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcDiscoveryConfig {
pub issuer: String,
pub authorization_endpoint: String,
pub token_endpoint: String,
pub userinfo_endpoint: String,
pub jwks_uri: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcUserInfo {
pub sub: String,
#[serde(default)]
pub email: String,
#[serde(default)]
pub name: String,
#[serde(default)]
pub preferred_username: String,
#[serde(default)]
pub picture: String,
}
#[async_trait]
pub trait OidcProvider: Send + Sync {
async fn get_authorization_url(
&self,
redirect_uri: &str,
state: &str,
scopes: &[&str],
) -> GarrisonResult<String>;
async fn exchange_code(
&self,
code: &str,
redirect_uri: &str,
state: &str,
) -> GarrisonResult<String>;
async fn get_user_info(&self, access_token: &str) -> GarrisonResult<OidcUserInfo>;
async fn validate_id_token(&self, id_token: &str) -> GarrisonResult<bool>;
}
#[cfg(feature = "protocol-jwt")]
#[derive(Debug, Clone, Deserialize, Serialize)]
struct Jwk {
kid: String,
n: String,
e: String,
}
#[cfg(feature = "protocol-jwt")]
#[derive(Debug, Clone, Deserialize, Serialize)]
struct JwksResponse {
keys: Vec<Jwk>,
}
pub struct DefaultOidcProvider {
config: OidcDiscoveryConfig,
client_id: String,
client_secret: String,
http_client: reqwest::Client,
dao: Option<Arc<dyn GarrisonDao>>,
state_ttl: Duration,
#[cfg(feature = "protocol-jwt")]
jwks_fetch_lock: tokio::sync::Mutex<()>,
}
impl DefaultOidcProvider {
pub fn new(
config: OidcDiscoveryConfig,
client_id: &str,
client_secret: &str,
) -> GarrisonResult<Self> {
validate_endpoint_scheme(&config.authorization_endpoint, "authorization_endpoint")?;
validate_endpoint_scheme(&config.token_endpoint, "token_endpoint")?;
validate_endpoint_scheme(&config.userinfo_endpoint, "userinfo_endpoint")?;
validate_endpoint_scheme(&config.jwks_uri, "jwks_uri")?;
let http_client = build_safe_http_client()?;
Ok(Self {
config,
client_id: client_id.to_string(),
client_secret: client_secret.to_string(),
http_client,
dao: None,
state_ttl: OIDC_STATE_TTL,
#[cfg(feature = "protocol-jwt")]
jwks_fetch_lock: tokio::sync::Mutex::new(()),
})
}
pub fn with_dao(mut self, dao: Arc<dyn GarrisonDao>) -> Self {
self.dao = Some(dao);
self
}
#[cfg(test)]
pub fn with_state_ttl(mut self, ttl: Duration) -> Self {
self.state_ttl = ttl;
self
}
#[cfg(feature = "protocol-jwt")]
fn jwks_cache_key(&self) -> String {
format!("{}{}", JWKS_CACHE_KEY_PREFIX, self.config.issuer)
}
fn state_cache_key(state: &str) -> String {
format!("{}{}", OIDC_STATE_KEY_PREFIX, state)
}
async fn register_state(&self, state: &str) -> GarrisonResult<()> {
let dao = self.dao.as_ref().ok_or_else(|| {
GarrisonError::Config("sso-oidc-dao-missing-register-state".to_string())
})?;
let key = Self::state_cache_key(state);
dao.set(&key, "1", self.state_ttl.as_secs()).await
}
async fn validate_and_consume_state(&self, state: &str) -> GarrisonResult<()> {
let dao = self.dao.as_ref().ok_or_else(|| {
GarrisonError::Config("sso-oidc-dao-missing-validate-state".to_string())
})?;
let key = Self::state_cache_key(state);
let value = dao.get_and_delete(&key).await?;
match value {
Some(_) => Ok(()),
None => Err(GarrisonError::InvalidParam(format!(
"sso-oidc-state-mismatch-or-expired::{}",
self.state_ttl.as_secs()
))),
}
}
#[cfg(feature = "protocol-jwt")]
async fn fetch_jwks(&self) -> GarrisonResult<()> {
let dao = self
.dao
.as_ref()
.ok_or_else(|| GarrisonError::Config("sso-oidc-dao-missing-cache-jwks".to_string()))?;
let resp = {
let mut attempt = 1;
loop {
match self.http_client.get(&self.config.jwks_uri).send().await {
Ok(resp) => break resp,
Err(e) if attempt < 2 => {
attempt += 1;
tracing::warn!(
"{}",
crate::i18n::translate_detail(
"logs-sso-oidc-jwks-fetch-retry",
&[("error", &e.to_string())]
)
);
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
},
Err(e) => {
return Err(GarrisonError::Internal(format!(
"sso-oidc-jwks-request::{}",
e
)));
},
}
}
};
if !resp.status().is_success() {
let status = resp.status();
let body = read_limited_text(resp).await.unwrap_or_default();
return Err(GarrisonError::Internal(format!(
"sso-oidc-jwks-status-error::{}::{}",
status, body
)));
}
let bytes = read_limited_bytes(resp)
.await
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-jwks-body-read::{}", e)))?;
let jwks: JwksResponse = serde_json::from_slice(&bytes)
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-jwks-parse::{}", e)))?;
let json = serde_json::to_string(&jwks)
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-jwks-serialize::{}", e)))?;
let cache_key = self.jwks_cache_key();
dao.set(&cache_key, &json, JWKS_CACHE_TTL.as_secs()).await?;
Ok(())
}
#[cfg(feature = "protocol-jwt")]
fn sanitize_kid(kid: &str) -> String {
let filtered: String = kid.chars().filter(|c| !c.is_control()).collect();
filtered.chars().take(128).collect()
}
async fn validate_id_token_impl(&self, id_token: &str) -> GarrisonResult<bool> {
use jsonwebtoken::{decode, Algorithm, DecodingKey, Validation};
#[derive(Deserialize, Debug)]
#[serde(untagged)]
enum Aud {
Single(String),
Multi(Vec<String>),
}
impl Aud {
fn contains(&self, client_id: &str) -> bool {
match self {
Aud::Single(s) => s == client_id,
Aud::Multi(v) => v.iter().any(|s| s == client_id),
}
}
}
#[derive(Deserialize)]
struct IdTokenClaims {
iss: String,
aud: Aud,
}
let dao = self
.dao
.as_ref()
.ok_or_else(|| GarrisonError::Config("sso-oidc-dao-missing-cache-jwks".to_string()))?;
let header = jsonwebtoken::decode_header(id_token).map_err(|e| {
GarrisonError::InvalidToken(format!("sso-oidc-id-token-header-parse::{}", e))
})?;
let kid = header.kid.as_deref().ok_or_else(|| {
GarrisonError::InvalidToken("sso-oidc-id-token-header-missing-kid".to_string())
})?;
let cache_key = self.jwks_cache_key();
let cached = dao.get(&cache_key).await?;
let (jwks, fresh): (JwksResponse, bool) = match cached
.as_deref()
.and_then(|json| serde_json::from_str(json).ok())
{
Some(jwks) => (jwks, false),
None => {
let _lock = self.jwks_fetch_lock.lock().await;
let cached = dao.get(&cache_key).await?;
match cached
.as_deref()
.and_then(|s| serde_json::from_str::<JwksResponse>(s).ok())
{
Some(jwks) => (jwks, false),
None => {
self.fetch_jwks().await?;
let json = dao.get(&cache_key).await?.ok_or_else(|| {
GarrisonError::Internal(
"sso-oidc-jwks-cache-empty-after-fetch".to_string(),
)
})?;
(
serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(format!("sso-oidc-jwks-parse::{}", e))
})?,
true,
)
},
}
},
};
let jwk = match jwks.keys.iter().find(|k| k.kid == kid).cloned() {
Some(jwk) => jwk,
None if !fresh => {
let _lock = self.jwks_fetch_lock.lock().await;
let cached = dao.get(&cache_key).await?;
let refreshed = match cached
.as_deref()
.and_then(|s| serde_json::from_str::<JwksResponse>(s).ok())
{
Some(jwks) => jwks,
None => {
self.fetch_jwks().await?;
let json = dao.get(&cache_key).await?.ok_or_else(|| {
GarrisonError::Internal(
"sso-oidc-jwks-cache-empty-after-fetch".to_string(),
)
})?;
serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(format!("sso-oidc-jwks-parse::{}", e))
})?
},
};
refreshed
.keys
.iter()
.find(|k| k.kid == kid)
.cloned()
.ok_or_else(|| {
GarrisonError::InvalidToken(format!(
"sso-oidc-jwks-key-not-found::{}",
Self::sanitize_kid(kid)
))
})?
},
None => {
return Err(GarrisonError::InvalidToken(format!(
"sso-oidc-jwks-key-not-found::{}",
Self::sanitize_kid(kid)
)))
},
};
let decoding_key = DecodingKey::from_rsa_components(&jwk.n, &jwk.e)
.map_err(|e| GarrisonError::InvalidToken(format!("sso-oidc-rsa-build::{}", e)))?;
let mut validation = Validation::new(Algorithm::RS256);
validation.validate_exp = true;
validation.validate_nbf = true; validation.leeway = 0;
validation.validate_aud = false;
let token_data =
decode::<IdTokenClaims>(id_token, &decoding_key, &validation).map_err(|e| {
let msg = e.to_string();
if msg.contains("ExpiredSignature") {
GarrisonError::InvalidToken("sso-oidc-id-token-expired".to_string())
} else {
GarrisonError::InvalidToken(format!("sso-oidc-id-token-verify::{}", e))
}
})?;
if token_data.claims.iss != self.config.issuer {
return Err(GarrisonError::InvalidToken(format!(
"sso-oidc-id-token-invalid::{}::{}",
self.config.issuer, token_data.claims.iss
)));
}
if !token_data.claims.aud.contains(&self.client_id) {
return Err(GarrisonError::InvalidToken(format!(
"sso-oidc-id-token-invalid::{}::{:?}",
self.client_id, token_data.claims.aud
)));
}
Ok(true)
}
}
#[async_trait]
impl OidcProvider for DefaultOidcProvider {
async fn get_authorization_url(
&self,
redirect_uri: &str,
state: &str,
scopes: &[&str],
) -> GarrisonResult<String> {
self.register_state(state).await?;
let scope = scopes.join(" ");
let url = format!(
"{}?response_type=code&client_id={}&redirect_uri={}&state={}&scope={}",
self.config.authorization_endpoint,
url_encode(&self.client_id),
url_encode(redirect_uri),
url_encode(state),
url_encode(&scope),
);
Ok(url)
}
async fn exchange_code(
&self,
code: &str,
redirect_uri: &str,
state: &str,
) -> GarrisonResult<String> {
self.validate_and_consume_state(state).await?;
let params = [
("grant_type", "authorization_code"),
("code", code),
("redirect_uri", redirect_uri),
("client_id", &self.client_id),
("client_secret", &self.client_secret),
];
let resp = self
.http_client
.post(&self.config.token_endpoint)
.form(¶ms)
.send()
.await
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-token-exchange::{}", e)))?;
if !resp.status().is_success() {
let status = resp.status();
let body = read_limited_text(resp).await.unwrap_or_default();
return Err(GarrisonError::Internal(format!(
"sso-oidc-token-status-error::{}::{}",
status, body
)));
}
let bytes = read_limited_bytes(resp)
.await
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-token-body-read::{}", e)))?;
let token_response: TokenResponse = serde_json::from_slice(&bytes)
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-token-parse::{}", e)))?;
let id_token = token_response
.id_token
.ok_or_else(|| GarrisonError::Internal("sso-oidc-missing-id-token".to_string()))?;
#[cfg(feature = "protocol-jwt")]
{
self.validate_id_token_impl(&id_token).await?;
}
#[cfg(not(feature = "protocol-jwt"))]
{
return Err(GarrisonError::Config(
"sso-oidc-id-token-verification-unavailable::enable-protocol-jwt".to_string(),
));
}
Ok(id_token)
}
async fn get_user_info(&self, access_token: &str) -> GarrisonResult<OidcUserInfo> {
let resp = self
.http_client
.get(&self.config.userinfo_endpoint)
.bearer_auth(access_token)
.send()
.await
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-userinfo-request::{}", e)))?;
if !resp.status().is_success() {
let status = resp.status();
let body = read_limited_text(resp).await.unwrap_or_default();
return Err(GarrisonError::Internal(format!(
"sso-oidc-userinfo-status-error::{}::{}",
status, body
)));
}
let bytes = read_limited_bytes(resp)
.await
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-userinfo-body-read::{}", e)))?;
serde_json::from_slice::<OidcUserInfo>(&bytes)
.map_err(|e| GarrisonError::Internal(format!("sso-oidc-userinfo-parse::{}", e)))
}
async fn validate_id_token(&self, id_token: &str) -> GarrisonResult<bool> {
#[cfg(feature = "protocol-jwt")]
{
return self.validate_id_token_impl(id_token).await;
}
#[cfg(not(feature = "protocol-jwt"))]
{
let _ = id_token;
Err(GarrisonError::NotImplemented(
"sso-oidc-validate-not-implemented".to_string(),
))
}
}
}
#[cfg(feature = "protocol-zeroize")]
impl Drop for DefaultOidcProvider {
fn drop(&mut self) {
use zeroize::Zeroize;
self.client_secret.zeroize();
}
}
#[derive(Debug, Deserialize)]
struct TokenResponse {
id_token: Option<String>,
#[allow(
dead_code,
reason = "OAuth2 标准字段:当前仅用 id_token,access_token 预留供 protocol-jwt 扩展"
)]
access_token: Option<String>,
#[allow(dead_code, reason = "OAuth2 标准字段:预留 token_type 供后续扩展")]
token_type: Option<String>,
#[allow(dead_code, reason = "OAuth2 标准字段:预留 expires_in 供后续扩展")]
expires_in: Option<i64>,
}
fn url_encode(s: &str) -> String {
utf8_percent_encode(s, URLENCODE_SET).to_string()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
#[test]
fn oidc_discovery_config_serde_roundtrip() {
let config = OidcDiscoveryConfig {
issuer: "https://accounts.google.com".to_string(),
authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth".to_string(),
token_endpoint: "https://oauth2.googleapis.com/token".to_string(),
userinfo_endpoint: "https://openidconnect.googleapis.com/v1/userinfo".to_string(),
jwks_uri: "https://www.googleapis.com/oauth2/v3/certs".to_string(),
};
let json = serde_json::to_string(&config).unwrap();
let deserialized: OidcDiscoveryConfig = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized.issuer, config.issuer);
assert_eq!(
deserialized.authorization_endpoint,
config.authorization_endpoint
);
assert_eq!(deserialized.token_endpoint, config.token_endpoint);
assert_eq!(deserialized.userinfo_endpoint, config.userinfo_endpoint);
assert_eq!(deserialized.jwks_uri, config.jwks_uri);
}
#[test]
fn oidc_user_info_serde_roundtrip() {
let user_info = OidcUserInfo {
sub: "1234567890".to_string(),
email: "user@example.com".to_string(),
name: "Test User".to_string(),
preferred_username: "testuser".to_string(),
picture: "https://example.com/avatar.png".to_string(),
};
let json = serde_json::to_string(&user_info).unwrap();
let deserialized: OidcUserInfo = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized.sub, user_info.sub);
assert_eq!(deserialized.email, user_info.email);
assert_eq!(deserialized.name, user_info.name);
assert_eq!(
deserialized.preferred_username,
user_info.preferred_username
);
assert_eq!(deserialized.picture, user_info.picture);
}
#[test]
fn oidc_user_info_missing_optional_claims_deserializes() {
let deserialized: OidcUserInfo =
serde_json::from_str(r#"{"sub":"sub-only"}"#).expect("仅 sub 应可反序列化");
assert_eq!(deserialized.sub, "sub-only");
assert_eq!(deserialized.email, "", "缺失的可选 claim 应为空字符串");
assert_eq!(deserialized.name, "");
assert_eq!(deserialized.preferred_username, "");
assert_eq!(deserialized.picture, "");
assert!(
serde_json::from_str::<OidcUserInfo>(r#"{"email":"a@b.com"}"#).is_err(),
"缺失必需的 sub 应反序列化失败"
);
}
#[test]
fn oidc_discovery_config_implements_clone_debug() {
let config = make_test_config();
let cloned = config.clone();
assert_eq!(cloned.issuer, config.issuer);
let debug_str = format!("{:?}", config);
assert!(debug_str.contains("OidcDiscoveryConfig"));
}
#[test]
fn oidc_user_info_implements_clone_debug() {
let user_info = OidcUserInfo {
sub: "sub-1".to_string(),
email: "a@b.com".to_string(),
name: "A".to_string(),
preferred_username: "a".to_string(),
picture: "pic".to_string(),
};
let cloned = user_info.clone();
assert_eq!(cloned.sub, user_info.sub);
let debug_str = format!("{:?}", user_info);
assert!(debug_str.contains("OidcUserInfo"));
}
fn make_test_config() -> OidcDiscoveryConfig {
OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: "https://idp.example.com/token".to_string(),
userinfo_endpoint: "https://idp.example.com/userinfo".to_string(),
jwks_uri: "https://idp.example.com/jwks".to_string(),
}
}
#[test]
fn default_oidc_provider_new_returns_instance() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "client-id", "client-secret").unwrap();
assert_eq!(provider.client_id, "client-id");
assert_eq!(provider.client_secret, "client-secret");
}
#[test]
fn new_rejects_plaintext_http_endpoint() {
let mut config = make_test_config();
config.token_endpoint = "http://idp.example.com/token".to_string();
let result = DefaultOidcProvider::new(config, "cid", "secret");
match result {
Err(GarrisonError::Config(msg)) => {
assert!(
msg.contains("token_endpoint"),
"错误应指明 token_endpoint,实际: {}",
msg
);
},
Err(other) => panic!("期望 Config,实际: {:?}", other),
Ok(_) => panic!("公网明文 http token_endpoint 应被构造期拒绝"),
}
}
#[test]
fn new_allows_localhost_http_endpoints() {
let mut config = make_test_config();
config.authorization_endpoint = "http://127.0.0.1:9000/authorize".to_string();
config.token_endpoint = "http://localhost:9000/token".to_string();
let result = DefaultOidcProvider::new(config, "cid", "secret");
assert!(
result.is_ok(),
"localhost http 端点应放行,实际: {:?}",
result.err()
);
}
#[test]
fn default_oidc_provider_implements_oidc_provider() {
fn assert_oidc_provider<T: OidcProvider>(_provider: &T) {}
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "id", "secret").unwrap();
assert_oidc_provider(&provider);
}
#[tokio::test]
async fn get_authorization_url_constructs_valid_url() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "test-client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let url = provider
.get_authorization_url(
"https://sp.example.com/callback",
"xyz-state",
&["openid", "profile", "email"],
)
.await
.unwrap();
assert!(url.starts_with("https://idp.example.com/authorize?"));
assert!(url.contains("response_type=code"));
assert!(url.contains("client_id=test-client-id"));
assert!(url.contains("redirect_uri=https%3A%2F%2Fsp.example.com%2Fcallback"));
assert!(url.contains("state=xyz-state"));
assert!(url.contains("scope=openid%20profile%20email"));
}
#[tokio::test]
async fn get_authorization_url_single_scope() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let url = provider
.get_authorization_url("https://cb.com/cb", "st", &["openid"])
.await
.unwrap();
assert!(url.contains("scope=openid"));
}
#[tokio::test]
async fn get_authorization_url_empty_scopes() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let url = provider
.get_authorization_url("https://cb.com/cb", "st", &[])
.await
.unwrap();
assert!(url.contains("scope="));
}
#[cfg(not(feature = "protocol-jwt"))]
#[tokio::test]
async fn validate_id_token_returns_not_implemented() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "id", "secret").unwrap();
let result = provider.validate_id_token("fake.jwt.token").await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::NotImplemented(_)) => {},
other => panic!("期望 NotImplemented 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn exchange_code_success_returns_id_token() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let issuer = "https://idp.example.com".to_string();
#[cfg(feature = "protocol-jwt")]
let (id_token, jwks_json) = make_valid_id_token(&issuer, "cid");
#[cfg(not(feature = "protocol-jwt"))]
let id_token: String = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyMTIzIn0.signature".to_string();
#[cfg(feature = "protocol-jwt")]
{
Mock::given(method("GET"))
.and(path("/jwks"))
.respond_with(ResponseTemplate::new(200).set_body_json(jwks_json))
.mount(&mock_server)
.await;
}
let config = OidcDiscoveryConfig {
issuer,
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: format!("{}/jwks", mock_server.uri()),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"id_token": id_token,
"access_token": "access-123",
"token_type": "Bearer",
"expires_in": 3600
})))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url(
"https://sp.example.com/callback",
"state-test-1",
&["openid"],
)
.await
.unwrap();
let returned_id_token = provider
.exchange_code(
"auth-code-123",
"https://sp.example.com/callback",
"state-test-1",
)
.await
.unwrap();
assert_eq!(returned_id_token, id_token);
}
#[tokio::test]
async fn exchange_code_error_status_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(400).set_body_string("invalid_grant"))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url(
"https://sp.example.com/callback",
"state-test-2",
&["openid"],
)
.await
.unwrap();
let result = provider
.exchange_code(
"bad-code",
"https://sp.example.com/callback",
"state-test-2",
)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn exchange_code_missing_id_token_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "access-123",
"token_type": "Bearer",
"expires_in": 3600
})))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url(
"https://sp.example.com/callback",
"state-test-3",
&["openid"],
)
.await
.unwrap();
let result = provider
.exchange_code(
"auth-code",
"https://sp.example.com/callback",
"state-test-3",
)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn get_user_info_success_returns_user_info() {
use wiremock::matchers::{header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("GET"))
.and(path("/userinfo"))
.and(header("authorization", "Bearer access-token-123"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"sub": "user-123",
"email": "user@example.com",
"name": "Test User",
"preferred_username": "testuser",
"picture": "https://example.com/avatar.png"
})))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let user_info = provider.get_user_info("access-token-123").await.unwrap();
assert_eq!(user_info.sub, "user-123");
assert_eq!(user_info.email, "user@example.com");
assert_eq!(user_info.name, "Test User");
assert_eq!(user_info.preferred_username, "testuser");
assert_eq!(user_info.picture, "https://example.com/avatar.png");
}
#[tokio::test]
async fn get_user_info_error_status_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("GET"))
.and(path("/userinfo"))
.respond_with(ResponseTemplate::new(401).set_body_string("invalid_token"))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.get_user_info("bad-token").await;
assert!(result.is_err());
}
#[test]
fn url_encode_encodes_special_chars() {
assert_eq!(url_encode("hello world"), "hello%20world");
assert_eq!(url_encode("a&b=c"), "a%26b%3Dc");
assert_eq!(
url_encode("https://example.com"),
"https%3A%2F%2Fexample.com"
);
assert_eq!(url_encode("plain"), "plain");
}
#[test]
fn url_encode_encodes_percent_sign() {
assert_eq!(url_encode("%"), "%25");
assert_eq!(url_encode("100%done"), "100%25done");
assert_eq!(url_encode("%26"), "%2526");
assert_eq!(url_encode("%3D"), "%253D");
}
#[cfg(feature = "protocol-jwt")]
fn make_test_rsa_key() -> (jsonwebtoken::EncodingKey, String, String) {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use jsonwebtoken::EncodingKey;
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
let mut rng = rsa::rand_core::OsRng;
let private_key = RsaPrivateKey::new(&mut rng, 2048).expect("生成 RSA 私钥应成功");
let public_key = RsaPublicKey::from(&private_key);
let n_b64 = URL_SAFE_NO_PAD.encode(public_key.n().to_bytes_be());
let e_b64 = URL_SAFE_NO_PAD.encode(public_key.e().to_bytes_be());
let der = private_key.to_pkcs1_der().expect("转 PKCS#1 DER 应成功");
let encoding_key = EncodingKey::from_rsa_der(der.as_bytes());
(encoding_key, n_b64, e_b64)
}
#[cfg(feature = "protocol-jwt")]
fn now_unix() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时间应早于 UNIX_EPOCH")
.as_secs() as i64
}
#[cfg(feature = "protocol-jwt")]
fn sign_test_jwt(
encoding_key: &jsonwebtoken::EncodingKey,
kid: &str,
iss: &str,
aud: &str,
exp: i64,
) -> String {
use jsonwebtoken::{encode, Algorithm, Header};
use serde::Serialize;
#[derive(Serialize)]
struct TestClaims {
iss: String,
aud: String,
exp: i64,
sub: String,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some(kid.to_string());
let claims = TestClaims {
iss: iss.to_string(),
aud: aud.to_string(),
exp,
sub: "user-123".to_string(),
};
encode(&header, &claims, encoding_key).expect("签发 JWT 应成功")
}
#[cfg(feature = "protocol-jwt")]
fn sign_test_jwt_with_aud_value(
encoding_key: &jsonwebtoken::EncodingKey,
kid: &str,
iss: &str,
aud: serde_json::Value,
exp: i64,
) -> String {
use jsonwebtoken::{encode, Algorithm, Header};
use serde::Serialize;
#[derive(Serialize)]
struct TestClaims {
iss: String,
aud: serde_json::Value,
exp: i64,
sub: String,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some(kid.to_string());
let claims = TestClaims {
iss: iss.to_string(),
aud,
exp,
sub: "user-123".to_string(),
};
encode(&header, &claims, encoding_key).expect("签发 JWT 应成功")
}
#[cfg(feature = "protocol-jwt")]
fn make_jwks_json(kid: &str, n_b64: &str, e_b64: &str) -> serde_json::Value {
serde_json::json!({
"keys": [{
"kty": "RSA",
"kid": kid,
"use": "sig",
"alg": "RS256",
"n": n_b64,
"e": e_b64,
}]
})
}
#[cfg(feature = "protocol-jwt")]
fn make_valid_id_token(issuer: &str, client_id: &str) -> (String, serde_json::Value) {
let (encoding_key, n_b64, e_b64) = make_test_rsa_key();
let id_token = sign_test_jwt(&encoding_key, "key1", issuer, client_id, now_unix() + 3600);
let jwks_json = make_jwks_json("key1", &n_b64, &e_b64);
(id_token, jwks_json)
}
#[cfg(feature = "protocol-jwt")]
async fn setup_jwks_mock_server(
jwks_json: serde_json::Value,
) -> (wiremock::MockServer, OidcDiscoveryConfig) {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
let issuer = "https://idp.example.com".to_string();
Mock::given(method("GET"))
.and(path("/jwks"))
.respond_with(ResponseTemplate::new(200).set_body_json(jwks_json))
.mount(&server)
.await;
let config = OidcDiscoveryConfig {
issuer,
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", server.uri()),
userinfo_endpoint: format!("{}/userinfo", server.uri()),
jwks_uri: format!("{}/jwks", server.uri()),
};
(server, config)
}
#[cfg(feature = "protocol-jwt")]
#[test]
fn sanitize_kid_filters_control_chars_and_limits_len() {
assert_eq!(DefaultOidcProvider::sanitize_kid("abc123"), "abc123");
assert_eq!(
DefaultOidcProvider::sanitize_kid("bad\x01kid\x7f"),
"badkid"
);
let long = "a".repeat(200);
assert_eq!(DefaultOidcProvider::sanitize_kid(&long).len(), 128);
}
#[tokio::test]
async fn validate_id_token_rejects_invalid_signature() {
let (encoding_key_signer, _n_signer, _e_signer) = make_test_rsa_key();
let (_encoding_key_other, n_other, e_other) = make_test_rsa_key();
let jwks_json = make_jwks_json("key1", &n_other, &e_other);
let (_server, config) = setup_jwks_mock_server(jwks_json).await;
let id_token = sign_test_jwt(
&encoding_key_signer,
"key1",
&config.issuer,
"client-id",
now_unix() + 3600,
);
let provider = DefaultOidcProvider::new(config, "client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.validate_id_token(&id_token).await;
assert!(result.is_err(), "无效签名应返回错误");
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("sso-oidc-id-token-verify"),
"无效签名应返回验签失败消息,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn validate_id_token_rejects_expired_token() {
let (encoding_key, n_b64, e_b64) = make_test_rsa_key();
let jwks_json = make_jwks_json("key1", &n_b64, &e_b64);
let (_server, config) = setup_jwks_mock_server(jwks_json).await;
let id_token = sign_test_jwt(
&encoding_key,
"key1",
&config.issuer,
"client-id",
now_unix() - 3600,
);
let provider = DefaultOidcProvider::new(config, "client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.validate_id_token(&id_token).await;
assert!(result.is_err(), "过期 token 应返回错误");
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("过期") || msg.contains("expired"),
"过期 token 应返回过期相关消息,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn validate_id_token_rejects_wrong_issuer() {
let (encoding_key, n_b64, e_b64) = make_test_rsa_key();
let jwks_json = make_jwks_json("key1", &n_b64, &e_b64);
let (_server, config) = setup_jwks_mock_server(jwks_json).await;
let id_token = sign_test_jwt(
&encoding_key,
"key1",
"https://wrong-issuer.example.com",
"client-id",
now_unix() + 3600,
);
let provider = DefaultOidcProvider::new(config, "client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.validate_id_token(&id_token).await;
assert!(result.is_err(), "iss 不匹配应返回错误");
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("iss"),
"iss 不匹配应返回 iss 相关消息,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn validate_id_token_rejects_wrong_audience() {
let (encoding_key, n_b64, e_b64) = make_test_rsa_key();
let jwks_json = make_jwks_json("key1", &n_b64, &e_b64);
let (_server, config) = setup_jwks_mock_server(jwks_json).await;
let id_token = sign_test_jwt(
&encoding_key,
"key1",
&config.issuer,
"wrong-aud",
now_unix() + 3600,
);
let provider = DefaultOidcProvider::new(config, "client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.validate_id_token(&id_token).await;
assert!(result.is_err(), "aud 不匹配应返回错误");
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("sso-oidc-id-token-invalid"),
"aud 不匹配应返回 aud 相关消息,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn validate_id_token_accepts_aud_array_containing_client_id() {
let (encoding_key, n_b64, e_b64) = make_test_rsa_key();
let jwks_json = make_jwks_json("key1", &n_b64, &e_b64);
let (_server, config) = setup_jwks_mock_server(jwks_json).await;
let id_token = sign_test_jwt_with_aud_value(
&encoding_key,
"key1",
&config.issuer,
serde_json::json!(["client-id", "account"]),
now_unix() + 3600,
);
let provider = DefaultOidcProvider::new(config, "client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.validate_id_token(&id_token).await;
assert!(
result.is_ok(),
"aud 为数组含 client_id 时应校验通过(H3),实际: {:?}",
result
);
assert!(result.unwrap());
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn validate_id_token_rejects_aud_array_without_client_id() {
let (encoding_key, n_b64, e_b64) = make_test_rsa_key();
let jwks_json = make_jwks_json("key1", &n_b64, &e_b64);
let (_server, config) = setup_jwks_mock_server(jwks_json).await;
let id_token = sign_test_jwt_with_aud_value(
&encoding_key,
"key1",
&config.issuer,
serde_json::json!(["other-client", "account"]),
now_unix() + 3600,
);
let provider = DefaultOidcProvider::new(config, "client-id", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.validate_id_token(&id_token).await;
assert!(result.is_err(), "aud 数组不含 client_id 时应返回错误");
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("sso-oidc-id-token-invalid"),
"aud 不匹配应返回 aud 相关消息,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn exchange_code_validates_id_token() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let (encoding_key_signer, _n_signer, _e_signer) = make_test_rsa_key();
let (_encoding_key_other, n_other, e_other) = make_test_rsa_key();
let mock_server = MockServer::start().await;
let issuer = "https://idp.example.com".to_string();
Mock::given(method("GET"))
.and(path("/jwks"))
.respond_with(
ResponseTemplate::new(200)
.set_body_json(make_jwks_json("key1", &n_other, &e_other)),
)
.mount(&mock_server)
.await;
let id_token = sign_test_jwt(
&encoding_key_signer,
"key1",
&issuer,
"cid",
now_unix() + 3600,
);
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"id_token": id_token,
"access_token": "access-123",
"token_type": "Bearer",
"expires_in": 3600
})))
.mount(&mock_server)
.await;
let config = OidcDiscoveryConfig {
issuer,
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: format!("{}/jwks", mock_server.uri()),
};
let provider = DefaultOidcProvider::new(config, "cid", "secret")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url(
"https://sp.example.com/callback",
"state-jwt-test",
&["openid"],
)
.await
.unwrap();
let result = provider
.exchange_code(
"auth-code-123",
"https://sp.example.com/callback",
"state-jwt-test",
)
.await;
assert!(
result.is_err(),
"exchange_code 应在 validate_id_token 失败时返回错误"
);
match result.err() {
Some(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("sso-oidc-id-token-verify"),
"exchange_code 应传递验签失败错误,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn exchange_code_rejects_unregistered_state() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"id_token": "fake-token",
"access_token": "access",
"token_type": "Bearer",
"expires_in": 3600
})))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider
.exchange_code("code", "https://sp.example.com/cb", "unregistered-state")
.await;
assert!(result.is_err(), "未注册的 state 应被拒绝");
match result.err() {
Some(GarrisonError::InvalidParam(msg)) => {
assert!(msg.contains("state"), "错误消息应提及 state,实际: {}", msg);
},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn exchange_code_rejects_mismatched_state() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"id_token": "fake-token",
"access_token": "access",
"token_type": "Bearer",
"expires_in": 3600
})))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url("https://sp.example.com/cb", "abc", &["openid"])
.await
.unwrap();
let result = provider
.exchange_code("code", "https://sp.example.com/cb", "xyz")
.await;
assert!(result.is_err(), "不匹配的 state 应被拒绝");
match result.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn exchange_code_state_is_one_time_use() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let issuer = "https://idp.example.com".to_string();
#[cfg(feature = "protocol-jwt")]
let (id_token, jwks_json) = make_valid_id_token(&issuer, "cid");
#[cfg(not(feature = "protocol-jwt"))]
let id_token: String = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyMTIzIn0.signature".to_string();
#[cfg(feature = "protocol-jwt")]
{
Mock::given(method("GET"))
.and(path("/jwks"))
.respond_with(ResponseTemplate::new(200).set_body_json(jwks_json))
.mount(&mock_server)
.await;
}
let config = OidcDiscoveryConfig {
issuer,
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: format!("{}/jwks", mock_server.uri()),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"id_token": id_token,
"access_token": "access-123",
"token_type": "Bearer",
"expires_in": 3600
})))
.up_to_n_times(1)
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url("https://sp.example.com/cb", "one-time-state", &["openid"])
.await
.unwrap();
let first = provider
.exchange_code("code", "https://sp.example.com/cb", "one-time-state")
.await;
assert!(first.is_ok(), "首次使用 state 应成功");
let second = provider
.exchange_code("code", "https://sp.example.com/cb", "one-time-state")
.await;
assert!(second.is_err(), "重用 state 应被拒绝(one-time use)");
match second.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn exchange_code_rejects_expired_state() {
use std::thread::sleep;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"id_token": "fake-token",
"access_token": "access",
"token_type": "Bearer",
"expires_in": 3600
})))
.mount(&mock_server)
.await;
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()))
.with_state_ttl(Duration::from_secs(1));
provider
.get_authorization_url("https://sp.example.com/cb", "expiring-state", &["openid"])
.await
.unwrap();
sleep(Duration::from_millis(1100));
let result = provider
.exchange_code("code", "https://sp.example.com/cb", "expiring-state")
.await;
assert!(result.is_err(), "过期的 state 应被拒绝");
match result.err() {
Some(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("sso-oidc-state-mismatch-or-expired"),
"错误消息应提及过期,实际: {}",
msg
);
},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn state_registration_allows_multiple_entries() {
let dao = Arc::new(InMemoryDao::new());
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: "https://idp.example.com/token".to_string(),
userinfo_endpoint: "https://idp.example.com/userinfo".to_string(),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(dao.clone());
for state in ["state-1", "state-2", "state-3"] {
provider
.get_authorization_url("https://cb.com/cb", state, &["openid"])
.await
.unwrap();
assert!(
dao.get(&DefaultOidcProvider::state_cache_key(state))
.await
.unwrap()
.is_some(),
"state {} 应已写入 DAO",
state
);
}
}
#[tokio::test]
async fn get_authorization_url_registers_state() {
let dao = Arc::new(InMemoryDao::new());
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: "https://idp.example.com/token".to_string(),
userinfo_endpoint: "https://idp.example.com/userinfo".to_string(),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(dao.clone());
provider
.get_authorization_url("https://cb.com/cb", "first-state", &["openid"])
.await
.unwrap();
assert!(
dao.get(&DefaultOidcProvider::state_cache_key("first-state"))
.await
.unwrap()
.is_some(),
"first-state 应已写入 DAO"
);
provider
.get_authorization_url("https://cb.com/cb", "second-state", &["openid"])
.await
.unwrap();
assert!(
dao.get(&DefaultOidcProvider::state_cache_key("second-state"))
.await
.unwrap()
.is_some(),
"second-state 应已写入 DAO"
);
provider
.get_authorization_url("https://cb.com/cb", "first-state", &["openid"])
.await
.unwrap();
}
#[test]
fn e1_build_safe_http_client_returns_valid_client() {
let client = build_safe_http_client();
assert!(client.is_ok(), "build_safe_http_client 应返回 Ok(Client)");
}
#[test]
fn e1_timeout_constants_match_spec() {
assert_eq!(HTTP_CONNECT_TIMEOUT, Duration::from_secs(10));
assert_eq!(HTTP_READ_TIMEOUT, Duration::from_secs(30));
}
#[test]
fn e1_default_oidc_provider_new_succeeds() {
let config = make_test_config();
let result = DefaultOidcProvider::new(config, "cid", "cs");
assert!(result.is_ok(), "DefaultOidcProvider::new 应返回 Ok");
}
#[test]
fn e2_max_body_bytes_is_4_mib() {
assert_eq!(MAX_BODY_BYTES, 4 * 1024 * 1024);
}
#[tokio::test]
async fn e2_read_limited_bytes_accepts_small_response() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/small"))
.respond_with(ResponseTemplate::new(200).set_body_string("hello"))
.mount(&mock_server)
.await;
let client = build_safe_http_client().unwrap();
let resp = client
.get(format!("{}/small", mock_server.uri()))
.send()
.await
.unwrap();
let bytes = read_limited_bytes(resp).await.unwrap();
assert_eq!(bytes, b"hello");
}
#[tokio::test]
async fn e2_read_limited_bytes_accepts_exact_limit() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let body = "x".repeat(MAX_BODY_BYTES);
Mock::given(method("GET"))
.and(path("/exact"))
.respond_with(ResponseTemplate::new(200).set_body_string(body.clone()))
.mount(&mock_server)
.await;
let client = build_safe_http_client().unwrap();
let resp = client
.get(format!("{}/exact", mock_server.uri()))
.send()
.await
.unwrap();
let bytes = read_limited_bytes(resp).await.unwrap();
assert_eq!(bytes.len(), MAX_BODY_BYTES);
}
#[tokio::test]
async fn e2_read_limited_bytes_rejects_oversized_response() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let oversized_body = "x".repeat(MAX_BODY_BYTES + 1024 * 1024);
Mock::given(method("GET"))
.and(path("/oversized"))
.respond_with(ResponseTemplate::new(200).set_body_string(oversized_body))
.mount(&mock_server)
.await;
let client = build_safe_http_client().unwrap();
let resp = client
.get(format!("{}/oversized", mock_server.uri()))
.send()
.await
.unwrap();
let result = read_limited_bytes(resp).await;
assert!(result.is_err(), "超大响应应返回错误");
match result.err() {
Some(GarrisonError::Network(msg)) => {
assert!(
msg.contains("sso-oidc-body-exceeds-limit")
|| msg.contains("sso-oidc-body-overflow"),
"错误消息应提及上限/E2,实际: {}",
msg
);
},
other => panic!("期望 Network 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn e2_read_limited_text_decodes_utf8() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/text"))
.respond_with(ResponseTemplate::new(200).set_body_string("hello 你好"))
.mount(&mock_server)
.await;
let client = build_safe_http_client().unwrap();
let resp = client
.get(format!("{}/text", mock_server.uri()))
.send()
.await
.unwrap();
let text = read_limited_text(resp).await.unwrap();
assert_eq!(text, "hello 你好");
}
#[tokio::test]
async fn e2_get_user_info_rejects_oversized_response() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let oversized_body = "x".repeat(MAX_BODY_BYTES + 1024 * 1024);
Mock::given(method("GET"))
.and(path("/userinfo"))
.respond_with(ResponseTemplate::new(200).set_body_string(oversized_body))
.mount(&mock_server)
.await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.get_user_info("access-token").await;
assert!(result.is_err(), "超大 userinfo 响应应返回错误");
}
#[tokio::test]
async fn e2_exchange_code_rejects_oversized_token_response() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let mock_server = MockServer::start().await;
let oversized_body = "x".repeat(MAX_BODY_BYTES + 1024 * 1024);
Mock::given(method("POST"))
.and(path("/token"))
.respond_with(ResponseTemplate::new(200).set_body_string(oversized_body))
.mount(&mock_server)
.await;
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/authorize".to_string(),
token_endpoint: format!("{}/token", mock_server.uri()),
userinfo_endpoint: format!("{}/userinfo", mock_server.uri()),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider
.get_authorization_url("https://sp.example.com/cb", "state-e2", &["openid"])
.await
.unwrap();
let result = provider
.exchange_code("code", "https://sp.example.com/cb", "state-e2")
.await;
assert!(result.is_err(), "超大 token 响应应返回错误");
}
#[test]
fn validate_endpoint_scheme_allows_https() {
assert!(
validate_endpoint_scheme("https://idp.example.com/authorize", "test_field").is_ok()
);
assert!(validate_endpoint_scheme("https://127.0.0.1:8443/token", "test_field").is_ok());
assert!(validate_endpoint_scheme("https://localhost/callback", "test_field").is_ok());
}
#[test]
fn validate_endpoint_scheme_allows_localhost_http() {
assert!(validate_endpoint_scheme("http://localhost:8080/token", "f").is_ok());
assert!(validate_endpoint_scheme("http://127.0.0.1/token", "f").is_ok());
assert!(validate_endpoint_scheme("http://localhost/authorize", "f").is_ok());
}
#[test]
fn validate_endpoint_scheme_rejects_public_http() {
assert!(validate_endpoint_scheme("http://idp.example.com/token", "f").is_err());
assert!(validate_endpoint_scheme("http://192.168.1.1/token", "f").is_err());
assert!(validate_endpoint_scheme("http://10.0.0.1:443/token", "f").is_err());
}
#[test]
fn validate_endpoint_scheme_rejects_missing_or_unknown_scheme() {
assert!(validate_endpoint_scheme("idp.example.com/token", "f").is_err());
assert!(validate_endpoint_scheme("ftp://idp.example.com/token", "f").is_err());
assert!(validate_endpoint_scheme("", "f").is_err());
}
#[test]
fn validate_endpoint_scheme_error_contains_field_and_url() {
let err = validate_endpoint_scheme("http://evil.com/token", "token_endpoint").unwrap_err();
match err {
GarrisonError::Config(msg) => {
assert!(msg.contains("token_endpoint"), "应含字段名: {}", msg);
assert!(msg.contains("http://evil.com/token"), "应含 URL: {}", msg);
},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn state_cache_key_format() {
let key = DefaultOidcProvider::state_cache_key("abc123");
assert_eq!(key, "oidc:state:abc123");
}
#[test]
fn state_cache_key_unique_per_state() {
let k1 = DefaultOidcProvider::state_cache_key("state-1");
let k2 = DefaultOidcProvider::state_cache_key("state-2");
assert_ne!(k1, k2);
}
#[cfg(feature = "protocol-jwt")]
#[test]
fn jwks_cache_key_format() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs").unwrap();
let key = provider.jwks_cache_key();
assert_eq!(key, "oidc:jwks:https://idp.example.com");
}
#[tokio::test]
async fn with_state_ttl_state_expires_after_ttl() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()))
.with_state_ttl(Duration::from_millis(50));
provider
.get_authorization_url("https://sp.example.com/cb", "state-ttl-test", &["openid"])
.await
.unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
let result = provider
.exchange_code("code", "https://sp.example.com/cb", "state-ttl-test")
.await;
assert!(result.is_err(), "state 过期后 exchange_code 应失败");
}
#[tokio::test]
async fn register_and_consume_state_roundtrip() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
provider.register_state("test-state-001").await.unwrap();
provider
.validate_and_consume_state("test-state-001")
.await
.unwrap();
let result = provider.validate_and_consume_state("test-state-001").await;
assert!(result.is_err(), "state 应只能消费一次");
}
#[tokio::test]
async fn register_state_without_dao_returns_error() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs").unwrap();
let result = provider.register_state("test-state-002").await;
assert!(result.is_err(), "未注入 DAO 时 register_state 应失败");
}
#[tokio::test]
async fn consume_unregistered_state_returns_error() {
let config = make_test_config();
let provider = DefaultOidcProvider::new(config, "cid", "cs")
.unwrap()
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider
.validate_and_consume_state("never-registered")
.await;
assert!(result.is_err(), "未注册的 state 应返回错误");
}
#[test]
fn sanitize_kid_empty_string() {
assert_eq!(DefaultOidcProvider::sanitize_kid(""), "");
}
#[test]
fn sanitize_kid_truncates_long_input() {
let long_kid = "a".repeat(1000);
let sanitized = DefaultOidcProvider::sanitize_kid(&long_kid);
assert!(sanitized.len() <= 256, "sanitize_kid 应限制长度");
}
#[test]
fn sanitize_kid_filters_control_chars() {
let kid_with_control = "valid\x00\x01\x1Fkid";
let sanitized = DefaultOidcProvider::sanitize_kid(kid_with_control);
assert!(!sanitized.contains('\x00'));
assert!(!sanitized.contains('\x01'));
assert!(sanitized.contains("valid"));
assert!(sanitized.contains("kid"));
}
#[test]
fn new_with_empty_strings_in_config_fails_scheme_validation() {
let config = OidcDiscoveryConfig {
issuer: "".to_string(),
authorization_endpoint: "".to_string(),
token_endpoint: "".to_string(),
userinfo_endpoint: "".to_string(),
jwks_uri: "".to_string(),
};
let result = DefaultOidcProvider::new(config, "cid", "cs");
assert!(result.is_err(), "空端点 URL 应被拒绝");
}
#[test]
fn build_safe_http_client_succeeds() {
let client = build_safe_http_client();
assert!(
client.is_ok(),
"build_safe_http_client 应成功: {:?}",
client.err()
);
}
#[test]
fn validate_endpoint_scheme_https_any_host_ok() {
assert!(validate_endpoint_scheme("https://accounts.google.com/oauth", "test").is_ok());
assert!(validate_endpoint_scheme("https://idp.example.com:8443/oidc", "test").is_ok());
}
#[test]
fn validate_endpoint_scheme_http_localhost_ok() {
assert!(validate_endpoint_scheme("http://localhost/oauth", "test").is_ok());
assert!(validate_endpoint_scheme("http://localhost:8080/oauth", "test").is_ok());
}
#[test]
fn validate_endpoint_scheme_http_127_ok() {
assert!(validate_endpoint_scheme("http://127.0.0.1/oauth", "test").is_ok());
assert!(validate_endpoint_scheme("http://127.0.0.1:3000/oidc", "test").is_ok());
}
#[test]
fn validate_endpoint_scheme_http_public_host_rejected() {
let result = validate_endpoint_scheme("http://idp.example.com/oauth", "test");
assert!(result.is_err(), "http + 公共 host 应被拒绝");
}
#[test]
fn validate_endpoint_scheme_no_scheme_rejected() {
let result = validate_endpoint_scheme("idp.example.com/oauth", "test");
assert!(result.is_err(), "无 scheme 应被拒绝");
}
#[test]
fn validate_endpoint_scheme_ftp_rejected() {
let result = validate_endpoint_scheme("ftp://idp.example.com/oauth", "test");
assert!(result.is_err(), "ftp scheme 应被拒绝");
}
#[test]
fn new_with_valid_https_endpoints_succeeds() {
let config = OidcDiscoveryConfig {
issuer: "https://idp.example.com".to_string(),
authorization_endpoint: "https://idp.example.com/auth".to_string(),
token_endpoint: "https://idp.example.com/token".to_string(),
userinfo_endpoint: "https://idp.example.com/userinfo".to_string(),
jwks_uri: "https://idp.example.com/jwks".to_string(),
};
let result = DefaultOidcProvider::new(config, "client_id", "client_secret");
assert!(
result.is_ok(),
"有效 https 端点应构造成功: {:?}",
result.err()
);
}
#[test]
fn new_with_http_localhost_endpoints_succeeds() {
let config = OidcDiscoveryConfig {
issuer: "http://localhost:8080".to_string(),
authorization_endpoint: "http://localhost:8080/auth".to_string(),
token_endpoint: "http://localhost:8080/token".to_string(),
userinfo_endpoint: "http://localhost:8080/userinfo".to_string(),
jwks_uri: "http://localhost:8080/jwks".to_string(),
};
let result = DefaultOidcProvider::new(config, "cid", "cs");
assert!(
result.is_ok(),
"http+localhost 端点应构造成功: {:?}",
result.err()
);
}
}