use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::loc;
use crate::protocol::oauth2::client::{build_safe_http_client, read_limited_bytes};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
const JWKS_CACHE_TTL: Duration = Duration::from_secs(600);
#[derive(Debug, Clone)]
pub struct KeycloakConfig {
pub base_url: String,
pub client_id: String,
pub client_secret: Option<String>,
pub redirect_uri: String,
pub expected_iss: String,
}
impl KeycloakConfig {
pub fn discovery_url(&self) -> String {
format!("{}/.well-known/openid-configuration", self.base_url)
}
pub fn jwks_url(&self) -> String {
format!("{}/protocol/openid-connect/certs", self.base_url)
}
pub fn authorize_url(&self) -> String {
format!("{}/protocol/openid-connect/auth", self.base_url)
}
pub fn token_url(&self) -> String {
format!("{}/protocol/openid-connect/token", self.base_url)
}
pub fn userinfo_url(&self) -> String {
format!("{}/protocol/openid-connect/userinfo", self.base_url)
}
}
#[derive(Debug, Clone, Deserialize, PartialEq)]
pub struct OidcDiscoveryMetadata {
pub issuer: String,
pub authorization_endpoint: String,
pub token_endpoint: String,
pub jwks_uri: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Jwk {
pub kid: String,
pub n: String,
pub e: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct JwksResponse {
pub keys: Vec<Jwk>,
}
const JWKS_CACHE_KEY_PREFIX: &str = "keycloak:jwks:";
#[derive(Debug, Clone, Deserialize, PartialEq)]
pub struct RealmAccess {
pub roles: Vec<String>,
}
#[derive(Debug, Clone, Deserialize, PartialEq)]
pub struct KeycloakClaims {
pub sub: String,
pub exp: i64,
#[serde(default)]
pub aud: serde_json::Value,
#[serde(default)]
pub iss: Option<String>,
pub preferred_username: Option<String>,
pub email: Option<String>,
pub realm_access: RealmAccess,
pub resource_access: HashMap<String, RealmAccess>,
#[serde(default)]
pub tenant_id: Option<i64>,
}
#[derive(Debug, Clone, Deserialize, PartialEq)]
pub struct KeycloakTokenSet {
pub access_token: String,
pub refresh_token: String,
pub id_token: String,
pub expires_in: u64,
}
pub struct KeycloakProvider {
config: KeycloakConfig,
http: reqwest::Client,
dao: Option<Arc<dyn GarrisonDao>>,
pkce_verifier: Option<String>,
}
impl KeycloakProvider {
pub fn new(config: KeycloakConfig) -> GarrisonResult<Self> {
let http = build_safe_http_client().map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-http-client-build-failed",
format!("Failed to build HTTP client: {}", e),
("detail", &e.to_string())
))
})?;
Ok(Self {
config,
http,
dao: None,
pkce_verifier: None,
})
}
pub fn with_dao(mut self, dao: Arc<dyn GarrisonDao>) -> Self {
self.dao = Some(dao);
self
}
pub fn with_pkce(mut self, verifier: &str) -> GarrisonResult<Self> {
crate::protocol::oauth2::OAuth2Client::generate_pkce_challenge(verifier)?;
self.pkce_verifier = Some(verifier.to_string());
Ok(self)
}
pub async fn discover(&self) -> GarrisonResult<OidcDiscoveryMetadata> {
let url = self.config.discovery_url();
let resp = self.http.get(&url).send().await.map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-discovery-request-failed",
format!("discovery request failed: {}", e),
("detail", &e.to_string())
))
})?;
if !resp.status().is_success() {
return Err(GarrisonError::Network(loc!(
"keycloak-discovery-status-not-2xx",
format!("discovery response status not 2xx: {}", resp.status()),
("detail", &resp.status().to_string())
)));
}
let bytes = read_limited_bytes(resp).await.map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-discovery-body-read-failed",
format!("discovery body read failed: {}", e),
("detail", &e.to_string())
))
})?;
serde_json::from_slice::<OidcDiscoveryMetadata>(&bytes).map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-discovery-response-parse-failed",
format!("discovery response parse failed: {}", e),
("detail", &e.to_string())
))
})
}
fn jwks_cache_key(&self) -> String {
format!("{}{}", JWKS_CACHE_KEY_PREFIX, self.config.expected_iss)
}
async fn fetch_jwks(&self) -> GarrisonResult<()> {
let dao = self.dao.as_ref().ok_or_else(|| {
GarrisonError::Config(loc!(
"keycloak-dao-not-injected",
"KeycloakProvider DAO not injected, cannot cache JWKS (call with_dao to inject GarrisonDao)"
.to_string()
))
})?;
let url = self.config.jwks_url();
let resp = self.http.get(&url).send().await.map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-jwks-request-failed",
format!("JWKS request failed: {}", e),
("detail", &e.to_string())
))
})?;
if !resp.status().is_success() {
return Err(GarrisonError::Network(loc!(
"keycloak-jwks-status-not-2xx",
format!("JWKS response status not 2xx: {}", resp.status()),
("detail", &resp.status().to_string())
)));
}
let bytes = read_limited_bytes(resp).await.map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-jwks-body-read-failed",
format!("JWKS body read failed: {}", e),
("detail", &e.to_string())
))
})?;
let jwks: JwksResponse = serde_json::from_slice(&bytes).map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-jwks-response-parse-failed",
format!("JWKS response parse failed: {}", e),
("detail", &e.to_string())
))
})?;
let json = serde_json::to_string(&jwks).map_err(|e| {
GarrisonError::Internal(loc!(
"keycloak-jwks-serialize-failed",
format!("JWKS serialize failed: {}", e),
("detail", &e.to_string())
))
})?;
let cache_key = self.jwks_cache_key();
dao.set(&cache_key, &json, JWKS_CACHE_TTL.as_secs()).await?;
Ok(())
}
fn sanitize_kid(kid: &str) -> String {
let filtered: String = kid.chars().filter(|c| !c.is_control()).collect();
filtered.chars().take(128).collect()
}
pub async fn verify_id_token(&self, id_token: &str) -> GarrisonResult<KeycloakClaims> {
use jsonwebtoken::{decode, Algorithm, DecodingKey, Validation};
let dao = self.dao.as_ref().ok_or_else(|| {
GarrisonError::Config(loc!(
"keycloak-dao-not-injected",
"KeycloakProvider DAO not injected, cannot cache JWKS (call with_dao to inject GarrisonDao)"
.to_string()
))
})?;
let header = jsonwebtoken::decode_header(id_token).map_err(|e| {
GarrisonError::InvalidToken(loc!(
"keycloak-id-token-header-parse-failed",
format!("id_token header parse failed: {}", e),
("detail", &e.to_string())
))
})?;
let kid = header.kid.as_deref().ok_or_else(|| {
GarrisonError::InvalidToken(loc!(
"keycloak-id-token-header-missing-kid",
"id_token header missing kid field".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 => {
self.fetch_jwks().await?;
let json = dao.get(&cache_key).await?.ok_or_else(|| {
GarrisonError::Internal(loc!(
"keycloak-jwks-cache-miss-after-fetch",
"cache miss after fetch_jwks (DAO write anomaly)".to_string()
))
})?;
(
serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(loc!(
"keycloak-jwks-deserialize-failed",
format!("JWKS deserialize failed: {}", e),
("detail", &e.to_string())
))
})?,
true,
)
},
};
let jwk = match jwks.keys.iter().find(|k| k.kid == kid).cloned() {
Some(jwk) => jwk,
None if !fresh => {
self.fetch_jwks().await?;
let json = dao.get(&cache_key).await?.ok_or_else(|| {
GarrisonError::Internal(loc!(
"keycloak-jwks-cache-miss-after-fetch",
"cache miss after fetch_jwks (DAO write anomaly)".to_string()
))
})?;
let refreshed: JwksResponse = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Internal(loc!(
"keycloak-jwks-deserialize-failed",
format!("JWKS deserialize failed: {}", e),
("detail", &e.to_string())
))
})?;
refreshed
.keys
.iter()
.find(|k| k.kid == kid)
.cloned()
.ok_or_else(|| {
GarrisonError::InvalidToken(loc!(
"keycloak-jwks-key-not-found",
format!("JWKS key not found for kid={}", Self::sanitize_kid(kid)),
("kid", &Self::sanitize_kid(kid))
))
})?
},
None => {
return Err(GarrisonError::InvalidToken(loc!(
"keycloak-jwks-key-not-found",
format!("JWKS key not found for kid={}", kid),
("kid", kid)
)))
},
};
let decoding_key = DecodingKey::from_rsa_components(&jwk.n, &jwk.e).map_err(|e| {
GarrisonError::InvalidToken(loc!(
"keycloak-rsa-public-key-build-failed",
format!("Failed to build RSA public key: {}", e),
("detail", &e.to_string())
))
})?;
let mut validation = Validation::new(Algorithm::RS256);
validation.validate_exp = true;
validation.validate_nbf = true;
validation.validate_aud = true;
validation.set_audience(&[&self.config.client_id]);
validation.set_issuer(&[&self.config.expected_iss]);
validation.leeway = 0;
let token_data =
decode::<KeycloakClaims>(id_token, &decoding_key, &validation).map_err(|e| {
let msg = e.to_string();
if msg.contains("ExpiredSignature") {
GarrisonError::InvalidToken(loc!(
"keycloak-token-expired",
"token expired".to_string()
))
} else if msg.contains("ImmatureSignature") {
GarrisonError::InvalidToken(loc!(
"keycloak-token-immature",
"token not yet valid (nbf)".to_string()
))
} else if msg.contains("InvalidAudience") {
GarrisonError::InvalidToken(loc!(
"keycloak-token-invalid-audience",
"invalid audience".to_string()
))
} else if msg.contains("InvalidIssuer") {
GarrisonError::InvalidToken(loc!(
"keycloak-token-invalid-issuer",
"invalid issuer".to_string()
))
} else {
GarrisonError::InvalidToken(loc!(
"keycloak-id-token-verify-failed",
format!("id_token verify failed: {}", e),
("detail", &e.to_string())
))
}
})?;
Ok(token_data.claims)
}
pub async fn exchange_code(&self, code: &str) -> GarrisonResult<KeycloakTokenSet> {
if code.is_empty() {
return Err(GarrisonError::InvalidParam(loc!(
"keycloak-code-empty",
"code cannot be empty".to_string()
)));
}
let mut form: Vec<(&str, &str)> = vec![
("grant_type", "authorization_code"),
("code", code),
("client_id", &self.config.client_id),
("redirect_uri", &self.config.redirect_uri),
];
match (&self.pkce_verifier, &self.config.client_secret) {
(Some(verifier), _) => form.push(("code_verifier", verifier.as_str())),
(None, Some(secret)) => form.push(("client_secret", secret.as_str())),
(None, None) => {
return Err(GarrisonError::Config(loc!(
"keycloak-public-client-requires-pkce",
"public client (client_secret=None) must call with_pkce to set PKCE verifier"
.to_string()
)));
},
}
let url = self.config.token_url();
let resp = self.http.post(&url).form(&form).send().await.map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-exchange-code-request-failed",
format!("exchange_code request failed: {}", e),
("detail", &e.to_string())
))
})?;
if !resp.status().is_success() {
return Err(GarrisonError::Network(loc!(
"keycloak-exchange-code-status-not-2xx",
format!("exchange_code response status not 2xx: {}", resp.status()),
("detail", &resp.status().to_string())
)));
}
let bytes = read_limited_bytes(resp).await.map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-exchange-code-body-read-failed",
format!("exchange_code body read failed: {}", e),
("detail", &e.to_string())
))
})?;
serde_json::from_slice::<KeycloakTokenSet>(&bytes).map_err(|e| {
GarrisonError::Network(loc!(
"keycloak-exchange-code-response-parse-failed",
format!("exchange_code response parse failed: {}", e),
("detail", &e.to_string())
))
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
#[test]
fn keycloak_config_constructs_with_base_url_client_id() {
let config = KeycloakConfig {
base_url: "https://kc.example.com:8443/realms/myrealm".into(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: "https://kc.example.com:8443/realms/myrealm".into(),
};
assert_eq!(
config.base_url,
"https://kc.example.com:8443/realms/myrealm"
);
assert_eq!(config.client_id, "garrison-rp");
assert!(config.client_secret.is_none());
assert_eq!(config.redirect_uri, "https://app.example.com/cb");
assert_eq!(
config.discovery_url(),
"https://kc.example.com:8443/realms/myrealm/.well-known/openid-configuration"
);
}
#[tokio::test]
async fn keycloak_provider_discover_fetches_metadata_from_well_known() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
let issuer = server.uri();
let authorization_endpoint = format!("{}/protocol/openid-connect/auth", server.uri());
let token_endpoint = format!("{}/protocol/openid-connect/token", server.uri());
let jwks_uri = format!("{}/protocol/openid-connect/certs", server.uri());
Mock::given(method("GET"))
.and(path("/.well-known/openid-configuration"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"issuer": issuer,
"authorization_endpoint": authorization_endpoint,
"token_endpoint": token_endpoint,
"jwks_uri": jwks_uri,
"response_types_supported": ["code"],
"subject_types_supported": ["public"],
"id_token_signing_alg_values_supported": ["RS256"],
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let provider = KeycloakProvider::new(config).expect("KeycloakProvider::new 应成功");
let metadata = provider.discover().await.expect("discover 应返回 Ok");
assert_eq!(metadata.issuer, issuer);
assert_eq!(metadata.authorization_endpoint, authorization_endpoint);
assert_eq!(metadata.token_endpoint, token_endpoint);
assert_eq!(metadata.jwks_uri, jwks_uri);
}
#[tokio::test]
async fn keycloak_provider_verify_id_token_validates_signature_and_claims() {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
use serde::Serialize;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
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_bytes = public_key.n().to_bytes_be();
let e_bytes = public_key.e().to_bytes_be();
let n_b64 = URL_SAFE_NO_PAD.encode(n_bytes);
let e_b64 = URL_SAFE_NO_PAD.encode(e_bytes);
let der = private_key.to_pkcs1_der().expect("转 PKCS#1 DER 应成功");
let encoding_key = EncodingKey::from_rsa_der(der.as_bytes());
let server = MockServer::start().await;
let issuer = server.uri();
#[derive(Serialize)]
struct KeycloakTestClaims {
sub: String,
exp: i64,
aud: serde_json::Value, iss: String, preferred_username: String,
email: String,
realm_access: serde_json::Value,
resource_access: serde_json::Value,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some("key1".to_string());
let exp = (std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时间应早于 UNIX_EPOCH")
.as_secs() as i64)
+ 3600;
let claims = KeycloakTestClaims {
sub: "user-123".into(),
exp,
aud: serde_json::Value::String("garrison-rp".to_string()), iss: issuer.clone(), preferred_username: "alice".into(),
email: "alice@example.com".into(),
realm_access: serde_json::json!({ "roles": ["user", "admin"] }),
resource_access: serde_json::json!({
"account": { "roles": ["manage-account"] }
}),
};
let id_token = encode(&header, &claims, &encoding_key).expect("签发 JWT 应成功");
Mock::given(method("GET"))
.and(path("/protocol/openid-connect/certs"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"keys": [{
"kty": "RSA",
"kid": "key1",
"use": "sig",
"alg": "RS256",
"n": n_b64,
"e": e_b64,
}]
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: issuer,
};
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_dao(Arc::new(InMemoryDao::new()));
let keycloak_claims = provider
.verify_id_token(&id_token)
.await
.expect("verify_id_token 应返回 Ok");
assert_eq!(keycloak_claims.sub, "user-123");
assert_eq!(keycloak_claims.realm_access.roles, vec!["user", "admin"]);
}
#[tokio::test]
async fn keycloak_provider_exchange_code_returns_token_set() {
use wiremock::matchers::{body_string, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/protocol/openid-connect/token"))
.and(body_string(
"grant_type=authorization_code&code=auth_code_123&client_id=garrison-rp&redirect_uri=https%3A%2F%2Fapp.example.com%2Fcb&client_secret=secret123",
))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "at-456",
"refresh_token": "rt-789",
"id_token": "it-012",
"expires_in": 3600,
"token_type": "Bearer",
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: Some("secret123".into()),
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let provider = KeycloakProvider::new(config).expect("KeycloakProvider::new 应成功");
let token_set = provider
.exchange_code("auth_code_123")
.await
.expect("exchange_code 应返回 Ok");
assert_eq!(token_set.access_token, "at-456");
assert_eq!(token_set.refresh_token, "rt-789");
assert_eq!(token_set.id_token, "it-012");
assert_eq!(token_set.expires_in, 3600);
}
#[tokio::test]
async fn keycloak_provider_rejects_expired_id_token() {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
use serde::Serialize;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
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());
let server = MockServer::start().await;
let issuer = server.uri();
#[derive(Serialize)]
struct ExpiredTestClaims {
sub: String,
exp: i64,
aud: serde_json::Value, iss: String, realm_access: serde_json::Value,
resource_access: serde_json::Value,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some("key1".to_string());
let exp = (std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时间应早于 UNIX_EPOCH")
.as_secs() as i64)
- 3600;
let claims = ExpiredTestClaims {
sub: "user-123".into(),
exp,
aud: serde_json::Value::String("garrison-rp".to_string()), iss: issuer.clone(), realm_access: serde_json::json!({ "roles": ["user"] }),
resource_access: serde_json::json!({
"account": { "roles": ["manage-account"] }
}),
};
let id_token = encode(&header, &claims, &encoding_key).expect("签发 JWT 应成功");
Mock::given(method("GET"))
.and(path("/protocol/openid-connect/certs"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"keys": [{
"kty": "RSA",
"kid": "key1",
"n": n_b64,
"e": e_b64,
}]
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: issuer,
};
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.verify_id_token(&id_token).await;
match result {
Err(crate::error::GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("expired") || msg.contains("过期"),
"过期 token 应返回过期相关消息,实际: {}",
msg
);
},
other => panic!("过期 token 应返回 InvalidToken 过期消息,实际: {:?}", other),
}
}
#[tokio::test]
async fn keycloak_verify_id_token_rejects_wrong_audience() {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
use serde::Serialize;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
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());
let server = MockServer::start().await;
let issuer = server.uri();
#[derive(Serialize)]
struct WrongAudTestClaims {
sub: String,
exp: i64,
aud: serde_json::Value,
iss: String,
realm_access: serde_json::Value,
resource_access: serde_json::Value,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some("key1".to_string());
let exp = (std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时间应早于 UNIX_EPOCH")
.as_secs() as i64)
+ 3600;
let claims = WrongAudTestClaims {
sub: "user-123".into(),
exp,
aud: serde_json::Value::String("wrong-audience".to_string()), iss: issuer.clone(),
realm_access: serde_json::json!({ "roles": ["user"] }),
resource_access: serde_json::json!({
"account": { "roles": ["manage-account"] }
}),
};
let id_token = encode(&header, &claims, &encoding_key).expect("签发 JWT 应成功");
Mock::given(method("GET"))
.and(path("/protocol/openid-connect/certs"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"keys": [{
"kty": "RSA",
"kid": "key1",
"n": n_b64,
"e": e_b64,
}]
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: issuer,
};
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.verify_id_token(&id_token).await;
match result {
Err(crate::error::GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("audience"),
"aud 不匹配应返回 audience 相关消息,实际: {}",
msg
);
},
other => panic!("aud 不匹配应返回 InvalidToken,实际: {:?}", other),
}
}
#[tokio::test]
async fn keycloak_verify_id_token_rejects_wrong_issuer() {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
use serde::Serialize;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
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());
let server = MockServer::start().await;
let issuer = server.uri();
#[derive(Serialize)]
struct WrongIssTestClaims {
sub: String,
exp: i64,
aud: serde_json::Value,
iss: String,
realm_access: serde_json::Value,
resource_access: serde_json::Value,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some("key1".to_string());
let exp = (std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时间应早于 UNIX_EPOCH")
.as_secs() as i64)
+ 3600;
let claims = WrongIssTestClaims {
sub: "user-123".into(),
exp,
aud: serde_json::Value::String("garrison-rp".to_string()), iss: "https://wrong-issuer.example.com".to_string(), realm_access: serde_json::json!({ "roles": ["user"] }),
resource_access: serde_json::json!({
"account": { "roles": ["manage-account"] }
}),
};
let id_token = encode(&header, &claims, &encoding_key).expect("签发 JWT 应成功");
Mock::given(method("GET"))
.and(path("/protocol/openid-connect/certs"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"keys": [{
"kty": "RSA",
"kid": "key1",
"n": n_b64,
"e": e_b64,
}]
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: issuer,
};
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_dao(Arc::new(InMemoryDao::new()));
let result = provider.verify_id_token(&id_token).await;
match result {
Err(crate::error::GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("issuer"),
"iss 不匹配应返回 issuer 相关消息,实际: {}",
msg
);
},
other => panic!("iss 不匹配应返回 InvalidToken,实际: {:?}", other),
}
}
#[tokio::test]
async fn keycloak_verify_id_token_accepts_aud_array() {
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use rsa::pkcs1::EncodeRsaPrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{RsaPrivateKey, RsaPublicKey};
use serde::Serialize;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
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());
let server = MockServer::start().await;
let issuer = server.uri();
#[derive(Serialize)]
struct AudArrayTestClaims {
sub: String,
exp: i64,
aud: serde_json::Value,
iss: String,
realm_access: serde_json::Value,
resource_access: serde_json::Value,
}
let mut header = Header::new(Algorithm::RS256);
header.kid = Some("key1".to_string());
let exp = (std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时间应早于 UNIX_EPOCH")
.as_secs() as i64)
+ 3600;
let claims = AudArrayTestClaims {
sub: "user-123".into(),
exp,
aud: serde_json::json!(["garrison-rp", "account"]),
iss: issuer.clone(),
realm_access: serde_json::json!({ "roles": ["user", "admin"] }),
resource_access: serde_json::json!({
"account": { "roles": ["manage-account"] }
}),
};
let id_token = encode(&header, &claims, &encoding_key).expect("签发 JWT 应成功");
Mock::given(method("GET"))
.and(path("/protocol/openid-connect/certs"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"keys": [{
"kty": "RSA",
"kid": "key1",
"n": n_b64,
"e": e_b64,
}]
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: issuer,
};
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_dao(Arc::new(InMemoryDao::new()));
let keycloak_claims = provider
.verify_id_token(&id_token)
.await
.expect("aud 为数组含 client_id 时应返回 Ok");
assert_eq!(keycloak_claims.sub, "user-123");
assert_eq!(keycloak_claims.realm_access.roles, vec!["user", "admin"]);
}
#[tokio::test]
async fn keycloak_pkce_flow_succeeds_with_valid_verifier() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/protocol/openid-connect/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "at-pkce",
"refresh_token": "rt-pkce",
"id_token": "it-pkce",
"expires_in": 3600,
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_pkce(verifier)
.expect("with_pkce 应成功");
let token_set = provider
.exchange_code("auth_code_123")
.await
.expect("exchange_code 应返回 Ok");
assert_eq!(token_set.access_token, "at-pkce");
assert_eq!(token_set.refresh_token, "rt-pkce");
assert_eq!(token_set.id_token, "it-pkce");
assert_eq!(token_set.expires_in, 3600);
let received = server.received_requests().await.expect("应收到请求");
assert_eq!(received.len(), 1, "应只收到 1 个请求");
let body = std::str::from_utf8(&received[0].body).expect("body 应为 UTF-8");
assert!(
body.contains("code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
"请求体应包含 code_verifier 字段,实际: {}",
body
);
assert!(
!body.contains("client_secret="),
"PKCE 流程不应包含 client_secret 字段,实际: {}",
body
);
}
#[test]
fn keycloak_pkce_flow_fails_on_invalid_verifier() {
let config = KeycloakConfig {
base_url: "https://kc.example.com:8443/realms/myrealm".into(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: "https://kc.example.com:8443/realms/myrealm".into(),
};
let provider = KeycloakProvider::new(config).expect("KeycloakProvider::new 应成功");
let result = provider.with_pkce("short");
assert!(result.is_err(), "无效 verifier 应返回错误");
match result.err() {
Some(crate::error::GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("43")
|| msg.contains("长度")
|| msg.contains("length")
|| msg.contains("pkce-length-invalid"),
"错误消息应说明长度约束,实际: {}",
msg
);
},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn keycloak_without_client_secret_and_without_pkce_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/protocol/openid-connect/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "should-not-reach",
"refresh_token": "x",
"id_token": "x",
"expires_in": 3600,
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: None,
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let provider = KeycloakProvider::new(config).expect("KeycloakProvider::new 应成功");
let result = provider.exchange_code("auth_code_123").await;
assert!(result.is_err(), "无 client_secret 且无 PKCE 应返回错误");
match result.err() {
Some(crate::error::GarrisonError::Config(msg)) => {
assert!(
msg.contains("with_pkce") || msg.contains("PKCE"),
"错误消息应提示调用 with_pkce,实际: {}",
msg
);
},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
let received = server.received_requests().await.expect("应能获取请求记录");
assert_eq!(
received.len(),
0,
"无鉴权方式时不应发送 HTTP 请求,实际收到 {} 个请求",
received.len()
);
}
#[tokio::test]
async fn keycloak_with_pkce_overrides_client_secret_auth() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/protocol/openid-connect/token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "at-override",
"refresh_token": "rt-override",
"id_token": "it-override",
"expires_in": 1800,
})))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: Some("secret123".into()),
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
let provider = KeycloakProvider::new(config)
.expect("KeycloakProvider::new 应成功")
.with_pkce(verifier)
.expect("with_pkce 应成功");
let token_set = provider
.exchange_code("auth_code_456")
.await
.expect("exchange_code 应返回 Ok");
assert_eq!(token_set.access_token, "at-override");
let received = server.received_requests().await.expect("应收到请求");
assert_eq!(received.len(), 1, "应只收到 1 个请求");
let body = std::str::from_utf8(&received[0].body).expect("body 应为 UTF-8");
assert!(
body.contains("code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
"PKCE 优先:请求体应包含 code_verifier 字段,实际: {}",
body
);
assert!(
!body.contains("client_secret="),
"PKCE 优先:请求体不应包含 client_secret 字段,实际: {}",
body
);
}
#[test]
fn loc_i18n_keycloak_token_expired_zh() {
use crate::i18n::{set_locale, GarrisonLocale};
let _guard = set_locale(GarrisonLocale::Zh);
let msg = crate::loc!("keycloak-token-expired", "token expired".to_string());
assert_eq!(msg, "token 已过期");
}
#[test]
fn loc_i18n_keycloak_token_expired_en() {
use crate::i18n::{set_locale, GarrisonLocale};
let _guard = set_locale(GarrisonLocale::En);
let msg = crate::loc!("keycloak-token-expired", "token expired".to_string());
assert_eq!(msg, "Token expired");
}
#[test]
fn loc_i18n_keycloak_jwks_key_not_found_with_kid_zh() {
use crate::i18n::{set_locale, GarrisonLocale};
let _guard = set_locale(GarrisonLocale::Zh);
let msg = crate::loc!(
"keycloak-jwks-key-not-found",
"JWKS key not found for kid=abc123".to_string(),
("kid", "abc123")
);
assert_eq!(msg, "JWKS 中未找到 kid=abc123 的公钥");
}
#[test]
fn sanitize_kid_filters_control_chars_and_limits_len() {
assert_eq!(KeycloakProvider::sanitize_kid("abc123"), "abc123");
assert_eq!(KeycloakProvider::sanitize_kid("bad\x01kid\x7f"), "badkid");
let long = "a".repeat(200);
assert_eq!(KeycloakProvider::sanitize_kid(&long).len(), 128);
}
#[test]
fn e1_keycloak_provider_new_uses_safe_http_client() {
let config = KeycloakConfig {
base_url: "https://kc.example.com:8443/realms/myrealm".into(),
client_id: "garrison-rp".into(),
client_secret: Some("secret".into()),
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: "https://kc.example.com:8443/realms/myrealm".into(),
};
let provider = KeycloakProvider::new(config);
assert!(provider.is_ok(), "KeycloakProvider::new 必须成功");
}
#[tokio::test]
async fn e2_keycloak_discover_rejects_oversized_response() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
let huge_value = "x".repeat(5 * 1024 * 1024);
let huge_json = format!(
r#"{{"issuer":"https://kc.example.com","authorization_endpoint":"{}","token_endpoint":"{}","jwks_uri":"{}","userinfo_endpoint":"{}"}}"#,
huge_value, huge_value, huge_value, huge_value
);
Mock::given(method("GET"))
.and(path("/.well-known/openid-configuration"))
.respond_with(ResponseTemplate::new(200).set_body_string(huge_json))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: Some("secret".into()),
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let provider = KeycloakProvider::new(config).expect("provider 构建成功");
let result = provider.discover().await;
assert!(result.is_err(), "超大 discovery JSON 必须被拒绝");
}
#[tokio::test]
async fn e2_keycloak_exchange_code_rejects_oversized_response() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
let huge_value = "x".repeat(5 * 1024 * 1024);
let huge_json = format!(r#"{{"access_token":"{}"}}"#, huge_value);
Mock::given(method("POST"))
.and(path("/protocol/openid-connect/token"))
.respond_with(ResponseTemplate::new(200).set_body_string(huge_json))
.mount(&server)
.await;
let config = KeycloakConfig {
base_url: server.uri(),
client_id: "garrison-rp".into(),
client_secret: Some("secret".into()),
redirect_uri: "https://app.example.com/cb".into(),
expected_iss: server.uri(),
};
let provider = KeycloakProvider::new(config).expect("provider 构建成功");
let result = provider.exchange_code("code123").await;
assert!(result.is_err(), "超大 token JSON 必须被拒绝");
}
}