Skip to main content

hyprstream_core/services/oauth/
oidc_discovery.rs

1//! OIDC provider discovery and metadata caching.
2//!
3//! Fetches and caches `/.well-known/openid-configuration` documents
4//! from external OIDC providers configured in `[oauth.oidc_providers]`.
5
6use 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/// Cached OIDC provider metadata (from `/.well-known/openid-configuration`).
15#[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
34/// Fetches and caches OIDC discovery documents for configured providers.
35pub struct OidcDiscoveryCache {
36    cache: RwLock<HashMap<String, CachedMetadata>>,
37    http: reqwest::Client,
38    ttl: Duration,
39}
40
41impl OidcDiscoveryCache {
42    /// Create a new cache with the given TTL and HTTP client.
43    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    /// Get cached metadata or fetch from the provider's discovery endpoint.
63    ///
64    /// # SSRF Protection
65    ///
66    /// The `issuer_url` must be from config (not user input). Discovery
67    /// documents are only fetched from HTTPS URLs (unless `allow_http`).
68    pub async fn get_metadata(
69        &self,
70        issuer_url: &str,
71        allow_http: bool,
72    ) -> Result<OidcProviderMetadata> {
73        // Check cache
74        {
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        // Fetch
84        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        // Size limit: 256KB
113        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        // Validate issuer matches
125        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        // Cache
136        {
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
182/// Shared reference for use in OAuthState.
183pub 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}