use crate::capabilities::IssuerUrl;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AudienceError {
InvalidShape(String),
}
impl fmt::Display for AudienceError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidShape(s) => {
write!(f, "invalid audience {s:?}: must be non-empty printable ASCII, ≤ 256 bytes")
}
}
}
}
impl std::error::Error for AudienceError {}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
#[serde(transparent)]
pub struct Audience(String);
impl Audience {
pub fn try_new(s: impl Into<String>) -> Result<Self, AudienceError> {
let s = s.into();
let ok = !s.is_empty() && s.len() <= 256 && !s.bytes().any(|b| b < 0x20 || b == 0x7f);
if !ok {
return Err(AudienceError::InvalidShape(s));
}
Ok(Self(s))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for Audience {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum AudienceClaim {
#[default]
Aud,
ClientId,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub struct OidcConfig {
issuer: IssuerUrl,
audience: Audience,
#[serde(default)]
audience_claim: AudienceClaim,
}
impl OidcConfig {
pub fn new(issuer: IssuerUrl, audience: Audience) -> Self {
Self { issuer, audience, audience_claim: AudienceClaim::Aud }
}
pub fn with_audience_claim(mut self, claim: AudienceClaim) -> Self {
self.audience_claim = claim;
self
}
pub fn audience_claim(&self) -> AudienceClaim {
self.audience_claim
}
pub fn issuer(&self) -> &IssuerUrl {
&self.issuer
}
pub fn audience(&self) -> &Audience {
&self.audience
}
pub fn discovery_url(&self) -> url::Url {
let base = self.issuer.as_url().as_str().trim_end_matches('/').to_string();
url::Url::parse(&format!("{base}/.well-known/openid-configuration"))
.expect("issuer URL + well-known suffix is always a valid URL")
}
}
#[cfg(test)]
mod tests {
use super::*;
fn issuer(s: &str) -> IssuerUrl {
IssuerUrl::try_new(s.parse().unwrap()).unwrap()
}
#[test]
fn audience_accepts_api_identifier_shapes() {
Audience::try_new("plexus:trak").unwrap();
Audience::try_new("https://api.example.com").unwrap();
Audience::try_new("my-api").unwrap();
}
#[test]
fn audience_rejects_bad_shapes() {
assert!(Audience::try_new("").is_err());
assert!(Audience::try_new("a".repeat(257)).is_err());
assert!(Audience::try_new("evil\0aud").is_err());
}
#[test]
fn discovery_url_normalizes_trailing_slash() {
let c = OidcConfig::new(
issuer("https://idp.example.com"),
Audience::try_new("plexus:trak").unwrap(),
);
assert_eq!(
c.discovery_url().as_str(),
"https://idp.example.com/.well-known/openid-configuration"
);
let c2 = OidcConfig::new(
issuer("https://idp.example.com/tenant/"),
Audience::try_new("plexus:trak").unwrap(),
);
assert_eq!(
c2.discovery_url().as_str(),
"https://idp.example.com/tenant/.well-known/openid-configuration"
);
}
#[test]
fn config_round_trips_serde() {
let c = OidcConfig::new(
issuer("https://idp.example.com"),
Audience::try_new("plexus:trak").unwrap(),
);
let s = serde_json::to_string(&c).unwrap();
let back: OidcConfig = serde_json::from_str(&s).unwrap();
assert_eq!(back, c);
}
#[test]
fn the_audience_claim_is_aud_unless_said() {
let c = OidcConfig::new(issuer("https://idp.example.com"), Audience::try_new("plexus:trak").unwrap());
assert_eq!(c.audience_claim(), AudienceClaim::Aud);
let old: OidcConfig =
serde_json::from_str(r#"{"issuer":"https://idp.example.com/","audience":"plexus:trak"}"#).unwrap();
assert_eq!(old, c);
let w = c.with_audience_claim(AudienceClaim::ClientId);
let back: OidcConfig = serde_json::from_str(&serde_json::to_string(&w).unwrap()).unwrap();
assert_eq!(back.audience_claim(), AudienceClaim::ClientId);
}
}