hyprstream_core/services/oauth/
oidc_discovery.rs1use std::collections::HashMap;
7use std::sync::Arc;
8use std::time::{Duration, Instant};
9
10use anyhow::{anyhow, Context, Result};
11use serde::Deserialize;
12use tokio::sync::RwLock;
13
14#[derive(Debug, Clone, Deserialize)]
16pub struct OidcProviderMetadata {
17 pub issuer: String,
18 pub authorization_endpoint: String,
19 pub token_endpoint: String,
20 #[serde(default)]
21 pub userinfo_endpoint: Option<String>,
22 pub jwks_uri: String,
23 #[serde(default)]
24 pub scopes_supported: Vec<String>,
25 #[serde(default)]
26 pub id_token_signing_alg_values_supported: Vec<String>,
27}
28
29struct CachedMetadata {
30 metadata: OidcProviderMetadata,
31 fetched_at: Instant,
32}
33
34pub struct OidcDiscoveryCache {
36 cache: RwLock<HashMap<String, CachedMetadata>>,
37 http: reqwest::Client,
38 ttl: Duration,
39}
40
41impl OidcDiscoveryCache {
42 pub fn new(http: reqwest::Client, ttl: Duration) -> Self {
44 Self {
45 cache: RwLock::new(HashMap::new()),
46 http,
47 ttl,
48 }
49 }
50
51 #[cfg(test)]
52 pub async fn seed_for_test(&self, metadata: OidcProviderMetadata) {
53 self.cache.write().await.insert(
54 metadata.issuer.clone(),
55 CachedMetadata {
56 metadata,
57 fetched_at: Instant::now(),
58 },
59 );
60 }
61
62 pub async fn get_metadata(
69 &self,
70 issuer_url: &str,
71 allow_http: bool,
72 ) -> Result<OidcProviderMetadata> {
73 {
75 let cache = self.cache.read().await;
76 if let Some(cached) = cache.get(issuer_url) {
77 if cached.fetched_at.elapsed() < self.ttl {
78 return Ok(cached.metadata.clone());
79 }
80 }
81 }
82
83 let discovery_url = format!(
85 "{}/.well-known/openid-configuration",
86 issuer_url.trim_end_matches('/')
87 );
88
89 if !allow_http && !discovery_url.starts_with("https://") {
90 return Err(anyhow!(
91 "OIDC discovery requires HTTPS (set allow_http=true for dev): {}",
92 discovery_url
93 ));
94 }
95
96 let response = self
97 .http
98 .get(&discovery_url)
99 .timeout(Duration::from_secs(10))
100 .send()
101 .await
102 .with_context(|| format!("Failed to fetch OIDC discovery from {}", discovery_url))?;
103
104 if !response.status().is_success() {
105 return Err(anyhow!(
106 "OIDC discovery returned {}: {}",
107 response.status(),
108 discovery_url
109 ));
110 }
111
112 let bytes = response.bytes().await?;
114 if bytes.len() > 256 * 1024 {
115 return Err(anyhow!(
116 "OIDC discovery response too large: {} bytes",
117 bytes.len()
118 ));
119 }
120
121 let metadata: OidcProviderMetadata = serde_json::from_slice(&bytes)
122 .with_context(|| format!("Invalid OIDC discovery JSON from {}", discovery_url))?;
123
124 if metadata.issuer != issuer_url {
126 return Err(anyhow!(
127 "OIDC discovery issuer mismatch: expected '{}', got '{}'",
128 issuer_url,
129 metadata.issuer
130 ));
131 }
132
133 validate_metadata_endpoints(&metadata, allow_http)?;
134
135 {
137 let mut cache = self.cache.write().await;
138 cache.insert(
139 issuer_url.to_owned(),
140 CachedMetadata {
141 metadata: metadata.clone(),
142 fetched_at: Instant::now(),
143 },
144 );
145 }
146
147 Ok(metadata)
148 }
149}
150
151fn validate_metadata_endpoints(metadata: &OidcProviderMetadata, allow_http: bool) -> Result<()> {
152 for (name, endpoint) in [
153 ("authorization_endpoint", &metadata.authorization_endpoint),
154 ("token_endpoint", &metadata.token_endpoint),
155 ("jwks_uri", &metadata.jwks_uri),
156 ] {
157 let parsed = url::Url::parse(endpoint)
158 .with_context(|| format!("OIDC discovery {name} is not a valid URL"))?;
159 let permitted_scheme =
160 parsed.scheme() == "https" || (allow_http && parsed.scheme() == "http");
161 if !permitted_scheme || parsed.host_str().is_none() {
162 return Err(anyhow!(
163 "OIDC discovery {name} must be HTTPS with a host (HTTP permitted only with allow_http=true)"
164 ));
165 }
166 }
167 Ok(())
168}
169
170impl Default for OidcDiscoveryCache {
171 fn default() -> Self {
172 Self::new(
173 reqwest::Client::builder()
174 .timeout(Duration::from_secs(10))
175 .build()
176 .unwrap_or_default(),
177 Duration::from_secs(300),
178 )
179 }
180}
181
182pub type SharedDiscoveryCache = Arc<OidcDiscoveryCache>;
184
185#[cfg(test)]
186mod tests {
187 use super::*;
188
189 #[test]
190 fn external_oidc_discovery_checks_browser_authorization_endpoint_scheme() {
191 let mut metadata = OidcProviderMetadata {
192 issuer: "https://idp.example".to_owned(),
193 authorization_endpoint: "https://idp.example/authorize".to_owned(),
194 token_endpoint: "https://idp.example/token".to_owned(),
195 userinfo_endpoint: None,
196 jwks_uri: "https://idp.example/jwks".to_owned(),
197 scopes_supported: vec![],
198 id_token_signing_alg_values_supported: vec![],
199 };
200 assert!(validate_metadata_endpoints(&metadata, false).is_ok());
201 metadata.authorization_endpoint = "http://idp.example/authorize".to_owned();
202 assert!(validate_metadata_endpoints(&metadata, false).is_err());
203 assert!(validate_metadata_endpoints(&metadata, true).is_ok());
204 metadata.authorization_endpoint = "javascript:alert(1)".to_owned();
205 assert!(validate_metadata_endpoints(&metadata, true).is_err());
206 }
207}