Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(tls): use Apple SecTrust by default on macOS
ldm02d5b88b3dca7
diff --git a/.github/workflows/macos-tls.yml b/.github/workflows/macos-tls.ymlnew file mode 100644index 000000000..37c971026--- /dev/null+++ b/.github/workflows/macos-tls.yml@@ -0,0 +1,41 @@+name: macOS TLS trust++on:+ pull_request:+ paths:+ - Cargo.toml+ - Cargo.lock+ - rust-toolchain+ - moli-curl/**+ - .github/workflows/macos-tls.yml+ workflow_dispatch:++permissions:+ contents: read++concurrency:+ group: macos-tls-${{ github.event.pull_request.number || github.ref }}+ cancel-in-progress: true++jobs:+ sectrust:+ name: SecTrust+ runs-on: macos-latest+ timeout-minutes: 25+ env:+ MACOSX_DEPLOYMENT_TARGET: "13.0"+ CARGO_INCREMENTAL: "0"+ steps:+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2+ with:+ persist-credentials: false+ - name: Install pinned Rust toolchain+ run: |+ toolchain=$(tr -d '[:space:]' < rust-toolchain)+ rustup toolchain install "$toolchain" --profile minimal --component clippy --no-self-update+ - name: Check macOS code+ run: cargo clippy --locked -p moli-curl --all-targets -- -D warnings+ - name: Test HTTP and WebSocket runtime+ run: cargo test --locked -p moli-curl+ - name: Test native trust and explicit CA overrides+ run: cargo test --locked -p moli-curl --test apple_sectrust -- --ignored --nocapturediff --git a/Cargo.lock b/Cargo.lockindex ae13e145f..752f43df3 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -845,7 +845,7 @@ dependencies = [[[package]]name = "curl"version = "0.4.49"-source = "git+https://github.com/lexmount/curl-rust?branch=moli#bcd4d9f9d7dcd4ec68cfa42f80e9e1f872d87229"+source = "git+https://github.com/lexmount/curl-rust?rev=a0ea59f5ca1b1e4bc8627a28c29463ac96aeb758#a0ea59f5ca1b1e4bc8627a28c29463ac96aeb758"dependencies = ["curl-sys","libc",@@ -859,7 +859,7 @@ dependencies = [[[package]]name = "curl-sys"version = "0.4.87+curl-8.19.0"-source = "git+https://github.com/lexmount/curl-rust?branch=moli#bcd4d9f9d7dcd4ec68cfa42f80e9e1f872d87229"+source = "git+https://github.com/lexmount/curl-rust?rev=a0ea59f5ca1b1e4bc8627a28c29463ac96aeb758#a0ea59f5ca1b1e4bc8627a28c29463ac96aeb758"dependencies = ["brotlic-sys","cc",@@ -2597,6 +2597,7 @@ dependencies = ["parking_lot","rcgen","rustls",+ "tempfile","tokio","tokio-tungstenite","tracing",diff --git a/Cargo.toml b/Cargo.tomlindex 3e72a25b6..a6da1555a 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -96,8 +96,8 @@ license = "MIT OR Apache-2.0"[patch.crates-io]xml5ever = { path = "vendor/xml5ever-0.39.0" }-curl = { git = "https://github.com/lexmount/curl-rust", branch = "moli" }-curl-sys = { git = "https://github.com/lexmount/curl-rust", branch = "moli" }+curl = { git = "https://github.com/lexmount/curl-rust", rev = "a0ea59f5ca1b1e4bc8627a28c29463ac96aeb758" }+curl-sys = { git = "https://github.com/lexmount/curl-rust", rev = "a0ea59f5ca1b1e4bc8627a28c29463ac96aeb758" }cookie = { git = "https://github.com/ldm0/cookie-rs", branch = "priority" }v8 = { path = "vendor/v8-152.2.0" }deno_v8 = { path = "vendor/deno_v8-0.3.0" }diff --git a/moli-curl/Cargo.toml b/moli-curl/Cargo.tomlindex b69aab7be..3f02f95d0 100644--- a/moli-curl/Cargo.toml+++ b/moli-curl/Cargo.toml@@ -21,6 +21,7 @@ url = "2.5.7"[dev-dependencies]rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs", "pem"] }rustls = { version = "0.23", default-features = false, features = ["aws_lc_rs", "std", "tls12"] }+tempfile = "3"tokio = { version = "1.51.0", features = ["macros", "rt", "time"] }tokio-tungstenite = { version = "0.28.0", default-features = false, features = ["handshake"] }tracing-subscriber = { version = "0.3.19", features = ["fmt"] }diff --git a/moli-curl/README.md b/moli-curl/README.mdindex f641eb12b..58be8beed 100644--- a/moli-curl/README.md+++ b/moli-curl/README.md@@ -29,6 +29,29 @@ The native owner keeps reads and writes independent and parks I/O after AGAINuntil the corresponding socket is signalled. It shares one spare receive Vec;successful reads transfer that Vec to the event consumer.+## TLS trust++On macOS, HTTPS, WSS, and HTTPS proxy connections use libcurl's Apple SecTrust+integration by default. AWS-LC still handles TLS; SecTrust evaluates certificate+trust through the operating system. The pinned curl-rust build enables this+integration and avoids automatically selecting a CA file or directory, which+would disable libcurl's default SecTrust selection.++An explicit `CurlTlsConfig::ca_cert` (`--ca-cert` in the CLI) takes precedence+over certificate environment variables. Otherwise, `SSL_CERT_FILE` and+`SSL_CERT_DIR` select file-based verification for both origins and HTTPS proxies.+These explicit sources use the existing TLS backend's verifier, without adding+the system trust store. Certificate-chain and hostname verification remain+enabled by default. Other platforms retain their existing trust configuration.++The `macOS TLS trust` workflow builds the AWS-LC/SecTrust combination on+`macos-latest`. Its `apple_sectrust` integration test covers HTTPS, WSS,+HTTPS proxy verification, rejected chains and hostnames, and CA file/directory+overrides. It checks libcurl's verifier diagnostics during real local handshakes.+The test is ignored in normal runs because it installs a temporary keychain and+administrator trust setting; it is restricted to ephemeral macOS CI runners and+cleans up the trust setting and keychain afterward.+## Enable countersSet `MOLI_CURL_WEBSOCKET_DIAGNOSTICS=1` before creating the runtime and enablediff --git a/moli-curl/src/tls.rs b/moli-curl/src/tls.rsindex 92bf4e85f..f9e2bfeec 100644--- a/moli-curl/src/tls.rs+++ b/moli-curl/src/tls.rs@@ -64,6 +64,12 @@ impl CurlTlsConfig {)})?;}+ #[cfg(target_os = "macos")]+ if self.ca_cert.is_some() {+ // An explicit CA file overrides SSL_CERT_DIR as well as+ // SSL_CERT_FILE, which curl-rust applies to a fresh handle.+ clear_ca_directory(easy, curl_sys::CURLOPT_CAPATH)?;+ }if include_client_identity {if let Some(client_cert) = &self.client_cert {easy.ssl_cert(client_cert).with_context(|| {@@ -127,10 +133,40 @@ impl CurlTlsConfig {)})?;}+ #[cfg(target_os = "macos")]+ if self.ca_cert.is_some() {+ clear_ca_directory(easy, curl_sys::CURLOPT_PROXY_CAPATH)?;+ } else if self.verify {+ // curl-rust applies explicit certificate environment variables to+ // the origin. Moli shares these sources with HTTPS proxies too.+ // Leave every CA option untouched when no override was supplied:+ // libcurl then selects its built-in Apple SecTrust verifier.+ if let Some(file) = std::env::var_os("SSL_CERT_FILE") {+ easy.proxy_cainfo(file.to_str().context("SSL_CERT_FILE is not valid UTF-8")?)+ .context("failed to configure HTTPS proxy SSL_CERT_FILE")?;+ }+ if let Some(directory) = std::env::var_os("SSL_CERT_DIR") {+ easy.proxy_capath(std::path::Path::new(&directory))+ .context("failed to configure HTTPS proxy SSL_CERT_DIR")?;+ }+ }Ok(())}}+#[cfg(target_os = "macos")]+fn clear_ca_directory<H: Handler>(easy: &mut Easy2<H>, option: curl_sys::CURLoption) -> Result<()> {+ // SAFETY: the caller supplies a CA directory string option, `easy` is+ // exclusively borrowed, and libcurl accepts NULL to clear this setting.+ let result = unsafe {+ curl_sys::curl_easy_setopt(easy.raw(), option, std::ptr::null::<std::ffi::c_char>())+ };+ if result != curl_sys::CURLE_OK {+ return Err(curl::Error::new(result)).context("failed to clear curl CA directory override");+ }+ Ok(())+}+#[cfg(test)]mod tests {use super::*;diff --git a/moli-curl/tests/apple_sectrust.rs b/moli-curl/tests/apple_sectrust.rsnew file mode 100644index 000000000..ec56fee3a--- /dev/null+++ b/moli-curl/tests/apple_sectrust.rs@@ -0,0 +1,507 @@+//! Real macOS trust evaluation. Run only on an ephemeral GitHub Actions runner:+//! this test installs a temporary keychain and administrator trust setting.++use std::{+ fs,+ io::{self, Read, Seek, Write},+ net::{TcpListener, TcpStream},+ path::{Path, PathBuf},+ process::{Command, Output},+ sync::Arc,+ thread,+ time::{Duration, Instant, SystemTime},+};++use curl::easy::{Easy2, Handler, InfoType, List, WriteError};+use moli_curl::CurlTlsConfig;+use rcgen::{BasicConstraints, CertificateParams, DnType, IsCa, KeyPair, KeyUsagePurpose};+use rustls::{+ ServerConfig, ServerConnection, StreamOwned,+ pki_types::{CertificateDer, PrivatePkcs8KeyDer},+};++const DEADLINE: Duration = Duration::from_secs(10);+const COMMAND_DEADLINE: Duration = Duration::from_secs(15);++#[test]+#[ignore = "requires an ephemeral macOS GitHub Actions runner and modifies its trust settings"]+fn apple_sectrust() {+ assert_eq!(std::env::consts::OS, "macos");+ assert_eq!(std::env::var("GITHUB_ACTIONS").as_deref(), Ok("true"));+ if let Ok(case) = std::env::var("MOLI_SECTRUST_CASE") {+ run_case(+ &case,+ &PathBuf::from(std::env::var_os("MOLI_SECTRUST_FIXTURES").unwrap()),+ );+ return;+ }++ let fixtures = tempfile::tempdir().unwrap();+ for name in ["trusted", "untrusted"] {+ generate_certificates(fixtures.path(), name);+ create_ca_directory(fixtures.path(), name);+ }+ let _keychain = Keychain::install(fixtures.path());++ // Separate processes keep certificate environment variables isolated from+ // other tests and exercise the binding's fresh-handle initialization.+ for route in ["origin", "proxy", "wss"] {+ for policy in [+ "native",+ "untrusted",+ "hostname",+ "ca",+ "ca-untrusted",+ "env-file",+ "env-file-untrusted",+ "env-dir",+ "env-dir-untrusted",+ "ca-over-env",+ "ca-untrusted-over-env",+ "insecure",+ ] {+ let case = format!("{route}/{policy}");+ let mut command = Command::new(std::env::current_exe().unwrap());+ command+ .args(["--ignored", "--exact", "apple_sectrust", "--nocapture"])+ .env("MOLI_SECTRUST_CASE", &case)+ .env("MOLI_SECTRUST_FIXTURES", fixtures.path())+ .env_remove("SSL_CERT_FILE")+ .env_remove("SSL_CERT_DIR");+ match policy {+ "env-file" | "env-file-untrusted" => {+ let ca = if policy == "env-file" {+ "trusted"+ } else {+ "untrusted"+ };+ command.env("SSL_CERT_FILE", fixtures.path().join(format!("{ca}.pem")));+ }+ "env-dir" | "env-dir-untrusted" => {+ let ca = if policy == "env-dir" {+ "trusted"+ } else {+ "untrusted"+ };+ command.env("SSL_CERT_DIR", fixtures.path().join(ca));+ }+ "ca-over-env" | "ca-untrusted-over-env" => {+ command.env("SSL_CERT_FILE", fixtures.path().join("untrusted.pem"));+ // If CAPATH leaks through the explicit CA override, the+ // negative case would unexpectedly trust this certificate.+ command.env("SSL_CERT_DIR", fixtures.path().join("trusted"));+ }+ _ => {}+ }+ let output = command_output(&mut command, COMMAND_DEADLINE).unwrap();+ assert!(+ output.status.success(),+ "{case}:\n{}\n{}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ println!("passed {case}");+ }+ }+}++fn generate_certificates(directory: &Path, name: &str) -> CertificateDer<'static> {+ let mut params = CertificateParams::new(Vec::<String>::new()).unwrap();+ params+ .distinguished_name+ .push(DnType::CommonName, format!("Moli {name} test CA"));+ params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);+ params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign];+ let root_key = KeyPair::generate().unwrap();+ let root = params.self_signed(&root_key).unwrap();+ let root_path = directory.join(format!("{name}.pem"));+ fs::write(&root_path, root.pem()).unwrap();++ let mut params = CertificateParams::new(vec!["fixture.test".to_owned()]).unwrap();+ params+ .distinguished_name+ .push(DnType::CommonName, "fixture.test");+ params.use_authority_key_identifier_extension = true;+ params.not_before = (SystemTime::now() - Duration::from_secs(86400)).into();+ params.not_after = (SystemTime::now() + Duration::from_secs(86400)).into();+ params.extended_key_usages = vec![rcgen::ExtendedKeyUsagePurpose::ServerAuth];+ let key = KeyPair::generate().unwrap();+ let certificate = params.signed_by(&key, &root, &root_key).unwrap();+ fs::write(directory.join(format!("{name}.der")), certificate.der()).unwrap();+ fs::write(directory.join(format!("{name}.key")), key.serialize_der()).unwrap();+ root.der().clone()+}++fn create_ca_directory(directory: &Path, name: &str) {+ let root_path = directory.join(format!("{name}.pem"));+ let hash = command_output(+ Command::new("openssl")+ .args(["x509", "-hash", "-noout", "-in"])+ .arg(&root_path),+ COMMAND_DEADLINE,+ )+ .unwrap();+ assert!(hash.status.success());+ let ca_directory = directory.join(name);+ fs::create_dir(&ca_directory).unwrap();+ fs::copy(+ root_path,+ ca_directory.join(format!(+ "{}.0",+ String::from_utf8(hash.stdout).unwrap().trim()+ )),+ )+ .unwrap();+}++struct Keychain {+ path: PathBuf,+ root: PathBuf,+ previous: Vec<String>,+}++impl Keychain {+ fn install(directory: &Path) -> Self {+ let previous = security(&["list-keychains", "-d", "user"]);+ let keychain = Self {+ path: directory.join("test.keychain-db"),+ root: directory.join("trusted.pem"),+ previous: previous+ .lines()+ .map(|line| line.trim().trim_matches('"').to_owned())+ .collect(),+ };+ let path = keychain.path.to_str().unwrap();+ security(&["create-keychain", "-p", "moli-test", path]);+ security(&["unlock-keychain", "-p", "moli-test", path]);+ let mut search_list = vec!["list-keychains", "-d", "user", "-s"];+ search_list.extend(keychain.previous.iter().map(String::as_str));+ search_list.push(path);+ security(&search_list);+ let output = command_output(+ Command::new("sudo")+ .args([+ "-n",+ "security",+ "add-trusted-cert",+ "-d",+ "-r",+ "trustRoot",+ "-p",+ "ssl",+ "-k",+ path,+ ])+ .arg(&keychain.root),+ COMMAND_DEADLINE,+ )+ .unwrap();+ assert!(+ output.status.success(),+ "{}",+ String::from_utf8_lossy(&output.stderr)+ );+ keychain+ }+}++impl Drop for Keychain {+ fn drop(&mut self) {+ cleanup(+ Command::new("sudo")+ .args(["-n", "security", "remove-trusted-cert", "-d"])+ .arg(&self.root),+ );+ cleanup(+ Command::new("security")+ .args(["list-keychains", "-d", "user", "-s"])+ .args(&self.previous),+ );+ cleanup(+ Command::new("security")+ .arg("delete-keychain")+ .arg(&self.path),+ );+ }+}++fn security(arguments: &[&str]) -> String {+ let output =+ command_output(Command::new("security").args(arguments), COMMAND_DEADLINE).unwrap();+ assert!(+ output.status.success(),+ "security {arguments:?}: {}",+ String::from_utf8_lossy(&output.stderr)+ );+ String::from_utf8(output.stdout).unwrap()+}++fn cleanup(command: &mut Command) {+ match command_output(command, COMMAND_DEADLINE) {+ Ok(output) if output.status.success() => {}+ Ok(output) => eprintln!(+ "cleanup {command:?}: {}",+ String::from_utf8_lossy(&output.stderr)+ ),+ Err(error) => eprintln!("cleanup {command:?}: {error}"),+ }+}++fn command_output(command: &mut Command, deadline: Duration) -> io::Result<Output> {+ // Files keep verbose child output from blocking on a full pipe while the+ // parent enforces the deadline, including during panic cleanup.+ let mut stdout = tempfile::tempfile()?;+ let mut stderr = tempfile::tempfile()?;+ command+ .stdout(stdout.try_clone()?)+ .stderr(stderr.try_clone()?);+ let mut child = command.spawn()?;+ let start = Instant::now();+ let status = loop {+ if let Some(status) = child.try_wait()? {+ break status;+ }+ if start.elapsed() >= deadline {+ if let Err(error) = child.kill() {+ // `sudo security` runs as root; the runner user cannot kill it+ // directly. Restrict escalation to this still-owned child PID.+ if error.kind() != io::ErrorKind::PermissionDenied+ || !Command::new("sudo")+ .args(["-n", "/bin/kill", "-KILL", &child.id().to_string()])+ .status()?+ .success()+ {+ return Err(error);+ }+ }+ child.wait()?;+ return Err(io::Error::new(+ io::ErrorKind::TimedOut,+ format!("{command:?} exceeded {deadline:?}"),+ ));+ }+ thread::sleep(Duration::from_millis(10));+ };+ stdout.rewind()?;+ stderr.rewind()?;+ let mut output = Output {+ status,+ stdout: Vec::new(),+ stderr: Vec::new(),+ };+ stdout.read_to_end(&mut output.stdout)?;+ stderr.read_to_end(&mut output.stderr)?;+ Ok(output)+}++#[derive(Default)]+struct Response {+ body: Vec<u8>,+ debug: String,+}++impl Handler for Response {+ fn write(&mut self, data: &[u8]) -> Result<usize, WriteError> {+ self.body.extend_from_slice(data);+ Ok(data.len())+ }++ fn debug(&mut self, kind: InfoType, data: &[u8]) {+ if matches!(kind, InfoType::Text) {+ self.debug.push_str(&String::from_utf8_lossy(data));+ }+ }+}++fn run_case(case: &str, directory: &Path) {+ let (route, policy) = case.split_once('/').unwrap();+ let certificate = if matches!(policy, "untrusted" | "insecure") {+ "untrusted"+ } else {+ "trusted"+ };+ let (port, server) = server(directory, certificate, route == "wss");+ let host = if policy == "hostname" {+ "wrong.test"+ } else {+ "fixture.test"+ };+ let mut easy = Easy2::new(Response::default());+ easy.timeout(DEADLINE).unwrap();+ easy.verbose(true).unwrap();+ easy.noproxy("").unwrap();+ let mut resolve = List::new();+ resolve.append(&format!("{host}:{port}:127.0.0.1")).unwrap();+ easy.resolve(resolve).unwrap();+ let mut tls = CurlTlsConfig {+ verify: policy != "insecure",+ ..Default::default()+ };+ if policy.starts_with("ca") {+ let ca = if policy.starts_with("ca-untrusted") {+ "untrusted"+ } else {+ "trusted"+ };+ tls.ca_cert = Some(directory.join(format!("{ca}.pem")));+ }+ if route == "proxy" {+ easy.url("http://target.invalid/resource").unwrap();+ easy.proxy(&format!("https://{host}:{port}")).unwrap();+ tls.configure_https_proxy(&mut easy).unwrap();+ } else {+ let scheme = if route == "wss" { "wss" } else { "https" };+ easy.url(&format!("{scheme}://{host}:{port}/resource"))+ .unwrap();+ easy.proxy("").unwrap();+ tls.configure(&mut easy, false).unwrap();+ if route == "wss" {+ easy.ws_connect_only(true).unwrap();+ }+ }+ let result = easy.perform();+ let Response { body, debug } = std::mem::take(easy.get_mut());+ drop(easy);+ let server_result = server.join().expect("TLS fixture panicked");+ if let Err(error) = &server_result {+ eprintln!("{case}: TLS fixture: {error}");+ }+ let failure = policy.contains("untrusted") || policy == "hostname";+ if failure {+ assert_eq!(result.unwrap_err().code(), 60, "{case}: {debug}");+ } else {+ result.unwrap_or_else(|error| panic!("{case}: {error}: {debug}"));+ server_result.unwrap();+ if route != "wss" {+ assert_eq!(body, b"ok");+ }+ if policy != "insecure" {+ let verifier = if policy == "native" {+ "Apple SecTrust"+ } else {+ "OpenSSL"+ };+ assert!(+ debug.contains(&format!("SSL certificate verified via {verifier}.")),+ "{case}: {debug}"+ );+ }+ }+}++fn server_config(directory: &Path, certificate: &str) -> ServerConfig {+ let certificate_der = fs::read(directory.join(format!("{certificate}.der")))+ .unwrap()+ .into();+ let key =+ PrivatePkcs8KeyDer::from(fs::read(directory.join(format!("{certificate}.key"))).unwrap());+ ServerConfig::builder()+ .with_no_client_auth()+ .with_single_cert(vec![certificate_der], key.into())+ .unwrap()+}++fn server(+ directory: &Path,+ certificate: &str,+ websocket: bool,+) -> (u16, thread::JoinHandle<io::Result<()>>) {+ let config = server_config(directory, certificate);+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ listener.set_nonblocking(true).unwrap();+ let task = thread::spawn(move || {+ let start = Instant::now();+ let stream = loop {+ match listener.accept() {+ Ok((stream, _)) => break stream,+ Err(error)+ if error.kind() == std::io::ErrorKind::WouldBlock+ && start.elapsed() < DEADLINE =>+ {+ thread::sleep(Duration::from_millis(10))+ }+ Err(error) => panic!("TLS fixture accept: {error}"),+ }+ };+ serve_connection(stream, config, websocket)+ });+ (port, task)+}++fn serve_connection(stream: TcpStream, config: ServerConfig, websocket: bool) -> io::Result<()> {+ // Darwin can inherit O_NONBLOCK from the listener. StreamOwned and the+ // synchronous WebSocket handshake need blocking I/O on the accepted socket.+ stream.set_nonblocking(false)?;+ stream.set_read_timeout(Some(DEADLINE))?;+ stream.set_write_timeout(Some(DEADLINE))?;+ let mut tls = StreamOwned::new(ServerConnection::new(Arc::new(config)).unwrap(), stream);+ if websocket {+ let mut socket = tokio_tungstenite::tungstenite::accept(tls)+ .map_err(|error| io::Error::other(error.to_string()))?;+ let _ = socket.close(None);+ return Ok(());+ }+ let mut request = Vec::new();+ let mut byte = [0];+ while request.len() < 16 * 1024 && !request.ends_with(b"\r\n\r\n") {+ tls.read_exact(&mut byte)?;+ request.push(byte[0]);+ }+ tls.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")+}++#[test]+fn fixture_completes_tls_on_an_initially_nonblocking_socket() {+ use rustls::{ClientConfig, ClientConnection, RootCertStore};++ let fixtures = tempfile::tempdir().unwrap();+ let root = generate_certificates(fixtures.path(), "trusted");+ let mut roots = RootCertStore::empty();+ roots.add(root).unwrap();+ let client_config = ClientConfig::builder()+ .with_root_certificates(roots)+ .with_no_client_auth();+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let client = TcpStream::connect(listener.local_addr().unwrap()).unwrap();+ client.set_read_timeout(Some(DEADLINE)).unwrap();+ client.set_write_timeout(Some(DEADLINE)).unwrap();+ let (accepted, _) = listener.accept().unwrap();+ accepted.set_nonblocking(true).unwrap();+ let server_config = server_config(fixtures.path(), "trusted");+ let server = thread::spawn(move || serve_connection(accepted, server_config, false));+ // The fixture must wait for ClientHello rather than treating WouldBlock as+ // rejection and closing the connection before the client starts TLS.+ thread::sleep(Duration::from_millis(50));+ let mut tls = StreamOwned::new(+ ClientConnection::new(Arc::new(client_config), "fixture.test".try_into().unwrap()).unwrap(),+ client,+ );+ tls.write_all(b"GET / HTTP/1.1\r\nHost: fixture.test\r\n\r\n")+ .unwrap();+ let expected = b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok";+ let mut response = vec![0; expected.len()];+ tls.read_exact(&mut response).unwrap();+ assert_eq!(response, expected);+ server.join().unwrap().unwrap();+}++#[test]+fn fixture_certificates_work_with_explicit_ca_files() {+ let fixtures = tempfile::tempdir().unwrap();+ generate_certificates(fixtures.path(), "trusted");+ generate_certificates(fixtures.path(), "untrusted");+ for route in ["origin", "wss", "proxy"] {+ for policy in ["ca", "ca-untrusted"] {+ run_case(&format!("{route}/{policy}"), fixtures.path());+ }+ }+}++#[cfg(unix)]+#[test]+fn command_deadline_terminates_a_stalled_process() {+ let error =+ command_output(Command::new("sleep").arg("30"), Duration::from_millis(50)).unwrap_err();+ assert_eq!(error.kind(), io::ErrorKind::TimedOut);+}