use std::collections::HashMap;
use std::sync::{Mutex, RwLock};
use std::time::{Duration, Instant};
use jsonwebtoken::jwk::{AlgorithmParameters, Jwk};
use jsonwebtoken::DecodingKey;
use tracing::{info, warn};
use crate::http_auth::JwtAlgorithmFamily;
#[derive(serde::Deserialize)]
struct RawJwkSet {
keys: Vec<serde_json::Value>,
}
const DEFAULT_REFRESH_SECS: u64 = 300;
const MIN_REFRESH_SECS: u64 = 30;
const DEFAULT_MIN_REFETCH_SECS: u64 = 30;
const MIN_REFETCH_FLOOR_SECS: u64 = 1;
const DEFAULT_TIMEOUT_MS: u64 = 3_000;
const MAX_JWKS_BYTES: usize = 1024 * 1024;
#[derive(Debug, Clone, Copy)]
pub(crate) struct JwksSettings {
pub(crate) refresh_every: Duration,
pub(crate) min_refetch: Duration,
pub(crate) timeout: Duration,
}
impl JwksSettings {
pub(crate) fn from_env() -> Self {
let secs = |name: &str, default: u64| {
std::env::var(name)
.ok()
.and_then(|v| v.trim().parse::<u64>().ok())
.unwrap_or(default)
};
Self {
refresh_every: Duration::from_secs(
secs("KRAB_OIDC_JWKS_REFRESH_SECS", DEFAULT_REFRESH_SECS).max(MIN_REFRESH_SECS),
),
min_refetch: Duration::from_secs(
secs("KRAB_OIDC_JWKS_MIN_REFETCH_SECS", DEFAULT_MIN_REFETCH_SECS)
.max(MIN_REFETCH_FLOOR_SECS),
),
timeout: Duration::from_millis(
secs("KRAB_OIDC_JWKS_TIMEOUT_MS", DEFAULT_TIMEOUT_MS).max(100),
),
}
}
}
pub(crate) fn url_allowed(url: &str, environment: &crate::config::Environment) -> bool {
let url = url.trim();
url.starts_with("https://")
|| (matches!(environment, crate::config::Environment::Dev) && url.starts_with("http://"))
}
#[derive(Default)]
struct JwksKeys {
keys: HashMap<String, Vec<(JwtAlgorithmFamily, DecodingKey)>>,
loaded: bool,
}
pub(crate) struct JwksSource {
url: String,
client: reqwest::Client,
settings: JwksSettings,
keys: RwLock<JwksKeys>,
last_attempt: Mutex<Option<Instant>>,
last_success: Mutex<Option<Instant>>,
fetch_lock: tokio::sync::Mutex<()>,
}
impl JwksSource {
pub(crate) fn new(url: String, settings: JwksSettings) -> anyhow::Result<Self> {
let client = reqwest::Client::builder()
.timeout(settings.timeout)
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|error| anyhow::anyhow!("JWKS HTTP client could not be built: {error}"))?;
Ok(Self {
url,
client,
settings,
keys: RwLock::new(JwksKeys::default()),
last_attempt: Mutex::new(None),
last_success: Mutex::new(None),
fetch_lock: tokio::sync::Mutex::new(()),
})
}
pub(crate) fn url(&self) -> &str {
&self.url
}
pub(crate) fn settings(&self) -> JwksSettings {
self.settings
}
pub(crate) fn loaded(&self) -> bool {
self.read_keys().loaded
}
pub(crate) fn has_kid(&self, kid: &str) -> bool {
self.read_keys().keys.contains_key(kid)
}
pub(crate) fn kids(&self) -> Vec<String> {
let mut kids: Vec<String> = self.read_keys().keys.keys().cloned().collect();
kids.sort();
kids
}
pub(crate) fn key(&self, kid: &str, family: JwtAlgorithmFamily) -> Option<DecodingKey> {
self.read_keys()
.keys
.get(kid)?
.iter()
.find(|(f, _)| *f == family)
.map(|(_, key)| key.clone())
}
pub(crate) fn may_refetch(&self) -> bool {
let last = self.last_attempt.lock().unwrap_or_else(|e| e.into_inner());
last.is_none_or(|at| at.elapsed() >= self.settings.min_refetch)
}
fn fetch_needed(&self, kid: Option<&str>) -> bool {
(!self.loaded() || kid.is_some_and(|kid| !self.has_kid(kid))) && self.may_refetch()
}
fn periodic_refresh_due(&self) -> bool {
let due = self
.last_success
.lock()
.unwrap_or_else(|e| e.into_inner())
.is_some_and(|at| at.elapsed() >= self.settings.refresh_every);
due && self.may_refetch()
}
pub(crate) async fn refresh_if_needed(
&self,
kid: Option<&str>,
periodic: bool,
) -> Option<anyhow::Result<usize>> {
let needed = || self.fetch_needed(kid) || (periodic && self.periodic_refresh_due());
if !needed() {
return None;
}
let _single_flight = self.fetch_lock.lock().await;
if !needed() {
return None;
}
Some(self.fetch_locked().await)
}
pub(crate) async fn refresh(&self) -> anyhow::Result<usize> {
let _single_flight = self.fetch_lock.lock().await;
self.fetch_locked().await
}
async fn fetch_locked(&self) -> anyhow::Result<usize> {
self.stamp_attempt();
let result = self.fetch_and_replace().await;
self.stamp_attempt();
result
}
fn stamp_attempt(&self) {
*self.last_attempt.lock().unwrap_or_else(|e| e.into_inner()) = Some(Instant::now());
}
async fn fetch_and_replace(&self) -> anyhow::Result<usize> {
let mut response = self.client.get(&self.url).send().await?;
let status = response.status();
anyhow::ensure!(
status.is_success(),
"JWKS at {} answered {status}{}",
self.url,
if status.is_redirection() {
" (redirects are not followed)"
} else {
""
}
);
if let Some(length) = response.content_length() {
anyhow::ensure!(
length <= MAX_JWKS_BYTES as u64,
"JWKS at {} is {length} bytes, over the {MAX_JWKS_BYTES}-byte limit",
self.url
);
}
let mut body = Vec::new();
while let Some(chunk) = response.chunk().await? {
anyhow::ensure!(
body.len() + chunk.len() <= MAX_JWKS_BYTES,
"JWKS at {} exceeds the {MAX_JWKS_BYTES}-byte limit",
self.url
);
body.extend_from_slice(&chunk);
}
let set: RawJwkSet = serde_json::from_slice(&body)?;
let mut keys: HashMap<String, Vec<(JwtAlgorithmFamily, DecodingKey)>> = HashMap::new();
for (index, raw) in set.keys.into_iter().enumerate() {
let Some(jwk) = self.parse_key(index, raw) else {
continue;
};
let jwk = &jwk;
let family = match &jwk.algorithm {
AlgorithmParameters::RSA(_) => JwtAlgorithmFamily::Rsa,
AlgorithmParameters::EllipticCurve(_) => JwtAlgorithmFamily::Ec,
AlgorithmParameters::OctetKeyPair(_) => JwtAlgorithmFamily::Ed,
AlgorithmParameters::OctetKey(_) => {
warn!(url = %self.url, "jwks_symmetric_key_ignored");
continue;
}
};
let key = match DecodingKey::from_jwk(jwk) {
Ok(key) => key,
Err(error) => {
warn!(url = %self.url, %error, "jwks_key_unusable_skipped");
continue;
}
};
let kid = jwk
.common
.key_id
.clone()
.unwrap_or_else(|| format!("#{index}"));
keys.entry(kid).or_default().push((family, key));
}
anyhow::ensure!(!keys.is_empty(), "JWKS at {} held no usable keys", self.url);
let count = keys.len();
*self.keys.write().unwrap_or_else(|e| e.into_inner()) = JwksKeys { keys, loaded: true };
*self.last_success.lock().unwrap_or_else(|e| e.into_inner()) = Some(Instant::now());
info!(url = %self.url, keys = count, "jwks_refreshed");
Ok(count)
}
fn parse_key(&self, index: usize, raw: serde_json::Value) -> Option<Jwk> {
let kid = raw
.get("kid")
.and_then(serde_json::Value::as_str)
.unwrap_or("")
.to_string();
if raw.get("use").and_then(serde_json::Value::as_str) == Some("enc") {
info!(url = %self.url, kid = %kid, index, "jwks_encryption_key_skipped");
return None;
}
match serde_json::from_value::<Jwk>(raw) {
Ok(jwk) => Some(jwk),
Err(error) => {
warn!(url = %self.url, kid = %kid, index, %error, "jwks_key_unsupported_skipped");
None
}
}
}
fn read_keys(&self) -> std::sync::RwLockReadGuard<'_, JwksKeys> {
self.keys.read().unwrap_or_else(|e| e.into_inner())
}
}
pub(crate) fn parse_not_after(raw: &str) -> Option<i64> {
let raw = raw.trim();
if let Ok(secs) = raw.parse::<i64>() {
return Some(secs);
}
let (date, rest) = raw.split_once(['T', 't', ' '])?;
let mut date_parts = date.splitn(3, '-');
let year: i64 = date_parts.next()?.parse().ok()?;
let month: u32 = date_parts.next()?.parse().ok()?;
let day: u32 = date_parts.next()?.parse().ok()?;
let (time, offset_secs) = if let Some(time) = rest.strip_suffix(['Z', 'z']) {
(time, 0)
} else {
let split = rest.rfind(['+', '-'])?;
let (time, offset) = rest.split_at(split);
let sign = if offset.starts_with('-') { -1 } else { 1 };
let (oh, om) = offset[1..].split_once(':')?;
let offset: i64 = oh.parse::<i64>().ok()? * 3600 + om.parse::<i64>().ok()? * 60;
(time, sign * offset)
};
let time = time.split('.').next()?;
let mut time_parts = time.splitn(3, ':');
let hour: i64 = time_parts.next()?.parse().ok()?;
let minute: i64 = time_parts.next()?.parse().ok()?;
let second: i64 = time_parts.next()?.parse().ok()?;
if !(1..=12).contains(&month)
|| day < 1
|| day > days_in_month(year, month)
|| hour > 23
|| minute > 59
|| second > 60
{
return None;
}
Some(
days_from_civil(year, month, day) * 86_400 + hour * 3600 + minute * 60 + second
- offset_secs,
)
}
fn days_in_month(year: i64, month: u32) -> u32 {
match month {
2 if (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 => 29,
2 => 28,
4 | 6 | 9 | 11 => 30,
_ => 31,
}
}
fn days_from_civil(year: i64, month: u32, day: u32) -> i64 {
let year = if month <= 2 { year - 1 } else { year };
let era = year.div_euclid(400);
let yoe = year - era * 400;
let month = i64::from(month);
let mp = (month + 9) % 12;
let doy = (153 * mp + 2) / 5 + i64::from(day) - 1;
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
era * 146_097 + doe - 719_468
}
#[cfg(test)]
mod tests {
use super::{parse_not_after, url_allowed, JwksSettings, JwksSource};
use crate::config::Environment;
use crate::http_auth::JwtAlgorithmFamily;
use serde_json::json;
use std::time::Duration;
#[test]
fn not_after_accepts_rfc3339_and_unix_seconds() {
assert_eq!(parse_not_after("0"), Some(0));
assert_eq!(parse_not_after("1790000000"), Some(1_790_000_000));
assert_eq!(parse_not_after("1970-01-01T00:00:00Z"), Some(0));
assert_eq!(parse_not_after("2026-10-01T00:00:00Z"), Some(1_790_812_800));
assert_eq!(
parse_not_after("2026-10-01T02:00:00+02:00"),
Some(1_790_812_800)
);
assert_eq!(
parse_not_after("2026-09-30T19:00:00.250-05:00"),
Some(1_790_812_800)
);
assert_eq!(parse_not_after("2024-02-29T12:00:00Z"), Some(1_709_208_000));
for bad in [
"",
"soon",
"2026-13-01T00:00:00Z",
"2026-10-01",
"2026-10-01T25:00:00Z",
] {
assert_eq!(parse_not_after(bad), None, "{bad}");
}
}
#[test]
fn not_after_rejects_impossible_dates() {
for bad in [
"2026-02-29T00:00:00Z",
"2026-02-30T00:00:00Z",
"2026-04-31T00:00:00Z",
"2026-06-31T00:00:00Z",
"2026-09-31T00:00:00Z",
"2026-11-31T00:00:00Z",
"1900-02-29T00:00:00Z",
"2026-01-00T00:00:00Z",
] {
assert_eq!(parse_not_after(bad), None, "{bad}");
}
for good in [
"2024-02-29T00:00:00Z",
"2000-02-29T00:00:00Z",
"2026-01-31T00:00:00Z",
"2026-12-31T23:59:59Z",
] {
assert!(parse_not_after(good).is_some(), "{good}");
}
}
const ED_X: &str = "tQCGXC6DpH3eQ7mQpTmUwz_UrjPnQ-X2ztczWt5Uyis";
fn settings() -> JwksSettings {
JwksSettings {
refresh_every: Duration::from_secs(300),
min_refetch: Duration::from_secs(30),
timeout: Duration::from_secs(2),
}
}
async fn serve(app: axum::Router) -> String {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let _ = axum::serve(listener, app).await;
});
format!("http://{addr}")
}
async fn serve_json(document: serde_json::Value) -> String {
let app = axum::Router::new().route(
"/jwks",
axum::routing::get(move || {
let document = document.clone();
async move { axum::Json(document) }
}),
);
format!("{}/jwks", serve(app).await)
}
#[tokio::test]
async fn unsupported_keys_do_not_break_the_set() {
let url = serve_json(json!({"keys": [
{"kty": "EC", "crv": "P-521", "alg": "ES512", "kid": "es512",
"x": "AQ", "y": "AQ", "use": "sig"},
{"kty": "EC", "crv": "secp256k1", "alg": "ES256K", "kid": "k1",
"x": "AQ", "y": "AQ"},
{"kty": "OKP", "crv": "X25519", "kid": "x25519", "x": ED_X, "use": "enc"},
{"kty": "RSA", "alg": "RSA-OAEP-384", "kid": "oaep", "n": "AQ", "e": "AQAB",
"use": "enc"},
{"kty": "OKP", "crv": "Ed25519", "kid": "enc-ed", "x": ED_X, "use": "enc"},
{"kty": "OKP", "crv": "Ed25519", "kid": "good", "x": ED_X, "use": "sig",
"alg": "EdDSA"}
]}))
.await;
let source = JwksSource::new(url, settings()).unwrap();
assert_eq!(source.refresh().await.unwrap(), 1);
assert!(source.has_kid("good"));
assert!(
!source.has_kid("enc-ed"),
"an encryption key must not verify signatures"
);
assert!(source.key("good", JwtAlgorithmFamily::Ed).is_some());
}
#[tokio::test]
async fn redirects_are_not_followed() {
let target_hits = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let hits = target_hits.clone();
let app = axum::Router::new()
.route(
"/jwks",
axum::routing::get(|| async { axum::response::Redirect::temporary("/real") }),
)
.route(
"/real",
axum::routing::get(move || {
let hits = hits.clone();
async move {
hits.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
axum::Json(json!({"keys": [
{"kty": "OKP", "crv": "Ed25519", "kid": "k", "x": ED_X}
]}))
}
}),
);
let url = format!("{}/jwks", serve(app).await);
let source = JwksSource::new(url, settings()).unwrap();
let error = source.refresh().await.unwrap_err().to_string();
assert!(error.contains("redirects are not followed"), "{error}");
assert!(!source.loaded());
assert_eq!(target_hits.load(std::sync::atomic::Ordering::SeqCst), 0);
}
#[tokio::test]
async fn oversized_documents_are_rejected() {
let padding = "x".repeat(super::MAX_JWKS_BYTES);
let document = json!({
"keys": [{"kty": "OKP", "crv": "Ed25519", "kid": "k", "x": ED_X}],
"padding": padding,
})
.to_string();
let declared = document.clone();
let app = axum::Router::new().route(
"/declared",
axum::routing::get(move || {
let body = declared.clone();
async move { body }
}),
);
let declared_url = format!("{}/declared", serve(app).await);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let undeclared_url = format!("http://{}/jwks", listener.local_addr().unwrap());
tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
if let Ok((mut socket, _)) = listener.accept().await {
let mut request = [0u8; 4096];
let _ = socket.read(&mut request).await;
let head = "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\nconnection: close\r\n\r\n";
let _ = socket.write_all(head.as_bytes()).await;
let _ = socket.write_all(document.as_bytes()).await;
let _ = socket.shutdown().await;
}
});
for url in [declared_url, undeclared_url] {
let source = JwksSource::new(url.clone(), settings()).unwrap();
let error = source.refresh().await.unwrap_err().to_string();
assert!(error.contains("limit"), "{url}: {error}");
assert!(!source.loaded(), "{url}");
}
}
#[test]
#[serial_test::serial]
fn min_refetch_has_a_floor() {
std::env::set_var("KRAB_OIDC_JWKS_MIN_REFETCH_SECS", "0");
let floored = JwksSettings::from_env().min_refetch;
std::env::set_var("KRAB_OIDC_JWKS_MIN_REFETCH_SECS", "45");
let explicit = JwksSettings::from_env().min_refetch;
std::env::remove_var("KRAB_OIDC_JWKS_MIN_REFETCH_SECS");
assert_eq!(floored, Duration::from_secs(1));
assert_eq!(explicit, Duration::from_secs(45));
}
#[test]
fn plain_http_is_dev_only() {
assert!(url_allowed(
"https://idp.example.com/jwks",
&Environment::Prod
));
assert!(!url_allowed(
"http://idp.example.com/jwks",
&Environment::Prod
));
assert!(!url_allowed(
"http://idp.example.com/jwks",
&Environment::Staging
));
assert!(url_allowed("http://127.0.0.1:8080/jwks", &Environment::Dev));
assert!(!url_allowed("ftp://x", &Environment::Dev));
}
}