#[cfg(any(feature = "rest", feature = "actix"))]
use crate::time::{Duration, Instant};
#[cfg(any(feature = "rest", feature = "actix"))]
use std::sync::RwLock;
#[cfg(any(feature = "rest", feature = "actix"))]
use jsonwebtoken::jwk::JwkSet;
#[cfg(any(feature = "rest", feature = "actix"))]
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
use serde::{Deserialize, Serialize};
use crate::AxiamError;
#[cfg(any(feature = "rest", feature = "actix"))]
use crate::client::OmitBrowserCredentials;
pub const JWKS_PATH: &str = "/oauth2/jwks";
#[cfg(any(feature = "rest", feature = "actix"))]
const JWKS_CACHE_TTL: Duration = Duration::from_secs(300);
#[cfg(any(feature = "rest", feature = "actix"))]
pub(crate) const FAILED_FETCH_MIN_INTERVAL: Duration = Duration::from_secs(60);
#[cfg(any(feature = "rest", feature = "actix"))]
const FORCED_REFETCH_MIN_INTERVAL: Duration = Duration::from_secs(60);
#[cfg(any(feature = "rest", feature = "actix"))]
pub const CLOCK_SKEW_LEEWAY_SECS: u64 = 60;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Claims {
pub sub: String,
pub tenant_id: String,
#[serde(default)]
pub org_id: Option<String>,
pub iss: String,
#[serde(default)]
pub iat: Option<i64>,
pub exp: i64,
#[serde(default)]
pub jti: Option<String>,
#[serde(default)]
pub sid: Option<String>,
#[serde(default)]
pub aud: Option<String>,
#[serde(default)]
pub scope: Option<String>,
#[serde(default)]
pub cnf: Option<CnfClaim>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CnfClaim {
#[serde(rename = "x5t#S256", default, skip_serializing_if = "Option::is_none")]
pub x5t_s256: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jkt: Option<String>,
}
impl CnfClaim {
pub fn certificate_thumbprint(&self) -> Option<&str> {
self.x5t_s256.as_deref()
}
pub fn dpop_thumbprint(&self) -> Option<&str> {
self.jkt.as_deref()
}
pub fn names_nothing_checkable(&self) -> bool {
self.certificate_thumbprint().is_none() && self.dpop_thumbprint().is_none()
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct PresentedProofs<'a> {
pub certificate_thumbprint: Option<&'a str>,
pub dpop_thumbprint: Option<&'a str>,
}
impl Claims {
pub fn verify_certificate_binding(
&self,
presented_thumbprint: Option<&str>,
) -> Result<(), AxiamError> {
let Some(cnf) = self.cnf.as_ref() else {
return Ok(());
};
let auth = |message: &str| AxiamError::Auth {
message: message.to_owned(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
};
let Some(expected) = cnf.certificate_thumbprint() else {
return Err(auth(
"token carries a cnf confirmation naming a method this entry point cannot verify \
(CONTRACT.md §10.1 rule 9 — an unverifiable constraint is not an absent one; \
use verify_token_binding for DPoP)",
));
};
if cnf.dpop_thumbprint().is_some() {
return Err(auth(
"token names both a certificate and a DPoP key; both must hold \
(CONTRACT.md §10.1 rule 9) — use verify_token_binding",
));
}
let Some(presented) = presented_thumbprint else {
return Err(auth(
"token is certificate-bound but no client certificate was presented",
));
};
if constant_time_eq(expected.as_bytes(), presented.as_bytes()) {
Ok(())
} else {
Err(auth(
"token is bound to a different client certificate than the one presented",
))
}
}
pub fn verify_token_binding(&self, proofs: PresentedProofs<'_>) -> Result<(), AxiamError> {
match self.cnf.as_ref() {
None => Ok(()),
Some(cnf) => cnf.verify(proofs),
}
}
}
impl CnfClaim {
pub fn verify(&self, proofs: PresentedProofs<'_>) -> Result<(), AxiamError> {
let cnf = self;
let auth = |message: &str| AxiamError::Auth {
message: message.to_owned(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
};
if cnf.names_nothing_checkable() {
return Err(auth(
"token carries a cnf confirmation naming no method this SDK can verify \
(CONTRACT.md §10.1 rule 9 — an unverifiable constraint is not an absent one)",
));
}
if let Some(expected) = cnf.certificate_thumbprint() {
let Some(presented) = proofs.certificate_thumbprint else {
return Err(auth(
"token is certificate-bound but no client certificate was presented",
));
};
if !constant_time_eq(expected.as_bytes(), presented.as_bytes()) {
return Err(auth(
"token is bound to a different client certificate than the one presented",
));
}
}
if let Some(expected) = cnf.dpop_thumbprint() {
let Some(presented) = proofs.dpop_thumbprint else {
return Err(auth(
"token is DPoP-bound but no verified DPoP proof was presented",
));
};
if !constant_time_eq(expected.as_bytes(), presented.as_bytes()) {
return Err(auth(
"token is bound to a different DPoP key than the one presented",
));
}
}
Ok(())
}
}
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut diff = 0u8;
for (x, y) in a.iter().zip(b.iter()) {
diff |= x ^ y;
}
diff == 0
}
#[cfg(any(feature = "rest", feature = "actix"))]
pub fn certificate_thumbprint_s256(der: &[u8]) -> String {
use base64::Engine as _;
use sha2::{Digest, Sha256};
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(Sha256::digest(der))
}
#[cfg(any(feature = "rest", feature = "actix"))]
struct CachedJwks {
jwks: JwkSet,
fetched_at: Instant,
last_forced_refetch: Option<Instant>,
}
#[cfg(any(feature = "rest", feature = "actix"))]
pub struct JwksVerifier {
http_client: reqwest::Client,
jwks_url: url::Url,
cache: RwLock<Option<CachedJwks>>,
fetch_lock: tokio::sync::Mutex<()>,
limit_failed_fetches: bool,
last_failed_fetch: std::sync::Mutex<Option<Instant>>,
expected_tenant_id: Option<uuid::Uuid>,
expected_issuer: Option<String>,
expected_audience: Option<String>,
revocation_feed: Option<crate::token::revocation::RevocationFeed>,
#[cfg(feature = "actix")]
resource_metadata_url: Option<String>,
#[cfg(feature = "actix")]
mcp_challenges: Option<crate::middleware::mcp::McpChallenges>,
}
#[cfg(any(feature = "rest", feature = "actix"))]
impl JwksVerifier {
pub fn new(http_client: reqwest::Client, base_url: &url::Url) -> Result<Self, AxiamError> {
let jwks_url = base_url.join(JWKS_PATH).map_err(|e| AxiamError::Network {
message: format!("invalid JWKS URL: {e}"),
source: None,
})?;
Ok(Self {
http_client,
jwks_url,
cache: RwLock::new(None),
fetch_lock: tokio::sync::Mutex::new(()),
limit_failed_fetches: false,
last_failed_fetch: std::sync::Mutex::new(None),
expected_tenant_id: None,
expected_issuer: None,
expected_audience: None,
revocation_feed: None,
#[cfg(feature = "actix")]
resource_metadata_url: None,
#[cfg(feature = "actix")]
mcp_challenges: None,
})
}
#[must_use]
pub fn expect_tenant_id(mut self, tenant_id: uuid::Uuid) -> Self {
self.expected_tenant_id = Some(tenant_id);
self
}
#[must_use]
pub fn expect_issuer(mut self, issuer: impl Into<String>) -> Self {
self.expected_issuer = Some(issuer.into());
self
}
#[must_use]
pub fn expect_audience(mut self, audience: impl Into<String>) -> Self {
self.expected_audience = Some(audience.into());
self
}
pub fn expected_audience(&self) -> Option<&str> {
self.expected_audience.as_deref()
}
#[cfg(feature = "actix")]
pub fn with_resource_metadata_url(
mut self,
url: impl Into<String>,
) -> Result<Self, AxiamError> {
let url = url.into();
if self.expected_audience.is_none() {
return Err(crate::middleware::mcp::refuse(
"with_resource_metadata_url",
"resource_metadata_url",
"requires expect_audience(...) to be called first (CONTRACT.md §28.5 rule 2) — announcing a resource identifier obliges this server to check that an inbound token's `aud` is that identifier, and a resource server that announces itself without checking is opened by a token minted for somebody else",
));
}
let challenges = crate::middleware::mcp::McpChallenges::build(&url)?;
self.resource_metadata_url = Some(url);
self.mcp_challenges = Some(challenges);
Ok(self)
}
#[cfg(feature = "actix")]
pub fn resource_metadata_url(&self) -> Option<&str> {
self.resource_metadata_url.as_deref()
}
#[cfg(feature = "actix")]
pub(crate) fn mcp_challenges(&self) -> Option<&crate::middleware::mcp::McpChallenges> {
self.mcp_challenges.as_ref()
}
pub(crate) fn for_jwks_url(http_client: reqwest::Client, jwks_url: url::Url) -> Self {
Self {
http_client,
jwks_url,
cache: RwLock::new(None),
fetch_lock: tokio::sync::Mutex::new(()),
limit_failed_fetches: false,
last_failed_fetch: std::sync::Mutex::new(None),
expected_tenant_id: None,
expected_issuer: None,
expected_audience: None,
revocation_feed: None,
#[cfg(feature = "actix")]
resource_metadata_url: None,
#[cfg(feature = "actix")]
mcp_challenges: None,
}
}
pub(crate) fn limiting_failed_fetches(mut self) -> Self {
self.limit_failed_fetches = true;
self
}
fn failed_fetch_cooldown(&self) -> Result<(), AxiamError> {
if !self.limit_failed_fetches {
return Ok(());
}
let last = *self
.last_failed_fetch
.lock()
.unwrap_or_else(|p| p.into_inner());
match last {
Some(at) if at.elapsed() < FAILED_FETCH_MIN_INTERVAL => Err(AxiamError::network(
"the JWKS fetch failed less than a minute ago; no fetch was made \
(CONTRACT.md §34.2 P6)",
)),
_ => Ok(()),
}
}
pub(crate) async fn verify_id_token_signature<T>(&self, token: &str) -> Result<T, AxiamError>
where
T: serde::de::DeserializeOwned,
{
use crate::error::IdTokenFailureReason;
let header = decode_header(token).map_err(|e| {
AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidAlg,
format!("malformed token: {e}"),
)
})?;
if header.alg != Algorithm::EdDSA {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidAlg,
format!(
"expected alg \"{}\", got {:?}",
crate::oidc::id_token::ID_TOKEN_ALG,
header.alg
),
));
}
let kid = header.kid.as_deref().ok_or_else(|| {
AxiamError::id_token_invalid(
IdTokenFailureReason::UnknownKid,
"token has no kid header",
)
})?;
let jwks = self.get_or_fetch().await?;
let jwk = match find_jwk_by_kid(&jwks, kid) {
Some(jwk) => jwk,
None => {
let refreshed = self.force_refetch_if_allowed().await?;
find_jwk_by_kid(&refreshed, kid).ok_or_else(|| {
AxiamError::id_token_invalid(
IdTokenFailureReason::UnknownKid,
"unknown kid after JWKS refetch",
)
})?
}
};
let decoding_key = DecodingKey::from_jwk(&jwk).map_err(|_| {
AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidSignature,
"unable to build decoding key from JWK",
)
})?;
let mut validation = Validation::new(Algorithm::EdDSA);
validation.required_spec_claims.clear();
validation.validate_exp = false;
validation.validate_nbf = false;
validation.validate_aud = false;
validation.leeway = 0;
let data = decode::<T>(token, &decoding_key, &validation).map_err(|e| {
use jsonwebtoken::errors::ErrorKind;
match e.kind() {
ErrorKind::InvalidSignature => AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidSignature,
"signature invalid",
),
_ => AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidSignature,
format!("claim decode failed: {e}"),
),
}
})?;
Ok(data.claims)
}
pub(crate) async fn key_for_kid(
&self,
kid: &str,
) -> Result<Option<jsonwebtoken::jwk::Jwk>, AxiamError> {
let jwks = self.get_or_fetch().await?;
if let Some(jwk) = find_jwk_by_kid(&jwks, kid) {
return Ok(Some(jwk));
}
let refreshed = self.force_refetch_if_allowed().await?;
Ok(find_jwk_by_kid(&refreshed, kid))
}
pub async fn verify(&self, token: &str) -> Result<Claims, AxiamError> {
self.verify_with_proofs(token, PresentedProofs::default())
.await
}
pub async fn verify_with_proofs(
&self,
token: &str,
proofs: PresentedProofs<'_>,
) -> Result<Claims, AxiamError> {
let claims = self.verify_rules_one_to_eight(token).await?;
claims.verify_token_binding(proofs)?;
Ok(claims)
}
async fn verify_rules_one_to_eight(&self, token: &str) -> Result<Claims, AxiamError> {
let claims = self.verify_claims(token).await?;
self.assert_tenant(&claims)?;
self.assert_not_revoked(&claims).await?;
Ok(claims)
}
#[must_use]
pub fn with_revocation_feed(mut self, feed: crate::token::revocation::RevocationFeed) -> Self {
self.revocation_feed = Some(feed);
self
}
async fn assert_not_revoked(&self, claims: &Claims) -> Result<(), AxiamError> {
let Some(feed) = &self.revocation_feed else {
return Ok(());
};
let Some(sid) = claims.sid.as_deref() else {
return Ok(());
};
if feed.is_revoked(sid).await {
return Err(AxiamError::Auth {
message: "the session behind this access token has been revoked \
(CONTRACT.md §10.4)"
.into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
});
}
Ok(())
}
pub async fn verify_sender_constrained(
&self,
token: &str,
presented_thumbprint: Option<&str>,
) -> Result<Claims, AxiamError> {
let claims = self.verify_rules_one_to_eight(token).await?;
claims.verify_certificate_binding(presented_thumbprint)?;
Ok(claims)
}
pub async fn verify_signature_only_unchecked(&self, token: &str) -> Result<Claims, AxiamError> {
let decoding_key = self.decoding_key_for(token).await?;
let mut validation = Validation::new(Algorithm::EdDSA);
validation.required_spec_claims.clear();
validation.validate_exp = false;
validation.validate_nbf = false;
validation.validate_aud = false;
validation.leeway = 0;
decode_claims(token, &decoding_key, &validation)
}
pub(crate) async fn verify_session_token(&self, token: &str) -> Result<Claims, AxiamError> {
self.verify_claims(token).await
}
async fn verify_claims(&self, token: &str) -> Result<Claims, AxiamError> {
let decoding_key = self.decoding_key_for(token).await?;
let mut validation = Validation::new(Algorithm::EdDSA);
validation.leeway = CLOCK_SKEW_LEEWAY_SECS;
validation.set_required_spec_claims(&["exp"]);
validation.validate_exp = true;
validation.validate_nbf = true;
match self.expected_issuer.as_deref() {
Some(iss) => {
validation.set_issuer(&[iss]);
validation.required_spec_claims.insert("iss".to_string());
}
None => validation.iss = None,
}
match self.expected_audience.as_deref() {
Some(aud) => {
validation.validate_aud = true;
validation.set_audience(&[aud]);
validation.required_spec_claims.insert("aud".to_string());
}
None => {
validation.validate_aud = false;
validation.aud = None;
}
}
decode_claims(token, &decoding_key, &validation)
}
async fn decoding_key_for(&self, token: &str) -> Result<DecodingKey, AxiamError> {
let header = decode_header(token).map_err(|e| AxiamError::Auth {
message: format!("invalid token header: {e}"),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
})?;
if header.alg != Algorithm::EdDSA {
return Err(AxiamError::Auth {
message: "unexpected alg: only EdDSA is accepted".into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
});
}
let jwks = self.get_or_fetch().await?;
let jwk = find_jwk(&jwks, header.kid.as_deref());
let jwk = match jwk {
Some(j) => j,
None => {
let refreshed = self.force_refetch_if_allowed().await?;
find_jwk(&refreshed, header.kid.as_deref()).ok_or_else(|| AxiamError::Auth {
message: "unknown kid after JWKS refetch".into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
})?
}
};
DecodingKey::from_jwk(&jwk).map_err(|_| AxiamError::Auth {
message: "unable to build decoding key from JWK".into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
})
}
fn assert_tenant(&self, claims: &Claims) -> Result<(), AxiamError> {
let expected = self.expected_tenant_id.ok_or_else(|| AxiamError::Auth {
message: "JWKS verifier has no expected tenant configured; refusing to accept a \
token (CONTRACT.md §10.1 rule 4 — call \
JwksVerifier::expect_tenant_id before using it as a route guard)"
.into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
})?;
let actual =
uuid::Uuid::parse_str(claims.tenant_id.trim()).map_err(|_| AxiamError::Auth {
message: "token tenant_id claim is absent or not a UUID".into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
})?;
if actual != expected {
return Err(AxiamError::Auth {
message: "token tenant_id does not match the configured tenant".into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
});
}
Ok(())
}
async fn get_or_fetch(&self) -> Result<JwkSet, AxiamError> {
if let Some(jwks) = self.cached_if_fresh() {
return Ok(jwks);
}
let _guard = self.fetch_lock.lock().await;
if let Some(jwks) = self.cached_if_fresh() {
return Ok(jwks);
}
self.failed_fetch_cooldown()?;
self.fetch_and_cache(false).await
}
fn cached_if_fresh(&self) -> Option<JwkSet> {
let cache = self.cache.read().ok()?;
let entry = cache.as_ref()?;
if entry.fetched_at.elapsed() < JWKS_CACHE_TTL {
Some(entry.jwks.clone())
} else {
None
}
}
async fn force_refetch_if_allowed(&self) -> Result<JwkSet, AxiamError> {
let _guard = self.fetch_lock.lock().await;
self.failed_fetch_cooldown()?;
let allowed = {
let cache = self.cache.read().ok();
match cache.as_ref().and_then(|c| c.as_ref()) {
Some(entry) => match entry.last_forced_refetch {
Some(last) => last.elapsed() >= FORCED_REFETCH_MIN_INTERVAL,
None => true,
},
None => true,
}
};
if allowed {
self.fetch_and_cache(true).await
} else if let Some(jwks) = self
.cache
.read()
.ok()
.and_then(|c| c.as_ref().map(|e| e.jwks.clone()))
{
Ok(jwks)
} else {
self.fetch_and_cache(true).await
}
}
async fn fetch_and_cache(&self, is_forced: bool) -> Result<JwkSet, AxiamError> {
let outcome = self.fetch_and_cache_once(is_forced).await;
if self.limit_failed_fetches {
*self
.last_failed_fetch
.lock()
.unwrap_or_else(|p| p.into_inner()) = outcome.is_err().then(Instant::now);
}
outcome
}
async fn fetch_and_cache_once(&self, is_forced: bool) -> Result<JwkSet, AxiamError> {
let response = self
.http_client
.get(self.jwks_url.clone())
.omit_browser_credentials()
.send()
.await
.map_err(|e| AxiamError::Network {
message: format!("JWKS fetch failed: {e}"),
source: Some(Box::new(e)),
})?;
if !response.status().is_success() {
return Err(AxiamError::from_http_status(
response.status().as_u16(),
"JWKS endpoint returned a non-success status".to_string(),
));
}
let jwks: JwkSet = response.json().await.map_err(|e| AxiamError::Network {
message: format!("JWKS response parse failed: {e}"),
source: Some(Box::new(e)),
})?;
let now = Instant::now();
if let Ok(mut cache) = self.cache.write() {
*cache = Some(CachedJwks {
jwks: jwks.clone(),
fetched_at: now,
last_forced_refetch: if is_forced { Some(now) } else { None },
});
}
Ok(jwks)
}
}
#[cfg(any(feature = "rest", feature = "actix"))]
fn decode_claims(
token: &str,
decoding_key: &DecodingKey,
validation: &Validation,
) -> Result<Claims, AxiamError> {
let data = decode::<Claims>(token, decoding_key, validation).map_err(|e| {
use jsonwebtoken::errors::ErrorKind;
let message = match e.kind() {
ErrorKind::InvalidSignature => "token signature invalid".to_string(),
ErrorKind::ExpiredSignature => "token expired".to_string(),
ErrorKind::ImmatureSignature => "token is not valid yet (nbf is in the future)".into(),
ErrorKind::MissingRequiredClaim(claim) => {
format!("token is missing the required {claim} claim")
}
ErrorKind::InvalidClaimFormat(claim) => {
format!("token {claim} claim is not a number")
}
ErrorKind::InvalidIssuer => "token issuer does not match the expected issuer".into(),
ErrorKind::InvalidAudience => {
"token audience does not match the expected audience".into()
}
_ => format!("token claim validation failed: {e}"),
};
AxiamError::Auth {
message,
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
}
})?;
Ok(data.claims)
}
#[cfg(any(feature = "rest", feature = "actix"))]
fn find_jwk(jwks: &JwkSet, kid: Option<&str>) -> Option<jsonwebtoken::jwk::Jwk> {
match kid {
Some(k) => jwks
.keys
.iter()
.find(|j| j.common.key_id.as_deref() == Some(k))
.cloned(),
None if jwks.keys.len() == 1 => jwks.keys.first().cloned(),
None => None,
}
}
#[cfg(any(feature = "rest", feature = "actix"))]
fn find_jwk_by_kid(jwks: &JwkSet, kid: &str) -> Option<jsonwebtoken::jwk::Jwk> {
jwks.keys
.iter()
.find(|j| j.common.key_id.as_deref() == Some(kid))
.cloned()
}
#[cfg(all(test, any(feature = "rest", feature = "actix")))]
mod tests {
use super::*;
use jsonwebtoken::{EncodingKey, Header, jwk::*};
const TEST_PUBLIC_X: &str = "11qYAYKxCrfVS_7TyWQHOg7hcvPapiMlrwIaaPcHURo";
fn ed25519_test_jwk(kid: Option<&str>) -> Jwk {
Jwk {
common: CommonParameters {
key_algorithm: Some(jsonwebtoken::jwk::KeyAlgorithm::EdDSA),
key_id: kid.map(str::to_string),
..Default::default()
},
algorithm: AlgorithmParameters::OctetKeyPair(OctetKeyPairParameters {
key_type: OctetKeyPairType::OctetKeyPair,
curve: EllipticCurve::Ed25519,
x: TEST_PUBLIC_X.to_string(),
}),
}
}
#[test]
fn rejects_non_eddsa_alg_header() {
let claims = Claims {
sub: "u".into(),
tenant_id: "t".into(),
org_id: None,
iss: "axiam".into(),
iat: None,
exp: 9_999_999_999,
jti: None,
sid: None,
aud: None,
scope: None,
cnf: None,
};
let token = jsonwebtoken::encode(
&Header::new(Algorithm::HS256),
&claims,
&EncodingKey::from_secret(b"irrelevant"),
)
.expect("encode HS256 test token");
let header = decode_header(&token).expect("decode header");
assert_ne!(header.alg, Algorithm::EdDSA);
}
#[test]
fn find_jwk_single_key_fallback_when_kid_absent() {
let jwk = ed25519_test_jwk(Some("test-kid"));
let jwks = JwkSet { keys: vec![jwk] };
let found = find_jwk(&jwks, None);
assert!(
found.is_some(),
"single-key fallback must match on kid=None"
);
}
#[test]
fn find_jwk_no_fallback_with_multiple_keys() {
let jwk1 = ed25519_test_jwk(Some("kid-1"));
let jwk2 = ed25519_test_jwk(Some("kid-2"));
let jwks = JwkSet {
keys: vec![jwk1, jwk2],
};
let found = find_jwk(&jwks, None);
assert!(
found.is_none(),
"must not fall back to a key when multiple keys exist and kid is absent"
);
}
#[test]
fn find_jwk_matches_by_kid() {
let jwk1 = ed25519_test_jwk(Some("kid-1"));
let jwk2 = ed25519_test_jwk(Some("kid-2"));
let jwks = JwkSet {
keys: vec![jwk1, jwk2],
};
let found = find_jwk(&jwks, Some("kid-2"));
assert_eq!(found.unwrap().common.key_id.as_deref(), Some("kid-2"));
}
async fn jwks_endpoint(
statuses: Vec<u16>,
) -> (
wiremock::MockServer,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use std::sync::atomic::{AtomicUsize, Ordering};
let server = wiremock::MockServer::start().await;
let hits = std::sync::Arc::new(AtomicUsize::new(0));
let seen = std::sync::Arc::clone(&hits);
let body = serde_json::json!({ "keys": [ed25519_test_jwk(Some("kid-1"))] });
wiremock::Mock::given(wiremock::matchers::method("GET"))
.respond_with(move |_: &wiremock::Request| {
let n = seen.fetch_add(1, Ordering::SeqCst);
let status = statuses[n.min(statuses.len() - 1)];
wiremock::ResponseTemplate::new(status).set_body_json(body.clone())
})
.mount(&server)
.await;
(server, hits)
}
fn ssf_verifier(server: &wiremock::MockServer) -> JwksVerifier {
let url = url::Url::parse(&format!("{}/oauth2/jwks", server.uri())).unwrap();
JwksVerifier::for_jwks_url(reqwest::Client::new(), url).limiting_failed_fetches()
}
fn backdate(verifier: &JwksVerifier, field: &str, by: Duration) {
let past = Instant::now()
.checked_sub(by)
.expect("a monotonic clock that far back");
match field {
"fetched_at" => verifier.cache.write().unwrap().as_mut().unwrap().fetched_at = past,
_ => *verifier.last_failed_fetch.lock().unwrap() = Some(past),
}
}
#[test]
fn the_key_cache_lifetime_is_within_ten_minutes() {
assert!(JWKS_CACHE_TTL <= Duration::from_secs(600));
}
#[tokio::test]
async fn the_key_cache_expires_and_the_next_lookup_fetches_again() {
use std::sync::atomic::Ordering;
let (server, hits) = jwks_endpoint(vec![200]).await;
let verifier = ssf_verifier(&server);
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert_eq!(hits.load(Ordering::SeqCst), 1, "served from the cache");
backdate(&verifier, "fetched_at", JWKS_CACHE_TTL);
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert_eq!(
hits.load(Ordering::SeqCst),
2,
"an expired cache fetches again"
);
assert!(verifier.key_for_kid("kid-9").await.unwrap().is_none());
assert_eq!(hits.load(Ordering::SeqCst), 3);
}
#[tokio::test]
async fn a_failed_fill_counts_and_the_next_lookup_inside_the_minute_makes_no_fetch() {
use std::sync::atomic::Ordering;
let (server, hits) = jwks_endpoint(vec![503, 200]).await;
let verifier = ssf_verifier(&server);
let e = verifier.key_for_kid("kid-1").await.unwrap_err();
assert!(matches!(e, AxiamError::Network { .. }), "{e}");
let e = verifier.key_for_kid("kid-1").await.unwrap_err();
assert!(matches!(e, AxiamError::Network { .. }), "no verdict: {e}");
assert_eq!(hits.load(Ordering::SeqCst), 1, "no fetch inside the minute");
backdate(&verifier, "last_failed_fetch", FAILED_FETCH_MIN_INTERVAL);
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert_eq!(hits.load(Ordering::SeqCst), 2, "the minute is over");
}
#[tokio::test]
async fn a_failed_expiry_refresh_and_a_failed_refetch_each_count() {
use std::sync::atomic::Ordering;
let (server, hits) = jwks_endpoint(vec![200, 503]).await;
let verifier = ssf_verifier(&server);
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert!(verifier.key_for_kid("kid-9").await.is_err());
assert_eq!(hits.load(Ordering::SeqCst), 2);
let e = verifier.key_for_kid("kid-8").await.unwrap_err();
assert!(matches!(e, AxiamError::Network { .. }), "{e}");
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert_eq!(hits.load(Ordering::SeqCst), 2);
backdate(&verifier, "last_failed_fetch", FAILED_FETCH_MIN_INTERVAL);
backdate(&verifier, "fetched_at", JWKS_CACHE_TTL);
assert!(verifier.key_for_kid("kid-1").await.is_err());
assert_eq!(hits.load(Ordering::SeqCst), 3);
assert!(verifier.key_for_kid("kid-1").await.is_err());
assert_eq!(hits.load(Ordering::SeqCst), 3, "no fetch inside the minute");
}
#[tokio::test]
async fn without_the_limit_a_failed_fetch_is_retried_on_the_next_lookup() {
use std::sync::atomic::Ordering;
let (server, hits) = jwks_endpoint(vec![503, 200]).await;
let url = url::Url::parse(&format!("{}/oauth2/jwks", server.uri())).unwrap();
let verifier = JwksVerifier::for_jwks_url(reqwest::Client::new(), url);
assert!(verifier.key_for_kid("kid-1").await.is_err());
assert!(verifier.key_for_kid("kid-1").await.unwrap().is_some());
assert_eq!(
hits.load(Ordering::SeqCst),
2,
"the §10 / §12 paths are unchanged"
);
}
}