plexus_auth_core/oidc/
config.rs1use crate::capabilities::IssuerUrl;
4use schemars::JsonSchema;
5use serde::{Deserialize, Serialize};
6use std::fmt;
7
8#[derive(Debug, Clone, PartialEq, Eq)]
10pub enum AudienceError {
11 InvalidShape(String),
13}
14
15impl fmt::Display for AudienceError {
16 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17 match self {
18 Self::InvalidShape(s) => {
19 write!(f, "invalid audience {s:?}: must be non-empty printable ASCII, ≤ 256 bytes")
20 }
21 }
22 }
23}
24
25impl std::error::Error for AudienceError {}
26
27#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
39#[serde(transparent)]
40pub struct Audience(String);
41
42impl Audience {
43 pub fn try_new(s: impl Into<String>) -> Result<Self, AudienceError> {
47 let s = s.into();
48 let ok = !s.is_empty() && s.len() <= 256 && !s.bytes().any(|b| b < 0x20 || b == 0x7f);
49 if !ok {
50 return Err(AudienceError::InvalidShape(s));
51 }
52 Ok(Self(s))
53 }
54
55 pub fn as_str(&self) -> &str {
57 &self.0
58 }
59}
60
61impl fmt::Display for Audience {
62 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
63 f.write_str(self.as_str())
64 }
65}
66
67#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
69#[serde(rename_all = "snake_case")]
70pub enum AudienceClaim {
71 #[default]
73 Aud,
74 ClientId,
78}
79
80#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
87pub struct OidcConfig {
88 issuer: IssuerUrl,
89 audience: Audience,
90 #[serde(default)]
93 audience_claim: AudienceClaim,
94}
95
96impl OidcConfig {
97 pub fn new(issuer: IssuerUrl, audience: Audience) -> Self {
99 Self { issuer, audience, audience_claim: AudienceClaim::Aud }
100 }
101
102 pub fn with_audience_claim(mut self, claim: AudienceClaim) -> Self {
104 self.audience_claim = claim;
105 self
106 }
107
108 pub fn audience_claim(&self) -> AudienceClaim {
110 self.audience_claim
111 }
112
113 pub fn issuer(&self) -> &IssuerUrl {
115 &self.issuer
116 }
117
118 pub fn audience(&self) -> &Audience {
120 &self.audience
121 }
122
123 pub fn discovery_url(&self) -> url::Url {
127 let base = self.issuer.as_url().as_str().trim_end_matches('/').to_string();
128 url::Url::parse(&format!("{base}/.well-known/openid-configuration"))
129 .expect("issuer URL + well-known suffix is always a valid URL")
130 }
131}
132
133#[cfg(test)]
134mod tests {
135 use super::*;
136
137 fn issuer(s: &str) -> IssuerUrl {
138 IssuerUrl::try_new(s.parse().unwrap()).unwrap()
139 }
140
141 #[test]
142 fn audience_accepts_api_identifier_shapes() {
143 Audience::try_new("plexus:trak").unwrap();
144 Audience::try_new("https://api.example.com").unwrap();
145 Audience::try_new("my-api").unwrap();
146 }
147
148 #[test]
149 fn audience_rejects_bad_shapes() {
150 assert!(Audience::try_new("").is_err());
151 assert!(Audience::try_new("a".repeat(257)).is_err());
152 assert!(Audience::try_new("evil\0aud").is_err());
153 }
154
155 #[test]
156 fn discovery_url_normalizes_trailing_slash() {
157 let c = OidcConfig::new(
160 issuer("https://idp.example.com"),
161 Audience::try_new("plexus:trak").unwrap(),
162 );
163 assert_eq!(
164 c.discovery_url().as_str(),
165 "https://idp.example.com/.well-known/openid-configuration"
166 );
167
168 let c2 = OidcConfig::new(
169 issuer("https://idp.example.com/tenant/"),
170 Audience::try_new("plexus:trak").unwrap(),
171 );
172 assert_eq!(
173 c2.discovery_url().as_str(),
174 "https://idp.example.com/tenant/.well-known/openid-configuration"
175 );
176 }
177
178 #[test]
179 fn config_round_trips_serde() {
180 let c = OidcConfig::new(
181 issuer("https://idp.example.com"),
182 Audience::try_new("plexus:trak").unwrap(),
183 );
184 let s = serde_json::to_string(&c).unwrap();
185 let back: OidcConfig = serde_json::from_str(&s).unwrap();
186 assert_eq!(back, c);
187 }
188
189 #[test]
190 fn the_audience_claim_is_aud_unless_said() {
191 let c = OidcConfig::new(issuer("https://idp.example.com"), Audience::try_new("plexus:trak").unwrap());
192 assert_eq!(c.audience_claim(), AudienceClaim::Aud);
193 let old: OidcConfig =
195 serde_json::from_str(r#"{"issuer":"https://idp.example.com/","audience":"plexus:trak"}"#).unwrap();
196 assert_eq!(old, c);
197 let w = c.with_audience_claim(AudienceClaim::ClientId);
198 let back: OidcConfig = serde_json::from_str(&serde_json::to_string(&w).unwrap()).unwrap();
199 assert_eq!(back.audience_claim(), AudienceClaim::ClientId);
200 }
201}