Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

feat(websocket): inherit browser TLS credentials

ldm07ed1ce8a9314
diff --git a/Cargo.lock b/Cargo.lock
index f675ea475..b97951418 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3263,6 +3263,7 @@ dependencies = [
"moli-curl",
"moli-dns-resolver",
"moli-url",
+ "openssl",
"rcgen",
"rustls",
"tokio",
diff --git a/moli-curl/src/websocket.rs b/moli-curl/src/websocket.rs
index 7772bcc8a..44f4f024f 100644
--- a/moli-curl/src/websocket.rs
+++ b/moli-curl/src/websocket.rs
@@ -23,7 +23,9 @@ use curl::multi::MultiWaker;
use parking_lot::Mutex;
use tokio::sync::{OwnedSemaphorePermit, Semaphore, mpsc};
-use crate::{CurlDnsResolution, CurlTransferId, runtime::identity::next_transfer_id};
+use crate::{
+ CurlDnsResolution, CurlTlsConfig, CurlTransferId, runtime::identity::next_transfer_id,
+};
pub use curl::easy::{WsFlags, WsFrame};
/// Fragment large messages above this layer to bound native write residence.
@@ -40,7 +42,7 @@ pub struct CurlWebSocketRequest {
/// An already resolved proxy policy. None explicitly disables environment proxies.
pub proxy: Option<String>,
pub proxy_headers: Vec<(String, String)>,
- pub tls_verify: bool,
+ pub tls: CurlTlsConfig,
pub dns_resolution: CurlDnsResolution,
pub handshake_timeout: Duration,
}
@@ -52,7 +54,7 @@ impl CurlWebSocketRequest {
headers: Vec::new(),
proxy: None,
proxy_headers: Vec::new(),
- tls_verify: true,
+ tls: CurlTlsConfig::default(),
dns_resolution: CurlDnsResolution::curl_managed(),
handshake_timeout: Duration::from_secs(30),
}
diff --git a/moli-curl/src/websocket/request.rs b/moli-curl/src/websocket/request.rs
index f2809e2bc..81e9694b4 100644
--- a/moli-curl/src/websocket/request.rs
+++ b/moli-curl/src/websocket/request.rs
@@ -67,8 +67,8 @@ pub(super) fn configure(request: &CurlWebSocketRequest) -> Result<Easy2<Handshak
easy.signal(false)?;
easy.ws_connect_only(true)?;
easy.ws_options(WsOptions::new().no_auto_pong(true))?;
- easy.ssl_verify_peer(request.tls_verify)?;
- easy.ssl_verify_host(request.tls_verify)?;
+ // The caller selects the client identity carried by this connection request.
+ request.tls.configure(&mut easy, true)?;
easy.proxy(request.proxy.as_deref().unwrap_or(""))?;
// The browser has already applied no_proxy; do not evaluate environment policy twice.
easy.noproxy("")?;
diff --git a/moli-fetch/src/client.rs b/moli-fetch/src/client.rs
index 928815881..8640be4f1 100644
--- a/moli-fetch/src/client.rs
+++ b/moli-fetch/src/client.rs
@@ -187,6 +187,10 @@ impl FetchClientHandle {
self.config.tls_verify_host()
}
+ pub fn tls_config(&self) -> &moli_curl::CurlTlsConfig {
+ self.config.tls_config()
+ }
+
pub fn request_timeout_ms(&self) -> u64 {
self.config.request_timeout_ms()
}
diff --git a/moli-fetch/src/lib.rs b/moli-fetch/src/lib.rs
index 0914dd20f..ab85f9532 100644
--- a/moli-fetch/src/lib.rs
+++ b/moli-fetch/src/lib.rs
@@ -45,6 +45,7 @@ pub use headers::{
is_forbidden_response_header_name, is_no_cors_safelisted_request_header,
};
pub use moli_cookie_jar::SharedBrowserCookieStore as SharedCookieStore;
+pub use moli_curl::CurlTlsConfig;
pub use moli_web_bot_auth::{WebBotAuthProfile, WebBotAuthSigner};
pub use network_fetch_result::{
NetworkExchangeObservation, NetworkFetchFailureContext, NetworkFetchFailureRequestContext,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/websockets/registration.rs b/moli-renderer-v8/src/native_bridge/context_host/websockets/registration.rs
index b7005eba8..77760c80f 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/websockets/registration.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/websockets/registration.rs
@@ -58,9 +58,9 @@ impl JsContextHost {
http_no_proxy: loader.and_then(|loader| loader.http_no_proxy().map(ToOwned::to_owned)),
proxy_bearer_token: loader
.and_then(|loader| loader.proxy_bearer_token().map(ToOwned::to_owned)),
- tls_verify_host: loader
- .map(|loader| loader.tls_verify_host())
- .unwrap_or(true),
+ tls: loader
+ .map(|loader| loader.tls_config().clone())
+ .unwrap_or_default(),
cookie_header: cookie_header_for_context,
pause_after_handshake: false,
};
diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rs
index d7d4cf454..25239aa0a 100644
--- a/moli-renderer-v8/src/network/request_client.rs
+++ b/moli-renderer-v8/src/network/request_client.rs
@@ -967,6 +967,10 @@ impl ResourceRequestClient {
self.resource_runtime.client().tls_verify_host()
}
+ pub fn tls_config(&self) -> &moli_fetch::CurlTlsConfig {
+ self.resource_runtime.client().tls_config()
+ }
+
pub fn request_timeout_ms(&self) -> u64 {
self.resource_runtime.client().request_timeout_ms()
}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/mod.rs
index 2b5190c2c..04361c36d 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/mod.rs
@@ -4,4 +4,5 @@ mod basic;
mod completion;
mod handshake;
mod stream;
+mod tls;
mod wpt_target;
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/tls.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/tls.rs
new file mode 100644
index 000000000..607f7064b
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/tls.rs
@@ -0,0 +1,95 @@
+use super::*;
+use moli_websocket::test_support::TlsWebSocketFixture;
+
+#[derive(Clone, Copy)]
+enum Client {
+ Page,
+ Stream,
+}
+
+async fn tls_credentials_reach_client(client: Client) {
+ let fixture = TlsWebSocketFixture::new();
+ let (url, server) = fixture.spawn(true).await;
+ let tls = fixture.tls_config();
+ let mut config = FetchConfig::default();
+ config.set_http_proxy(Some(String::new()));
+ config.set_tls_credentials(
+ tls.ca_cert,
+ tls.client_cert,
+ tls.client_key,
+ tls.client_cert_password,
+ );
+ // The document is https://example.com, so this also verifies that WSS
+ // sends its configured identity across origins (credentials=include).
+ let mut page_vm = test_page_vm_with_config(config, Vec::new());
+ let local_executor = page_vm.local_executor.clone();
+ let result = local_executor.run(Box::pin(async move {
+ let socket_script = format!(r#"
+ const socket = new WebSocket({url:?});
+ let echo;
+ socket.onopen = () => socket.send('tls-echo');
+ socket.onmessage = event => {{ echo = event.data; socket.close(1000, 'done'); }};
+ socket.onclose = event => finish(`${{echo}}:${{event.code}}:${{event.wasClean}}`);
+ socket.onerror = () => finish('error');
+ "#);
+ let script = match client {
+ Client::Page => socket_script,
+ Client::Stream => format!(r#"
+ (async () => {{
+ try {{
+ const stream = new WebSocketStream({url:?});
+ stream.closed.catch(() => {{}});
+ const opened = await stream.opened;
+ const writer = opened.writable.getWriter();
+ const reader = opened.readable.getReader();
+ await writer.write('tls-echo');
+ const {{value}} = await reader.read();
+ await writer.close();
+ const info = await stream.closed;
+ finish(`${{value}}:${{info.closeCode}}`);
+ }} catch (error) {{ finish('error'); }}
+ }})();
+ "#),
+
+ };
+ page_vm.vm_mut().eval(&format!(r#"
+ globalThis.__tlsDone = false;
+ (() => {{
+ const finish = value => {{ globalThis.__tlsResult = value; globalThis.__tlsDone = true; }};
+ {script}
+ }})();
+ "#))?;
+ drive_websocket_until_done(&mut page_vm, "String(globalThis.__tlsDone === true)", "TLS round trip").await?;
+ page_vm.vm_mut().eval("String(globalThis.__tlsResult)")
+ })).await.expect("TLS test runs on the page owner lane");
+ let peer = server.await.expect("TLS fixture task");
+ assert_eq!(
+ result,
+ if matches!(client, Client::Stream) {
+ "tls-echo:1005"
+ } else {
+ "tls-echo:1000:true"
+ },
+ "server result: {peer:?}"
+ );
+ assert_eq!(
+ peer.expect("mTLS WebSocket handshake and close"),
+ std::slice::from_ref(&fixture.client_certificate)
+ );
+}
+
+// V8's debug stack budget is 4 MiB; match the renderer's 8 MiB native
+// stack when driving Promise/Stream callbacks from these PageVm fixtures.
+#[test]
+fn websocket_tls_credentials_reach_page() {
+ run_page_vm_large_stack_async_test("tls-page", || {
+ Box::pin(tls_credentials_reach_client(Client::Page))
+ });
+}
+
+#[test]
+fn websocket_tls_credentials_reach_stream() {
+ run_page_vm_large_stack_async_test("tls-stream", || {
+ Box::pin(tls_credentials_reach_client(Client::Stream))
+ });
+}
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index 1705f1746..562848188 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -1288,7 +1288,7 @@ pub(crate) fn register_worker_websocket<'s>(
.request_client()
.proxy_bearer_token()
.map(ToOwned::to_owned),
- tls_verify_host: loader.request_client().tls_verify_host(),
+ tls: loader.request_client().tls_config().clone(),
cookie_header: cookie_header_for_context,
pause_after_handshake: false,
};
diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs
index bd002398f..c3fbd9878 100644
--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs
@@ -1521,3 +1521,4 @@ mod lifecycle;
mod modules;
mod network;
mod postmessage;
+mod tls;
diff --git a/moli-renderer-v8/src/worker/thread/tests/tls.rs b/moli-renderer-v8/src/worker/thread/tests/tls.rs
new file mode 100644
index 000000000..33846826b
--- /dev/null
+++ b/moli-renderer-v8/src/worker/thread/tests/tls.rs
@@ -0,0 +1,67 @@
+use super::super::WorkerGlobalKind;
+use super::*;
+use moli_websocket::test_support::TlsWebSocketFixture;
+
+async fn tls_credentials_reach_worker(kind: WorkerGlobalKind) {
+ ensure_v8();
+ let fixture = TlsWebSocketFixture::new();
+ let (url, server) = fixture.spawn(true).await;
+ let tls = fixture.tls_config();
+ let mut config = FetchConfig::default();
+ config.set_http_proxy(Some(String::new()));
+ config.set_tls_credentials(
+ tls.ca_cert,
+ tls.client_cert,
+ tls.client_key,
+ tls.client_cert_password,
+ );
+ let client = ResourceRequestClient::new(&config).expect("Worker TLS request client");
+ let worker = spawn_test_worker_with_options(
+ WorkerSpawnOptions::new(
+ format!(
+ r#"
+ const socket = new WebSocket({url:?});
+ socket.onopen = () => socket.send('worker-tls-echo');
+ socket.onmessage = event => {{
+ if (event.data === 'worker-tls-echo') socket.close(1000, 'done');
+ }};
+ socket.onclose = () => close();
+ socket.onerror = () => close();
+ "#
+ ),
+ // A different origin from the WSS endpoint: WebSocket credentials
+ // are included even though module/fetch defaults use same-origin.
+ "https://example.com/worker.js".to_owned(),
+ )
+ .with_request_client(client)
+ .with_global_kind(kind),
+ );
+ let peer = server.await.expect("Worker TLS fixture task");
+ worker.terminate_and_join();
+ assert_eq!(
+ peer.expect("Worker mTLS handshake, echo and close"),
+ std::slice::from_ref(&fixture.client_certificate)
+ );
+}
+
+#[tokio::test]
+async fn websocket_tls_credentials_reach_dedicated_worker() {
+ tls_credentials_reach_worker(WorkerGlobalKind::Dedicated {
+ name: "tls-worker".to_owned(),
+ })
+ .await;
+}
+
+#[tokio::test]
+async fn websocket_tls_credentials_reach_shared_worker() {
+ tls_credentials_reach_worker(WorkerGlobalKind::Shared {
+ name: "tls-shared-worker".to_owned(),
+ storage_key: moli_storage_key::MoliStorageKey::new(
+ "https://example.com".to_owned(),
+ "https://example.com".to_owned(),
+ None,
+ moli_storage_key::StoragePartitionRelation::FirstParty,
+ ),
+ })
+ .await;
+}
diff --git a/moli-websocket/Cargo.toml b/moli-websocket/Cargo.toml
index 8741bdc93..70025b910 100644
--- a/moli-websocket/Cargo.toml
+++ b/moli-websocket/Cargo.toml
@@ -5,7 +5,7 @@ version = "0.1.0"
edition = "2024"
[features]
-test-support = ["dep:rcgen", "dep:tokio-tungstenite", "dep:tokio-rustls", "dep:rustls", "dep:futures-util", "tokio/net", "tokio/io-util"]
+test-support = ["dep:rcgen", "dep:openssl", "dep:tokio-tungstenite", "dep:tokio-rustls", "dep:rustls", "dep:futures-util", "tokio/net", "tokio/io-util"]
[dependencies]
base64 = "0.22"
@@ -15,7 +15,8 @@ moli-dns-resolver = { path = "../moli-dns-resolver" }
futures-util = { version = "0.3", default-features = false, features = ["sink", "std"], optional = true }
http = "1"
moli-url = { path = "../moli-url" }
-rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs"], optional = true }
+rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs", "pem"], optional = true }
+openssl = { version = "0.10", optional = true }
rustls = { version = "0.23", default-features = false, features = ["aws_lc_rs", "logging", "prefer-post-quantum", "std", "tls12"], optional = true }
tokio = { version = "1.51.0", features = ["macros", "rt-multi-thread", "sync", "time"] }
tokio-rustls = { version = "0.26", default-features = false, features = ["aws_lc_rs", "logging", "tls12"], optional = true }
@@ -28,7 +29,8 @@ rustls = { version = "0.23", default-features = false, features = ["aws_lc_rs",
tokio = { version = "1.51.0", features = ["io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }
tokio-rustls = { version = "0.26", default-features = false, features = ["aws_lc_rs", "logging", "tls12"] }
tokio-tungstenite = { version = "0.28.0", default-features = false, features = ["handshake", "__rustls-tls"] }
-rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs"] }
+rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs", "pem"] }
+openssl = "0.10"
[lints]
workspace = true
diff --git a/moli-websocket/src/test_support.rs b/moli-websocket/src/test_support.rs
index 4226264d4..f8dd650a5 100644
--- a/moli-websocket/src/test_support.rs
+++ b/moli-websocket/src/test_support.rs
@@ -2,6 +2,9 @@
// unboxed HTTP response, so these test-server callbacks cannot shrink it.
#![allow(clippy::result_large_err)]
+mod tls;
+pub use tls::TlsWebSocketFixture;
+
use std::sync::Arc;
use futures_util::{SinkExt, StreamExt};
@@ -39,7 +42,7 @@ pub fn test_websocket_context() -> ConnectOptions {
http_proxy: None,
http_no_proxy: None,
proxy_bearer_token: None,
- tls_verify_host: true,
+ tls: Default::default(),
cookie_header: None,
pause_after_handshake: false,
}
diff --git a/moli-websocket/src/test_support/tls.rs b/moli-websocket/src/test_support/tls.rs
new file mode 100644
index 000000000..78e50a02e
--- /dev/null
+++ b/moli-websocket/src/test_support/tls.rs
@@ -0,0 +1,203 @@
+use std::{
+ fs,
+ path::PathBuf,
+ sync::{
+ Arc,
+ atomic::{AtomicU64, Ordering},
+ },
+ time::{SystemTime, UNIX_EPOCH},
+};
+
+use futures_util::{SinkExt, StreamExt};
+use moli_curl::CurlTlsConfig;
+use openssl::{pkcs12::Pkcs12, pkey::PKey, symm::Cipher, x509::X509};
+use rcgen::{
+ BasicConstraints, CertificateParams, DnType, ExtendedKeyUsagePurpose, IsCa, KeyPair,
+ KeyUsagePurpose,
+};
+use rustls::{
+ RootCertStore, ServerConfig,
+ pki_types::{CertificateDer, PrivatePkcs8KeyDer},
+ server::WebPkiClientVerifier,
+};
+use tokio::{
+ net::TcpListener,
+ task::JoinHandle,
+ time::{Duration, timeout},
+};
+use tokio_tungstenite::tungstenite::Message;
+
+/// Private trust and client identity files for real WSS connection tests.
+pub struct TlsWebSocketFixture {
+ dir: PathBuf,
+ roots: RootCertStore,
+ server_certificate: CertificateDer<'static>,
+ server_key: PrivatePkcs8KeyDer<'static>,
+ pub client_certificate: Vec<u8>,
+}
+
+impl Default for TlsWebSocketFixture {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl TlsWebSocketFixture {
+ pub fn new() -> Self {
+ let ca_key = KeyPair::generate().unwrap();
+ let mut ca_params = CertificateParams::new(Vec::new()).unwrap();
+ ca_params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
+ ca_params.key_usages = vec![KeyUsagePurpose::KeyCertSign];
+ ca_params
+ .distinguished_name
+ .push(DnType::CommonName, "Moli WSS test CA");
+ let ca = ca_params.self_signed(&ca_key).unwrap();
+ let server_key = KeyPair::generate().unwrap();
+ // Only localhost is valid, so the same endpoint can test a hostname mismatch.
+ let mut server_params = CertificateParams::new(vec!["localhost".to_owned()]).unwrap();
+ server_params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ServerAuth];
+ let server_cert = server_params.signed_by(&server_key, &ca, &ca_key).unwrap();
+ let client_key = KeyPair::generate().unwrap();
+ let mut client_params = CertificateParams::new(Vec::new()).unwrap();
+ client_params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ClientAuth];
+ let client_cert = client_params.signed_by(&client_key, &ca, &ca_key).unwrap();
+
+ static NEXT_ID: AtomicU64 = AtomicU64::new(0);
+ let dir = std::env::temp_dir().join(format!(
+ "moli-websocket-tls-{}-{}-{}",
+ std::process::id(),
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap()
+ .as_nanos(),
+ NEXT_ID.fetch_add(1, Ordering::Relaxed),
+ ));
+ fs::create_dir(&dir).unwrap();
+ let mut roots = RootCertStore::empty();
+ roots.add(ca.der().clone()).unwrap();
+ let fixture = Self {
+ dir,
+ roots,
+ server_certificate: server_cert.der().clone(),
+ server_key: server_key.serialize_der().into(),
+ client_certificate: client_cert.der().to_vec(),
+ };
+ fs::write(fixture.dir.join("ca.pem"), ca.pem()).unwrap();
+ fs::write(fixture.dir.join("client.pem"), client_cert.pem()).unwrap();
+ fs::write(fixture.dir.join("client.der"), client_cert.der()).unwrap();
+ fs::write(
+ fixture.dir.join("client-key.pem"),
+ client_key.serialize_pem(),
+ )
+ .unwrap();
+ fs::write(
+ fixture.dir.join("client-combined.pem"),
+ format!("{}{}", client_cert.pem(), client_key.serialize_pem()),
+ )
+ .unwrap();
+ let key = PKey::private_key_from_der(&client_key.serialize_der()).unwrap();
+ let cert = X509::from_der(client_cert.der()).unwrap();
+ let password = "moli-tls-test-password";
+ fs::write(
+ fixture.dir.join("client-encrypted-key.pem"),
+ key.private_key_to_pem_pkcs8_passphrase(Cipher::aes_256_cbc(), password.as_bytes())
+ .unwrap(),
+ )
+ .unwrap();
+ let pkcs12 = Pkcs12::builder()
+ .name("moli-client")
+ .pkey(&key)
+ .cert(&cert)
+ .build2(password)
+ .unwrap()
+ .to_der()
+ .unwrap();
+ fs::write(fixture.dir.join("client.p12"), &pkcs12).unwrap();
+ fs::write(fixture.dir.join("client.PFX"), pkcs12).unwrap();
+ fixture
+ }
+
+ pub fn tls_config(&self) -> CurlTlsConfig {
+ CurlTlsConfig {
+ ca_cert: Some(self.dir.join("ca.pem")),
+ client_cert: Some(self.dir.join("client.pem")),
+ client_key: Some(self.dir.join("client-key.pem")),
+ client_cert_password: Some("moli-tls-test-password".to_owned()),
+ ..CurlTlsConfig::default()
+ }
+ }
+
+ pub fn pkcs12_config(&self) -> CurlTlsConfig {
+ CurlTlsConfig {
+ client_cert: Some(self.dir.join("client.p12")),
+ client_key: None,
+ ..self.tls_config()
+ }
+ }
+
+ /// Echoes until a clean WebSocket close and returns the actual TLS peer chain.
+ pub async fn spawn(
+ &self,
+ require_identity: bool,
+ ) -> (String, JoinHandle<Result<Vec<Vec<u8>>, String>>) {
+ let verifier = WebPkiClientVerifier::builder(Arc::new(self.roots.clone()));
+ let verifier = if require_identity {
+ verifier
+ } else {
+ verifier.allow_unauthenticated()
+ };
+ let config = ServerConfig::builder()
+ .with_client_cert_verifier(verifier.build().unwrap())
+ .with_single_cert(
+ vec![self.server_certificate.clone()],
+ self.server_key.clone_key().into(),
+ )
+ .unwrap();
+ let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(config));
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let port = listener.local_addr().unwrap().port();
+ let task = tokio::spawn(async move {
+ timeout(Duration::from_secs(10), async move {
+ let (tcp, _) = listener.accept().await.map_err(|error| error.to_string())?;
+ let stream = acceptor
+ .accept(tcp)
+ .await
+ .map_err(|error| format!("TLS: {error}"))?;
+ let certificates = stream
+ .get_ref()
+ .1
+ .peer_certificates()
+ .unwrap_or_default()
+ .iter()
+ .map(|cert| cert.to_vec())
+ .collect();
+ let mut socket = tokio_tungstenite::accept_async(stream)
+ .await
+ .map_err(|error| format!("Upgrade: {error}"))?;
+ while let Some(message) = socket.next().await {
+ match message.map_err(|error| error.to_string())? {
+ message @ (Message::Text(_) | Message::Binary(_)) => socket
+ .send(message)
+ .await
+ .map_err(|error| error.to_string())?,
+ Message::Close(_) => {
+ socket.flush().await.map_err(|error| error.to_string())?;
+ return Ok(certificates);
+ }
+ _ => {}
+ }
+ }
+ Err("WebSocket ended without a Close frame".to_owned())
+ })
+ .await
+ .map_err(|error| format!("TLS fixture deadline: {error}"))?
+ });
+ (format!("wss://localhost:{port}/tls"), task)
+ }
+}
+
+impl Drop for TlsWebSocketFixture {
+ fn drop(&mut self) {
+ let _ = fs::remove_dir_all(&self.dir);
+ }
+}
diff --git a/moli-websocket/src/tests.rs b/moli-websocket/src/tests.rs
index b19295dff..a8da138a3 100644
--- a/moli-websocket/src/tests.rs
+++ b/moli-websocket/src/tests.rs
@@ -16,6 +16,8 @@ use tokio::{
};
use url::Url;
+mod tls;
+
#[test]
fn websocket_slot_limit_blocks_until_permit_is_dropped() {
let slots = Arc::new(Semaphore::new(1));
@@ -1050,7 +1052,7 @@ async fn websocket_transport_respects_disabled_tls_verify_for_self_signed_wss()
let (url, headers_rx, server) = spawn_tls_header_capture_websocket_server().await;
let (event_tx, mut event_rx) = mpsc::channel(32);
let mut context = test_websocket_context();
- context.tls_verify_host = false;
+ context.tls.verify = false;
let command_tx = spawn_connection(3, url, Vec::new(), context, event_tx);
let headers = timeout(Duration::from_secs(3), headers_rx)
@@ -1078,7 +1080,7 @@ async fn websocket_transport_wss_allows_server_to_omit_response_subprotocol() {
let (url, headers_rx, server) = spawn_tls_header_capture_websocket_server().await;
let (event_tx, mut event_rx) = mpsc::channel(32);
let mut context = test_websocket_context();
- context.tls_verify_host = false;
+ context.tls.verify = false;
let _command_tx = spawn_connection(
4,
diff --git a/moli-websocket/src/tests/tls.rs b/moli-websocket/src/tests/tls.rs
new file mode 100644
index 000000000..522c241d3
--- /dev/null
+++ b/moli-websocket/src/tests/tls.rs
@@ -0,0 +1,195 @@
+use super::*;
+use moli_curl::CurlTlsConfig;
+
+fn tls_context(tls: CurlTlsConfig) -> ConnectOptions {
+ ConnectOptions {
+ tls,
+ http_proxy: Some(String::new()),
+ http_no_proxy: Some(String::new()),
+ ..test_websocket_context()
+ }
+}
+
+async fn exercise_tls_connection(url: String, context: ConnectOptions, opens: bool) {
+ let (events, mut receiver) = mpsc::channel(32);
+ let connection = spawn_connection(501, url, Vec::new(), context, events);
+ if !opens {
+ assert!(
+ !recv_handshake_failure_events(&mut receiver)
+ .await
+ .is_empty()
+ );
+ return;
+ }
+ recv_open_event(&mut receiver).await;
+ connection
+ .send(Command::SendText("TLS echo".to_owned()))
+ .unwrap();
+ let mut echoed = false;
+ loop {
+ match timeout(Duration::from_secs(5), receiver.recv())
+ .await
+ .unwrap()
+ .unwrap()
+ {
+ Event::TextMessage { data, .. } => {
+ assert_eq!(data, "TLS echo");
+ echoed = true;
+ connection
+ .send(Command::Close {
+ code: Some(1000),
+ reason: "done".to_owned(),
+ })
+ .unwrap();
+ }
+ Event::Close {
+ code, was_clean, ..
+ } => {
+ assert!(echoed);
+ assert_eq!(code, 1000);
+ assert!(was_clean);
+ break;
+ }
+ Event::Error { message, .. } => panic!("TLS connection failed: {message}"),
+ _ => {}
+ }
+ }
+}
+
+#[tokio::test]
+async fn websocket_tls_custom_ca_preserves_chain_and_hostname_verification() {
+ let fixture = TlsWebSocketFixture::new();
+ let unrelated = TlsWebSocketFixture::new();
+ for (name, ca, mismatch, opens) in [
+ ("trusted", fixture.tls_config().ca_cert, false, true),
+ ("missing CA", None, false, false),
+ ("wrong CA", unrelated.tls_config().ca_cert, false, false),
+ ("wrong hostname", fixture.tls_config().ca_cert, true, false),
+ ] {
+ let tls = CurlTlsConfig {
+ ca_cert: ca,
+ ..CurlTlsConfig::default()
+ };
+ let (mut url, server) = fixture.spawn(false).await;
+ if mismatch {
+ url = url.replace("localhost", "127.0.0.1");
+ }
+ exercise_tls_connection(url, tls_context(tls), opens).await;
+ let result = server.await.unwrap();
+ if opens {
+ assert!(
+ result.unwrap().is_empty(),
+ "{name}: no client identity configured"
+ );
+ } else {
+ assert!(result.is_err(), "{name}: untrusted TLS must fail");
+ }
+ }
+}
+
+#[tokio::test]
+async fn websocket_tls_client_identity_supports_certificate_formats_and_passwords() {
+ let fixture = TlsWebSocketFixture::new();
+ let pem = fixture.tls_config();
+ let mut combined = pem.clone();
+ combined
+ .client_cert
+ .as_mut()
+ .unwrap()
+ .set_file_name("client-combined.pem");
+ combined.client_key = None;
+ let mut der = pem.clone();
+ der.client_cert.as_mut().unwrap().set_extension("der");
+ let mut encrypted = pem.clone();
+ encrypted
+ .client_key
+ .as_mut()
+ .unwrap()
+ .set_file_name("client-encrypted-key.pem");
+ let mut pfx = fixture.pkcs12_config();
+ pfx.client_cert.as_mut().unwrap().set_extension("PFX");
+ let mut insecure = pem.clone();
+ insecure.verify = false;
+ insecure.ca_cert = None;
+ for (name, tls) in [
+ ("PEM", pem),
+ ("combined PEM", combined),
+ ("DER", der),
+ ("encrypted PEM key", encrypted),
+ ("P12", fixture.pkcs12_config()),
+ ("PFX", pfx),
+ ("verification disabled", insecure),
+ ] {
+ let (url, server) = fixture.spawn(true).await;
+ exercise_tls_connection(url, tls_context(tls), true).await;
+ assert_eq!(
+ server.await.unwrap().unwrap(),
+ std::slice::from_ref(&fixture.client_certificate),
+ "{name}"
+ );
+ }
+}
+
+#[tokio::test]
+async fn websocket_tls_rejects_missing_wrong_or_locked_client_identity() {
+ let fixture = TlsWebSocketFixture::new();
+ let unrelated = TlsWebSocketFixture::new();
+ let missing = CurlTlsConfig {
+ ca_cert: fixture.tls_config().ca_cert,
+ ..CurlTlsConfig::default()
+ };
+ let mut wrong_identity = unrelated.tls_config();
+ wrong_identity.ca_cert = fixture.tls_config().ca_cert;
+ let mut wrong_key = fixture.tls_config();
+ wrong_key.client_key = unrelated.tls_config().client_key;
+ let mut wrong_password = fixture.pkcs12_config();
+ wrong_password.client_cert_password = Some("incorrect-password".to_owned());
+ let mut missing_password = fixture.pkcs12_config();
+ missing_password.client_cert_password = None;
+ let mut wrong_pem_password = fixture.tls_config();
+ wrong_pem_password
+ .client_key
+ .as_mut()
+ .unwrap()
+ .set_file_name("client-encrypted-key.pem");
+ wrong_pem_password.client_cert_password = Some("incorrect-password".to_owned());
+ for (name, tls) in [
+ ("missing identity", missing),
+ ("wrong identity", wrong_identity),
+ ("mismatched key", wrong_key),
+ ("wrong P12 password", wrong_password),
+ ("missing P12 password", missing_password),
+ ("wrong PEM password", wrong_pem_password),
+ ] {
+ let (url, server) = fixture.spawn(true).await;
+ exercise_tls_connection(url, tls_context(tls), false).await;
+ assert!(
+ server.await.unwrap().is_err(),
+ "{name}: mTLS must not succeed"
+ );
+ }
+}
+
+#[tokio::test]
+async fn websocket_tls_credentials_apply_inside_http_connect_tunnel() {
+ let fixture = TlsWebSocketFixture::new();
+ let (url, server) = fixture.spawn(true).await;
+ let (proxy_url, request, proxy) = spawn_http_connect_proxy().await;
+ let mut context = tls_context(fixture.pkcs12_config());
+ context.http_proxy = Some(proxy_url);
+ exercise_tls_connection(url.clone(), context, true).await;
+ assert_eq!(
+ server.await.unwrap().unwrap(),
+ std::slice::from_ref(&fixture.client_certificate)
+ );
+ let target = Url::parse(&url).unwrap();
+ let request = timeout(Duration::from_secs(5), request)
+ .await
+ .unwrap()
+ .unwrap();
+ assert!(request.starts_with(&format!(
+ "CONNECT localhost:{} HTTP/1.1\r\n",
+ target.port().unwrap()
+ )));
+ proxy.await.unwrap();
+}
diff --git a/moli-websocket/src/transport.rs b/moli-websocket/src/transport.rs
index 9b437d3d2..5548966bf 100644
--- a/moli-websocket/src/transport.rs
+++ b/moli-websocket/src/transport.rs
@@ -32,7 +32,9 @@ pub(crate) async fn open_websocket_stream(
.headers
.retain(|(name, _)| !name.eq_ignore_ascii_case("connection"));
native.proxy = proxy.map(|url| url.to_string());
- native.tls_verify = context.tls_verify_host;
+ // WebSocket opening handshakes use credentials=include, including across
+ // origins: https://websockets.spec.whatwg.org/#opening-handshake
+ native.tls = context.tls.clone();
if native.proxy.is_some() {
let mut validated = String::new();
append_proxy_connect_header(&mut validated, "User-Agent", &context.user_agent)?;
diff --git a/moli-websocket/src/types.rs b/moli-websocket/src/types.rs
index 45fb1a9ad..b76b3fcb6 100644
--- a/moli-websocket/src/types.rs
+++ b/moli-websocket/src/types.rs
@@ -6,7 +6,7 @@ pub struct ConnectOptions {
pub http_proxy: Option<String>,
pub http_no_proxy: Option<String>,
pub proxy_bearer_token: Option<String>,
- pub tls_verify_host: bool,
+ pub tls: moli_curl::CurlTlsConfig,
pub cookie_header: Option<String>,
pub pause_after_handshake: bool,
}