Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(websocket): inherit browser TLS credentials
ldm07ed1ce8a9314
diff --git a/Cargo.lock b/Cargo.lockindex 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.rsindex 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.rsindex 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<Handshakeasy.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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.tomlindex 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 = truediff --git a/moli-websocket/src/test_support.rs b/moli-websocket/src/test_support.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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,}