use serde::Deserialize;
use crate::error::Error;
use crate::error::Result;
use crate::flow::http_client;
use crate::provider::OAuthConfig;
const WELL_KNOWN_PATH: &str = "/.well-known/openid-configuration";
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct OidcMetadata {
pub issuer: String,
pub authorization_endpoint: String,
pub token_endpoint: String,
#[serde(default)]
pub device_authorization_endpoint: Option<String>,
#[serde(default)]
pub revocation_endpoint: Option<String>,
#[serde(default)]
pub scopes_supported: Option<Vec<String>>,
#[serde(default)]
pub code_challenge_methods_supported: Option<Vec<String>>,
}
impl OidcMetadata {
pub fn to_oauth_config(
&self,
client_id: impl Into<String>,
scopes: Vec<String>,
) -> OAuthConfig {
OAuthConfig {
scopes,
..OAuthConfig::new(
self.authorization_endpoint.clone(),
self.token_endpoint.clone(),
client_id,
)
}
}
}
#[tracing::instrument(level = "debug", skip_all, fields(issuer = %issuer))]
pub async fn discover(issuer: &str) -> Result<OidcMetadata> {
let parsed_issuer = url::Url::parse(issuer)
.map_err(|e| Error::Malformed(format!("invalid OIDC issuer URL `{issuer}`: {e}")))?;
if parsed_issuer.scheme() != "https" && parsed_issuer.scheme() != "http" {
return Err(Error::Malformed(format!(
"invalid OIDC issuer scheme `{}` in `{issuer}`: must be http or https",
parsed_issuer.scheme()
)));
}
if parsed_issuer.query().is_some() || parsed_issuer.fragment().is_some() {
return Err(Error::Malformed(format!(
"OIDC issuer URL `{issuer}` must not contain query or fragment components"
)));
}
let base = issuer.trim_end_matches('/');
let url = format!("{base}{WELL_KNOWN_PATH}");
tracing::debug!("fetching OIDC discovery document");
let client = http_client()?;
let response = client
.get(&url)
.header(reqwest::header::ACCEPT, "application/json")
.send()
.await?;
let status = response.status();
let body = response.text().await?;
if !status.is_success() {
tracing::warn!(status = %status, "OIDC discovery endpoint returned a non-success status");
return Err(Error::Authorization(format!(
"OIDC discovery failed: HTTP {status}"
)));
}
let metadata: OidcMetadata = serde_json::from_str(&body)
.map_err(|e| Error::Malformed(format!("OIDC discovery document: {e}")))?;
if metadata.issuer.trim_end_matches('/') != base {
return Err(Error::Malformed(format!(
"OIDC issuer mismatch: requested `{base}`, document declares `{}`",
metadata.issuer
)));
}
crate::provider::validate_url(&metadata.authorization_endpoint, base, "authorization_endpoint")
.map_err(|e| Error::Malformed(format!("OIDC discovery authorization_endpoint: {e}")))?;
crate::provider::validate_url(&metadata.token_endpoint, base, "token_endpoint")
.map_err(|e| Error::Malformed(format!("OIDC discovery token_endpoint: {e}")))?;
if let Some(dev_ep) = &metadata.device_authorization_endpoint {
crate::provider::validate_url(dev_ep, base, "device_authorization_endpoint")
.map_err(|e| Error::Malformed(format!("OIDC discovery device_authorization_endpoint: {e}")))?;
}
if let Some(methods) = &metadata.code_challenge_methods_supported {
if !methods.iter().any(|m| m == "S256") {
return Err(Error::Malformed(
"OIDC provider does not support S256 PKCE code challenge method".to_string(),
));
}
}
tracing::debug!(
has_device = metadata.device_authorization_endpoint.is_some(),
"OIDC discovery succeeded"
);
Ok(metadata)
}