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)))
}
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,
pub email: String,
pub name: String,
pub preferred_username: String,
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_attr(not(feature = "protocol-jwt"), allow(dead_code))]
#[derive(Debug, Clone, Deserialize, Serialize)]
struct Jwk {
kid: String,
n: String,
e: String,
}
#[cfg_attr(not(feature = "protocol-jwt"), allow(dead_code))]
#[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> {
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(test)]
pub fn with_max_state_entries(self, _max: usize) -> Self {
self
}
#[cfg(test)]
pub fn state_store_len(&self) -> usize {
0
}
#[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 = self
.http_client
.get(&self.config.jwks_uri)
.send()
.await
.map_err(|e| 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")]
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: JwksResponse = match cached
.as_deref()
.and_then(|json| serde_json::from_str(json).ok())
{
Some(jwks) => jwks,
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,
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))
})?
},
}
},
};
let jwk = jwks.keys.iter().find(|k| k.kid == kid).cloned();
let jwk = jwk.ok_or_else(|| {
GarrisonError::InvalidToken(format!("sso-oidc-jwks-key-not-found::{}", 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.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?;
}
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::MockDao;
#[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_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 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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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 rand::rngs::OsRng;
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
let mut rng = 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")]
#[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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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(MockDao::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_store_evicts_oldest_when_max_entries_reached() {
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(Arc::new(MockDao::new()))
.with_max_state_entries(2);
provider
.get_authorization_url("https://cb.com/cb", "state-1", &["openid"])
.await
.unwrap();
provider
.get_authorization_url("https://cb.com/cb", "state-2", &["openid"])
.await
.unwrap();
provider
.get_authorization_url("https://cb.com/cb", "state-3", &["openid"])
.await
.unwrap();
assert_eq!(provider.state_store_len(), 0);
}
#[tokio::test]
async fn get_authorization_url_registers_state() {
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(Arc::new(MockDao::new()));
assert_eq!(provider.state_store_len(), 0);
provider
.get_authorization_url("https://cb.com/cb", "first-state", &["openid"])
.await
.unwrap();
assert_eq!(provider.state_store_len(), 0);
provider
.get_authorization_url("https://cb.com/cb", "second-state", &["openid"])
.await
.unwrap();
assert_eq!(provider.state_store_len(), 0);
provider
.get_authorization_url("https://cb.com/cb", "first-state", &["openid"])
.await
.unwrap();
assert_eq!(provider.state_store_len(), 0);
}
#[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(MockDao::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(MockDao::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 响应应返回错误");
}
}