mod claims;
mod jwks;
mod verify;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
pub use claims::VerifiedClaims;
pub use jwks::{MAX_JWKS_BYTES, MAX_KEYS};
pub use verify::{MAX_TOKEN_BYTES, VerifyError};
use crate::RuntimeError;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct VerifierConfig {
pub issuer: String,
pub jwks_url: String,
pub audiences: Vec<String>,
pub any_audience: bool,
pub required_claims: Vec<(String, String)>,
pub leeway: Duration,
pub min_refresh_interval: Duration,
pub cache_ttl: Duration,
}
impl VerifierConfig {
#[must_use]
pub fn new(issuer: impl Into<String>, jwks_url: impl Into<String>) -> Self {
Self {
issuer: issuer.into(),
jwks_url: jwks_url.into(),
audiences: Vec::new(),
any_audience: false,
required_claims: Vec::new(),
leeway: Duration::from_secs(60),
min_refresh_interval: Duration::from_secs(60),
cache_ttl: Duration::from_secs(60 * 60),
}
}
#[must_use]
pub fn with_audiences(mut self, audiences: Vec<String>) -> Self {
self.audiences = audiences;
self
}
#[must_use]
pub fn without_audience_check(mut self) -> Self {
self.any_audience = true;
self
}
#[must_use]
pub fn with_required_claim(
mut self,
claim: impl Into<String>,
value: impl Into<String>,
) -> Self {
self.required_claims.push((claim.into(), value.into()));
self
}
#[must_use]
pub fn with_min_refresh_interval(mut self, interval: Duration) -> Self {
self.min_refresh_interval = interval;
self
}
#[must_use]
pub fn with_cache_ttl(mut self, ttl: Duration) -> Self {
self.cache_ttl = ttl;
self
}
}
#[derive(Debug)]
pub struct Verifier {
config: VerifierConfig,
keys: jwks::KeyStore,
}
impl Verifier {
pub async fn load(http: reqwest::Client, config: VerifierConfig) -> Result<Self, RuntimeError> {
let keys = jwks::KeyStore::new(
http,
config.jwks_url.clone(),
config.min_refresh_interval,
config.cache_ttl,
);
keys.refresh_now().await?;
Ok(Self { config, keys })
}
#[must_use]
pub fn deferred(http: reqwest::Client, config: VerifierConfig) -> Self {
let keys = jwks::KeyStore::new(
http,
config.jwks_url.clone(),
config.min_refresh_interval,
config.cache_ttl,
);
Self { config, keys }
}
pub async fn verify(&self, token: &str) -> Result<VerifiedClaims, VerifyError> {
let (encoded_header, encoded_payload, encoded_signature) = verify::split(token)?;
let header = verify::header(encoded_header)?;
let kid = header.kid.ok_or(VerifyError::Malformed)?;
let key = match self.keys.get(&kid) {
Some(key) => key,
None => {
self.keys
.refresh_if_stale()
.await
.map_err(|_| VerifyError::UnknownKey)?;
self.keys.get(&kid).ok_or(VerifyError::UnknownKey)?
}
};
let signed = &token[..encoded_header.len() + 1 + encoded_payload.len()];
verify::signature(&key.n, &key.e, signed, encoded_signature)?;
let claims = verify::payload(encoded_payload)?;
self.check_claims(&claims)?;
Ok(VerifiedClaims::new(claims))
}
fn check_claims(
&self,
claims: &serde_json::Map<String, serde_json::Value>,
) -> Result<(), VerifyError> {
if claims.get("iss").and_then(serde_json::Value::as_str)
!= Some(self.config.issuer.as_str())
{
return Err(VerifyError::Claims);
}
for (name, expected) in &self.config.required_claims {
if claims.get(name).and_then(serde_json::Value::as_str) != Some(expected.as_str()) {
return Err(VerifyError::Claims);
}
}
if !self.config.any_audience && !verify::audience_matches(claims, &self.config.audiences) {
return Err(VerifyError::Claims);
}
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_or(0.0, |since| since.as_secs_f64());
let leeway = self.config.leeway.as_secs_f64();
let expiry = claims
.get("exp")
.and_then(serde_json::Value::as_f64)
.ok_or(VerifyError::Claims)?;
if expiry + leeway <= now {
return Err(VerifyError::Claims);
}
if let Some(not_before) = claims.get("nbf") {
let not_before = not_before.as_f64().ok_or(VerifyError::Claims)?;
if not_before - leeway > now {
return Err(VerifyError::Claims);
}
}
Ok(())
}
}
#[must_use]
pub fn bearer(authorization: &str) -> &str {
let value = authorization.trim();
match value.split_once(char::is_whitespace) {
Some((scheme, token)) if scheme.eq_ignore_ascii_case("bearer") => token.trim(),
_ => value,
}
}