use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use crate::AxiamError;
use crate::error::IdTokenFailureReason;
pub const MAX_CLOCK_SKEW_SEC: u64 = 60;
pub const ID_TOKEN_ALG: &str = "EdDSA";
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Audience {
One(String),
Many(Vec<String>),
}
impl Audience {
pub fn as_slice(&self) -> Vec<&str> {
match self {
Audience::One(s) => vec![s.as_str()],
Audience::Many(items) => items.iter().map(String::as_str).collect(),
}
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct IdTokenClaims {
pub iss: String,
pub sub: String,
pub aud: Audience,
#[serde(default)]
pub exp: Option<i64>,
#[serde(default)]
pub iat: Option<i64>,
#[serde(default)]
pub nbf: Option<i64>,
#[serde(default)]
pub nonce: Option<String>,
#[serde(default)]
pub azp: Option<String>,
#[serde(flatten)]
pub extra: BTreeMap<String, serde_json::Value>,
}
#[derive(Debug, Clone)]
pub struct IdTokenExpectations<'a> {
pub issuer: &'a str,
pub client_id: &'a str,
pub nonce: Option<&'a str>,
pub clock_skew_sec: u64,
}
pub fn resolve_clock_skew_sec(clock_skew_sec: u64) -> u64 {
clock_skew_sec.min(MAX_CLOCK_SKEW_SEC)
}
pub fn constant_time_equals(a: &str, b: &str) -> bool {
let a = a.as_bytes();
let b = b.as_bytes();
if a.len() != b.len() {
return false;
}
let mut diff: u8 = 0;
for (x, y) in a.iter().zip(b.iter()) {
diff |= x ^ y;
}
diff == 0
}
pub fn check_id_token_claims(
claims: IdTokenClaims,
expectations: &IdTokenExpectations<'_>,
now_sec: i64,
) -> Result<IdTokenClaims, AxiamError> {
let skew = resolve_clock_skew_sec(expectations.clock_skew_sec) as i64;
if claims.iss != expectations.issuer {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidIssuer,
"iss does not equal the discovery document issuer",
));
}
let audiences = claims.aud.as_slice();
if !audiences.contains(&expectations.client_id) {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidAudience,
"aud does not contain this client_id",
));
}
if audiences.len() > 1 && claims.azp.as_deref() != Some(expectations.client_id) {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::InvalidAudience,
"aud holds multiple audiences and azp is absent or does not equal this client_id",
));
}
let exp = claims.exp.ok_or_else(|| {
AxiamError::id_token_invalid(IdTokenFailureReason::TokenExpired, "exp claim is missing")
})?;
if exp + skew <= now_sec {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::TokenExpired,
"exp is in the past",
));
}
let iat = claims.iat.ok_or_else(|| {
AxiamError::id_token_invalid(IdTokenFailureReason::TokenExpired, "iat claim is missing")
})?;
if iat - skew > now_sec {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::TokenExpired,
"iat is in the future",
));
}
if let Some(nbf) = claims.nbf
&& nbf - skew > now_sec
{
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::TokenExpired,
"nbf is in the future",
));
}
if let Some(expected_nonce) = expectations.nonce {
match claims.nonce.as_deref() {
Some(actual) if constant_time_equals(actual, expected_nonce) => {}
_ => {
return Err(AxiamError::id_token_invalid(
IdTokenFailureReason::NonceMismatch,
"nonce claim is absent or does not match the request nonce",
));
}
}
}
Ok(claims)
}
#[cfg(test)]
mod tests {
use super::*;
fn claims() -> IdTokenClaims {
IdTokenClaims {
iss: "https://iam.example.com".into(),
sub: "user-1".into(),
aud: Audience::One("axiam-rp".into()),
exp: Some(1_800_003_600),
iat: Some(1_800_000_000),
nbf: None,
nonce: Some("nonce-value".into()),
azp: None,
extra: BTreeMap::new(),
}
}
fn expectations() -> IdTokenExpectations<'static> {
IdTokenExpectations {
issuer: "https://iam.example.com",
client_id: "axiam-rp",
nonce: Some("nonce-value"),
clock_skew_sec: 60,
}
}
const NOW: i64 = 1_800_000_000;
#[test]
fn accepts_a_fully_valid_claim_set() {
assert!(check_id_token_claims(claims(), &expectations(), NOW).is_ok());
}
#[test]
fn rule3_rejects_issuer_mismatch_including_trailing_slash() {
let mut c = claims();
c.iss = "https://iam.example.com/".into();
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::InvalidIssuer)
);
}
#[test]
fn rule4_accepts_array_audience_containing_client_id() {
let mut c = claims();
c.aud = Audience::Many(vec!["axiam-rp".into()]);
assert!(check_id_token_claims(c, &expectations(), NOW).is_ok());
}
#[test]
fn rule4_rejects_wrong_audience() {
let mut c = claims();
c.aud = Audience::One("other".into());
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::InvalidAudience)
);
}
#[test]
fn rule4_multiple_audiences_require_matching_azp() {
let mut c = claims();
c.aud = Audience::Many(vec!["axiam-rp".into(), "other-rp".into()]);
let err = check_id_token_claims(c.clone(), &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::InvalidAudience)
);
c.azp = Some("axiam-rp".into());
assert!(check_id_token_claims(c, &expectations(), NOW).is_ok());
}
#[test]
fn rule5_missing_exp_or_iat_is_token_expired() {
let mut c = claims();
c.exp = None;
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::TokenExpired)
);
let mut c = claims();
c.iat = None;
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::TokenExpired)
);
}
#[test]
fn rule5_allows_up_to_60s_skew_on_exp_but_no_more() {
let mut c = claims();
c.exp = Some(NOW - 30);
assert!(check_id_token_claims(c, &expectations(), NOW).is_ok());
let mut c = claims();
c.exp = Some(NOW - 61);
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::TokenExpired)
);
}
#[test]
fn rule5_honours_nbf_when_present() {
let mut c = claims();
c.nbf = Some(NOW + 30);
assert!(check_id_token_claims(c, &expectations(), NOW).is_ok());
let mut c = claims();
c.nbf = Some(NOW + 600);
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::TokenExpired)
);
}
#[test]
fn rule5_a_narrowed_skew_is_respected() {
let mut c = claims();
c.exp = Some(NOW - 30);
let mut exp = expectations();
exp.clock_skew_sec = 5;
let err = check_id_token_claims(c, &exp, NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::TokenExpired)
);
}
#[test]
fn resolve_clock_skew_clamps_above_the_maximum() {
assert_eq!(resolve_clock_skew_sec(3600), MAX_CLOCK_SKEW_SEC);
assert_eq!(resolve_clock_skew_sec(5), 5);
}
#[test]
fn rule6_rejects_mismatched_or_missing_nonce() {
let mut c = claims();
c.nonce = Some("other".into());
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::NonceMismatch)
);
let mut c = claims();
c.nonce = None;
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
assert_eq!(
err.id_token_failure_reason(),
Some(IdTokenFailureReason::NonceMismatch)
);
}
#[test]
fn rule6_is_skipped_when_no_nonce_is_expected() {
let mut exp = expectations();
exp.nonce = None;
let mut c = claims();
c.nonce = None;
assert!(check_id_token_claims(c.clone(), &exp, NOW).is_ok());
c.nonce = Some("anything".into());
assert!(check_id_token_claims(c, &exp, NOW).is_ok());
}
#[test]
fn never_embeds_the_expected_or_actual_nonce_in_the_error_message() {
let mut c = claims();
c.nonce = Some("wrong-value".into());
let err = check_id_token_claims(c, &expectations(), NOW).unwrap_err();
let message = err.to_string();
assert!(!message.contains("nonce-value"));
assert!(!message.contains("wrong-value"));
}
#[test]
fn preserves_unknown_claims_in_extra() {
let json = serde_json::json!({
"iss": "https://iam.example.com",
"sub": "user-1",
"aud": "axiam-rp",
"exp": 1_800_003_600i64,
"iat": 1_800_000_000i64,
"nonce": "n",
"email": "user@example.com",
"custom_org_tier": "gold",
});
let claims: IdTokenClaims = serde_json::from_value(json).expect("deserialize");
assert_eq!(
claims.extra.get("email").and_then(|v| v.as_str()),
Some("user@example.com")
);
assert_eq!(
claims.extra.get("custom_org_tier").and_then(|v| v.as_str()),
Some("gold")
);
}
}