use std::collections::HashMap;
use std::fmt;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use jsonwebtoken::{decode, decode_header, Algorithm, DecodingKey, Validation};
use serde::Deserialize;
use url::Url;
use crate::auth::AuthContext;
use crate::oidc::config::{AudienceClaim, OidcConfig};
use crate::oidc::fetch::JwksFetcher;
use crate::oidc::jwks;
use crate::tenant::types::{TenantError, TenantId};
use crate::verified_user::VerifiedUser;
#[derive(Debug)]
pub enum OidcError {
Discovery(String),
JwksUnavailable(String),
MissingKeyId,
UnknownKeyId(String),
UnsupportedAlgorithm(String),
InvalidSignature,
Expired,
WrongIssuer,
WrongAudience,
NotYetValid,
IssuedInFuture {
iat: i64,
now: i64,
},
MalformedToken(String),
InvalidTenantClaim(TenantError),
}
impl fmt::Display for OidcError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Discovery(m) => write!(f, "OIDC discovery failed: {m}"),
Self::JwksUnavailable(m) => write!(f, "JWKS unavailable and no cached keys: {m}"),
Self::MissingKeyId => f.write_str("token header carries no kid"),
Self::UnknownKeyId(kid) => {
write!(f, "kid {kid:?} not in JWKS after one refresh")
}
Self::UnsupportedAlgorithm(alg) => {
write!(f, "unsupported token algorithm {alg} (RS256-only)")
}
Self::InvalidSignature => f.write_str("token signature invalid"),
Self::Expired => f.write_str("token expired (exp in the past, zero leeway)"),
Self::NotYetValid => f.write_str("token not yet valid (nbf in the future, zero leeway)"),
Self::WrongIssuer => f.write_str("token iss does not match configured issuer"),
Self::WrongAudience => f.write_str("token aud does not match configured audience"),
Self::IssuedInFuture { iat, now } => {
write!(f, "token iat {iat} is in the future (now {now})")
}
Self::MalformedToken(m) => write!(f, "malformed token: {m}"),
Self::InvalidTenantClaim(e) => write!(f, "invalid org_id claim: {e}"),
}
}
}
impl std::error::Error for OidcError {}
#[derive(Debug, Deserialize)]
struct OidcClaims {
sub: String,
iss: String,
exp: i64,
iat: i64,
#[serde(default)]
org_id: Option<String>,
#[serde(default)]
sid: Option<String>,
#[serde(default)]
jti: Option<String>,
#[serde(default)]
roles: Option<Vec<String>>,
#[serde(default)]
username: Option<String>,
#[serde(flatten)]
extra: serde_json::Map<String, serde_json::Value>,
}
#[derive(Debug, Deserialize)]
struct DiscoveryDoc {
issuer: String,
jwks_uri: String,
}
const KID_MISS_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
struct CacheState {
jwks_uri: Option<Url>,
keys: HashMap<String, DecodingKey>,
fetched_at: Option<Instant>,
ttl: Duration,
degraded: bool,
generation: u64,
last_error: Option<String>,
kid_miss_at: Option<Instant>,
}
#[derive(Clone, Copy, PartialEq)]
enum RefreshOutcome {
Fresh,
Degraded,
}
pub struct OidcValidator {
config: OidcConfig,
fetcher: Arc<dyn JwksFetcher>,
state: Mutex<CacheState>,
refresh_lock: tokio::sync::Mutex<()>,
}
impl OidcValidator {
#[cfg(feature = "oidc-reqwest")]
pub fn new(config: OidcConfig) -> Self {
Self::with_fetcher(config, Arc::new(crate::oidc::fetch::ReqwestJwksFetcher::new()))
}
pub fn with_fetcher(config: OidcConfig, fetcher: Arc<dyn JwksFetcher>) -> Self {
Self {
config,
fetcher,
state: Mutex::new(CacheState {
jwks_uri: None,
keys: HashMap::new(),
fetched_at: None,
ttl: Duration::from_secs(0),
degraded: false,
generation: 0,
last_error: None,
kid_miss_at: None,
}),
refresh_lock: tokio::sync::Mutex::new(()),
}
}
#[doc(hidden)]
pub fn expire_cache(&self) {
let mut st = self.state.lock().unwrap();
st.fetched_at = None;
st.kid_miss_at = None;
}
pub fn config(&self) -> &OidcConfig {
&self.config
}
pub async fn validate_token(&self, token: &str) -> Result<VerifiedToken, OidcError> {
let header =
decode_header(token).map_err(|e| OidcError::MalformedToken(e.to_string()))?;
if header.alg != Algorithm::RS256 {
return Err(OidcError::UnsupportedAlgorithm(format!("{:?}", header.alg)));
}
let kid = header.kid.ok_or(OidcError::MissingKeyId)?;
let (needs_refresh, generation) = {
let st = self.state.lock().unwrap();
(st.fetched_at.is_none_or(|at| at.elapsed() >= st.ttl), st.generation)
};
let mut refresh_attempted = false;
if needs_refresh {
self.refresh(generation, false).await?;
refresh_attempted = true;
}
let key = match self.lookup(&kid) {
Some(k) => k,
None => {
if !refresh_attempted {
let generation = self.state.lock().unwrap().generation;
self.refresh(generation, true).await?;
}
self.lookup(&kid).ok_or(OidcError::UnknownKeyId(kid.clone()))?
}
};
let mut validation = Validation::new(Algorithm::RS256);
validation.leeway = 0;
validation.validate_nbf = true;
let issuer_str = self.config.issuer().as_url().as_str();
validation.set_issuer(&[issuer_str, issuer_str.trim_end_matches('/')]);
match self.config.audience_claim() {
AudienceClaim::Aud => {
validation.set_audience(&[self.config.audience().as_str()]);
validation.set_required_spec_claims(&["sub", "exp", "iss", "aud"]);
}
AudienceClaim::ClientId => {
validation.validate_aud = false;
validation.set_required_spec_claims(&["sub", "exp", "iss"]);
}
}
let data = decode::<OidcClaims>(token, &key, &validation).map_err(map_jwt_error)?;
let claims = data.claims;
if self.config.audience_claim() == AudienceClaim::ClientId
&& claims.extra.get("client_id").and_then(serde_json::Value::as_str) != Some(self.config.audience().as_str())
{
return Err(OidcError::WrongAudience);
}
let now = chrono::Utc::now().timestamp();
if claims.iat > now {
return Err(OidcError::IssuedInFuture { iat: claims.iat, now });
}
let tenant = claims
.org_id
.as_deref()
.map(TenantId::try_new)
.transpose()
.map_err(OidcError::InvalidTenantClaim)?;
let session_id = claims
.sid
.clone()
.or_else(|| claims.jti.clone())
.unwrap_or_else(|| token.rsplit('.').next().unwrap_or_default().to_string());
let user = VerifiedUser::new_sealed(
claims.sub,
claims.iss,
claims.iat,
claims.exp,
tenant,
);
Ok(VerifiedToken {
user,
roles: claims.roles.unwrap_or_default(),
username: claims.username,
session_id,
extra: claims.extra,
})
}
fn lookup(&self, kid: &str) -> Option<DecodingKey> {
self.state.lock().unwrap().keys.get(kid).cloned()
}
async fn refresh(&self, seen: u64, kid_miss: bool) -> Result<RefreshOutcome, OidcError> {
let _flight = self.refresh_lock.lock().await;
{
let mut st = self.state.lock().unwrap();
if st.generation != seen {
return Self::settled(&st);
}
if kid_miss {
if st.kid_miss_at.is_some_and(|at| at.elapsed() < KID_MISS_REFRESH_INTERVAL) {
tracing::debug!(
target: "plexus::auth",
issuer = %self.config.issuer(),
"unknown kid: JWKS refreshed for a kid-miss within the last minute; not refetching"
);
return Self::settled(&st);
}
st.kid_miss_at = Some(Instant::now());
}
}
let fetched = self.try_fetch_keys().await;
let mut st = self.state.lock().unwrap();
st.generation += 1;
match fetched {
Ok((keys, ttl, jwks_uri)) => {
st.last_error = None;
if st.degraded {
tracing::info!(
target: "plexus::auth",
issuer = %self.config.issuer(),
"auth_provider_restored: JWKS refresh succeeded; leaving degraded mode"
);
}
st.keys = keys;
st.ttl = ttl;
st.fetched_at = Some(Instant::now());
st.jwks_uri = Some(jwks_uri);
st.degraded = false;
Ok(RefreshOutcome::Fresh)
}
Err(err) => {
st.last_error = Some(err.to_string());
if st.keys.is_empty() {
return Err(err);
}
if !st.degraded {
st.degraded = true;
tracing::warn!(
target: "plexus::auth",
issuer = %self.config.issuer(),
error = %err,
"auth_provider_degraded: IdP unreachable; serving cached JWKS \
(future-exp tokens only — exp has no grace)"
);
}
Ok(RefreshOutcome::Degraded)
}
}
}
fn settled(st: &CacheState) -> Result<RefreshOutcome, OidcError> {
if st.keys.is_empty() {
if let Some(e) = &st.last_error {
return Err(OidcError::JwksUnavailable(e.clone()));
}
}
Ok(if st.degraded { RefreshOutcome::Degraded } else { RefreshOutcome::Fresh })
}
async fn try_fetch_keys(
&self,
) -> Result<(HashMap<String, DecodingKey>, Duration, Url), OidcError> {
let cached_uri = self.state.lock().unwrap().jwks_uri.clone();
let jwks_uri = match cached_uri {
Some(u) => u,
None => self.discover().await?,
};
let doc = self
.fetcher
.fetch(&jwks_uri)
.await
.map_err(|e| OidcError::JwksUnavailable(e.to_string()))?;
let keys = jwks::parse_jwks(&doc.body).map_err(OidcError::JwksUnavailable)?;
let ttl = jwks::ttl_from_cache_control(doc.cache_control.as_deref());
Ok((keys, ttl, jwks_uri))
}
async fn discover(&self) -> Result<Url, OidcError> {
let url = self.config.discovery_url();
let doc = self
.fetcher
.fetch(&url)
.await
.map_err(|e| OidcError::Discovery(e.to_string()))?;
let parsed: DiscoveryDoc = serde_json::from_str(&doc.body)
.map_err(|e| OidcError::Discovery(format!("discovery document parse error: {e}")))?;
let configured = self.config.issuer().as_url().as_str().trim_end_matches('/');
if parsed.issuer.trim_end_matches('/') != configured {
return Err(OidcError::Discovery(format!(
"discovery document issuer {:?} does not match configured issuer {:?}",
parsed.issuer, configured
)));
}
let jwks_uri = Url::parse(&parsed.jwks_uri)
.map_err(|e| OidcError::Discovery(format!("invalid jwks_uri: {e}")))?;
trusted_jwks_uri(self.config.issuer().as_url(), &jwks_uri)?;
Ok(jwks_uri)
}
}
fn trusted_jwks_uri(issuer: &Url, jwks_uri: &Url) -> Result<(), OidcError> {
let same_origin = jwks_uri.scheme() == issuer.scheme()
&& jwks_uri.host_str() == issuer.host_str()
&& jwks_uri.port_or_known_default() == issuer.port_or_known_default();
if jwks_uri.scheme() == "https" || same_origin {
Ok(())
} else {
Err(OidcError::Discovery(format!(
"jwks_uri {jwks_uri} is neither https nor on the issuer's origin"
)))
}
}
fn map_jwt_error(e: jsonwebtoken::errors::Error) -> OidcError {
use jsonwebtoken::errors::ErrorKind;
match e.kind() {
ErrorKind::ExpiredSignature => OidcError::Expired,
ErrorKind::ImmatureSignature => OidcError::NotYetValid,
ErrorKind::InvalidIssuer => OidcError::WrongIssuer,
ErrorKind::InvalidAudience => OidcError::WrongAudience,
ErrorKind::InvalidSignature => OidcError::InvalidSignature,
_ => OidcError::MalformedToken(e.to_string()),
}
}
#[derive(Debug, Clone)]
pub struct VerifiedToken {
user: VerifiedUser,
roles: Vec<String>,
username: Option<String>,
session_id: String,
extra: serde_json::Map<String, serde_json::Value>,
}
impl VerifiedToken {
pub fn user(&self) -> &VerifiedUser {
&self.user
}
pub fn tenant_id(&self) -> Option<&TenantId> {
self.user.tenant_id()
}
pub fn roles(&self) -> &[String] {
&self.roles
}
pub fn username(&self) -> Option<&str> {
self.username.as_deref()
}
pub fn claim(&self, name: &str) -> Option<&serde_json::Value> {
self.extra.get(name)
}
pub fn session_id(&self) -> &str {
&self.session_id
}
pub fn into_auth_context(self) -> AuthContext {
let mut metadata = serde_json::Map::new();
if let Some(t) = self.user.tenant_id() {
let v = serde_json::Value::String(t.as_str().to_string());
metadata.insert("org_id".into(), v.clone());
metadata.insert("tenant_id".into(), v);
}
metadata.insert(
"iss".into(),
serde_json::Value::String(self.user.issuer().to_string()),
);
if let Some(u) = &self.username {
metadata.insert("username".into(), serde_json::Value::String(u.clone()));
}
metadata.insert(
"auth_method".into(),
serde_json::Value::String("oidc".into()),
);
metadata.insert("expires_at".into(), serde_json::Value::from(self.user.expires_at()));
AuthContext::new(
self.user.user_id().to_string(),
self.session_id,
self.roles,
serde_json::Value::Object(metadata),
)
}
}