Skip to main content

hyprstream_core/auth/
jwks_fetcher.rs

1//! TLS-validated JWKS retrieval for the service-authentication path.
2
3use hyprstream_rpc::auth::JwksFetcher;
4use std::sync::Arc;
5
6/// Fetch JWKS documents using reqwest's default TLS verifier.
7///
8/// The returned client trusts the platform CA store. Deployments with a private
9/// PKI must add that CA to the platform trust store or use an explicitly
10/// configured trust mechanism; this fetcher never accepts an invalid server
11/// certificate.
12pub fn default_jwks_fetcher() -> JwksFetcher {
13    jwks_fetcher_with_client(reqwest::Client::new())
14}
15
16fn jwks_fetcher_with_client(client: reqwest::Client) -> JwksFetcher {
17    Arc::new(move |url: String| {
18        let client = client.clone();
19        Box::pin(async move {
20            let response = client.get(&url).send().await?.error_for_status()?;
21            Ok(response.json().await?)
22        })
23    })
24}
25
26#[cfg(test)]
27mod tests {
28    use super::*;
29    use axum::{routing::get, Json, Router};
30
31    struct TestTls {
32        root_pem: Vec<u8>,
33        chain_der: Vec<Vec<u8>>,
34        key_der: Vec<u8>,
35    }
36
37    fn test_tls() -> anyhow::Result<TestTls> {
38        let ca_key = rcgen::KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256)?;
39        let mut ca_params = rcgen::CertificateParams::default();
40        ca_params.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Unconstrained);
41        ca_params
42            .distinguished_name
43            .push(rcgen::DnType::CommonName, "hyprstream-jwks-test-root");
44        let ca = ca_params.self_signed(&ca_key)?;
45
46        let leaf_key = rcgen::KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256)?;
47        let mut leaf_params = rcgen::CertificateParams::new(vec!["localhost".to_owned()])?;
48        leaf_params
49            .distinguished_name
50            .push(rcgen::DnType::CommonName, "localhost");
51        let leaf = leaf_params.signed_by(&leaf_key, &ca, &ca_key)?;
52
53        Ok(TestTls {
54            root_pem: ca.pem().into_bytes(),
55            chain_der: vec![leaf.der().to_vec(), ca.der().to_vec()],
56            key_der: leaf_key.serialize_der(),
57        })
58    }
59
60    #[tokio::test]
61    async fn default_fetcher_rejects_untrusted_tls_and_accepts_declared_ca() -> anyhow::Result<()> {
62        hyprstream_rpc::transport::install_pq_crypto_provider()?;
63        let tls = test_tls()?;
64        let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
65        let address = listener.local_addr()?;
66        let rustls = axum_server::tls_rustls::RustlsConfig::from_der(
67            tls.chain_der.clone(),
68            tls.key_der.clone(),
69        )
70        .await?;
71        let app = Router::new().route(
72            "/oauth/jwks",
73            get(|| async { Json(serde_json::json!({ "keys": [] })) }),
74        );
75        let server = tokio::spawn(async move {
76            let _ = axum_server::from_tcp_rustls(listener, rustls)
77                .serve(app.into_make_service())
78                .await;
79        });
80        let url = format!("https://localhost:{}/oauth/jwks", address.port());
81
82        let error = match default_jwks_fetcher()(url.clone()).await {
83            Ok(jwks) => anyhow::bail!("untrusted TLS certificate returned JWKS: {jwks}"),
84            Err(error) => error,
85        };
86        assert!(
87            error.chain().any(|cause| {
88                let message = cause.to_string();
89                message.contains("certificate verify failed")
90                    && message.contains("self-signed certificate in certificate chain")
91            }),
92            "expected untrusted certificate-chain error, got: {error:#}"
93        );
94
95        let declared_ca = reqwest::Certificate::from_pem(&tls.root_pem)?;
96        let trusted_client = reqwest::Client::builder()
97            .no_proxy()
98            .add_root_certificate(declared_ca)
99            .build()?;
100        let jwks = jwks_fetcher_with_client(trusted_client)(url).await?;
101        assert_eq!(jwks, serde_json::json!({ "keys": [] }));
102
103        server.abort();
104        Ok(())
105    }
106}