From 5dfc570732e6a0f47e5346a4bf5c91bc1c197419 Mon Sep 17 00:00:00 2001 From: peg Date: Thu, 29 Oct 2026 09:12:48 +0100 Subject: [PATCH 1/4] Use Unix sockets for the attestation provider --- Cargo.lock | 21 +- crates/attestation-provider-server/Cargo.toml | 14 +- crates/attestation-provider-server/README.md | 10 + crates/attestation-provider-server/src/lib.rs | 396 ++++++++++++++---- .../attestation-provider-server/src/main.rs | 53 ++- crates/attestation/Cargo.toml | 1 + crates/attestation/README.md | 9 +- crates/attestation/src/lib.rs | 108 +---- crates/attestation/src/provider.rs | 113 +++++ readme.md | 2 +- 10 files changed, 520 insertions(+), 207 deletions(-) create mode 100644 crates/attestation-provider-server/README.md create mode 100644 crates/attestation/src/provider.rs diff --git a/Cargo.lock b/Cargo.lock index 368589b0..4b74bcc1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -406,6 +406,7 @@ dependencies = [ "serde", "serde-saphyr", "serde_json", + "socket2 0.6.3", "tdx-attest 0.6.0", "tempfile", "thiserror 2.0.18", @@ -422,13 +423,10 @@ version = "0.1.0" dependencies = [ "anyhow", "attestation", - "axum", "clap", - "hex", - "parity-scale-codec", - "reqwest 0.13.4", + "nix 0.26.4", "rustls", - "thiserror 2.0.18", + "tempfile", "tokio", "tracing", "tracing-subscriber", @@ -3180,6 +3178,17 @@ dependencies = [ "tracing", ] +[[package]] +name = "nix" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b" +dependencies = [ + "bitflags 1.3.2", + "cfg-if", + "libc", +] + [[package]] name = "nix" version = "0.31.2" @@ -5637,7 +5646,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ba782755fc073877e567c2253c0be48e4aa9a254c232d36d3985dfae0bd5205" dependencies = [ "libc", - "nix", + "nix 0.31.2", ] [[package]] diff --git a/crates/attestation-provider-server/Cargo.toml b/crates/attestation-provider-server/Cargo.toml index ca72e80c..3ae5101b 100644 --- a/crates/attestation-provider-server/Cargo.toml +++ b/crates/attestation-provider-server/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "attestation-provider-server" -description = "An HTTP server which provides attestations" +description = "A Unix socket server which provides attestations" version = "0.1.0" edition = "2024" license = "MIT" @@ -12,15 +12,15 @@ workspace = true [dependencies] attestation = { workspace = true } -tokio = { workspace = true } +tokio = { workspace = true, features = ["net", "io-util", "signal", "macros", "rt-multi-thread"] } rustls = { workspace = true, default-features = false, features = ["aws_lc_rs"] } -axum = "0.8.6" clap = { version = "4.5.51", features = ["derive", "env"] } anyhow = "1.0.100" -hex = "0.4.3" tracing = "0.1.41" tracing-subscriber = { version = "0.3.20", features = ["env-filter", "json"] } -parity-scale-codec = "3.7.5" -reqwest = { workspace = true } -thiserror = "2.0.17" + +nix = { version = "=0.26.4", default-features = false, features = ["user"] } + +[dev-dependencies] +tempfile = "3.23.0" diff --git a/crates/attestation-provider-server/README.md b/crates/attestation-provider-server/README.md new file mode 100644 index 00000000..65da6990 --- /dev/null +++ b/crates/attestation-provider-server/README.md @@ -0,0 +1,10 @@ +# Attestation provider service + +Generates quotes and collects platform metadata in a privileged process so +applications can request attestations through a Unix socket without those +privileges. + +Use `--socket-path` and provision its parent directory with the application's +access group and mode `2750`. + +The service creates the socket with mode `0660`. diff --git a/crates/attestation-provider-server/src/lib.rs b/crates/attestation-provider-server/src/lib.rs index 44e1c5e2..a1954cdf 100644 --- a/crates/attestation-provider-server/src/lib.rs +++ b/crates/attestation-provider-server/src/lib.rs @@ -1,114 +1,346 @@ -use std::{net::SocketAddr, time::Duration}; +//! Attestation generation through a group-accessible filesystem Unix +//! socket. +use std::{ + os::unix::fs::{MetadataExt, PermissionsExt}, + path::{Path, PathBuf}, + time::Duration, +}; pub use attestation::AttestationGenerator; -use attestation::{AttestationError, AttestationExchangeMessage, AttestationVerifier}; -use axum::{ - extract::{Path, State}, - http::StatusCode, - response::{IntoResponse, Response}, +use attestation::{ + AttestationExchangeMessage, + AttestationVerifier, + Encode, + provider::{MAX_RESPONSE_SIZE, ProviderError, ProviderResponse}, +}; +use tokio::{ + io::{AsyncReadExt, AsyncWriteExt}, + net::{UnixListener, UnixSocket, UnixStream}, + time::timeout, }; -use parity_scale_codec::{Decode, Encode}; -use tokio::net::TcpListener; -#[derive(Clone)] -struct SharedState { - attestation_generator: AttestationGenerator, +/// The underlying unix socket for the service +pub struct ProviderSocket { + pub listener: UnixListener, + path: PathBuf, + device: u64, + inode: u64, +} + +impl ProviderSocket { + /// Existing paths are never removed at startup. + pub fn bind(path: &Path) -> anyhow::Result { + anyhow::ensure!(path.is_absolute(), "Expected an absolute socket path"); + let parent = std::fs::symlink_metadata( + path.parent().ok_or_else(|| anyhow::anyhow!("Missing parent"))?, + )?; + let uid = nix::unistd::geteuid().as_raw(); + anyhow::ensure!( + parent.is_dir() && + (parent.uid() == 0 || parent.uid() == uid) && + parent.mode() & 0o022 == 0, + "Socket parent must be service/root-owned and not group/other writable" + ); + let socket = UnixSocket::new_stream()?; + socket.bind(path)?; + let metadata = std::fs::symlink_metadata(path)?; + // Establish the cleanup guard before any subsequent fallible + // operation. + let mut cleanup = SocketCleanup { + path: path.into(), + device: metadata.dev(), + inode: metadata.ino(), + armed: true, + }; + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o660))?; + let listener = socket.listen(128)?; + let result = Self { + listener, + path: cleanup.path.clone(), + device: cleanup.device, + inode: cleanup.inode, + }; + cleanup.armed = false; + Ok(result) + } +} + +struct SocketCleanup { + path: PathBuf, + device: u64, + inode: u64, + armed: bool, +} + +fn cleanup(path: &Path, device: u64, inode: u64) { + if let Ok(metadata) = std::fs::symlink_metadata(path) && + metadata.dev() == device && + metadata.ino() == inode + { + let _ = std::fs::remove_file(path); + } +} + +impl Drop for SocketCleanup { + fn drop(&mut self) { + if self.armed { + cleanup(&self.path, self.device, self.inode); + } + } +} + +impl Drop for ProviderSocket { + fn drop(&mut self) { + cleanup(&self.path, self.device, self.inode); + } } -/// An HTTP server which provides attestations +/// Serve an already-bound listener. The caller controls permissions and +/// path cleanup. pub async fn attestation_provider_server( - listener: TcpListener, - attestation_generator: AttestationGenerator, + listener: UnixListener, + generator: AttestationGenerator, ) -> anyhow::Result<()> { - let app = axum::Router::new() - .route("/attest/{input_data}", axum::routing::get(get_attest)) - .with_state(SharedState { attestation_generator }); + loop { + let (stream, _) = listener.accept().await?; + let generator = generator.clone(); + tokio::spawn(async move { + if let Err(error) = serve_connection(stream, generator).await { + tracing::debug!(%error, "Provider connection failed"); + } + }); + } +} - axum::serve(listener, app).await?; +async fn serve_connection( + mut stream: UnixStream, + generator: AttestationGenerator, +) -> anyhow::Result<()> { + let request = timeout(Duration::from_secs(1), async { + let mut input = [0; 64]; + stream.read_exact(&mut input).await?; + if stream.read(&mut [0]).await? != 0 { + return Err(std::io::ErrorKind::InvalidData.into()); + } + Ok::<_, std::io::Error>(input) + }) + .await?; - Ok(()) -} + let result: ProviderResponse = match request { + Err(_) => Err(ProviderError::InvalidRequest), + Ok(input) => generator.generate_attestation(input).map_err(|error| { + tracing::error!(%error, "Attestation generation failed"); + ProviderError::GenerationFailed + }), + }; -/// Handler for the GET `/attest/{input_data}` route -/// Input data should be 64 bytes hex -async fn get_attest( - State(shared_state): State, - Path(input_data): Path, -) -> Result<(StatusCode, Vec), ServerError> { - let input_data: [u8; 64] = - hex::decode(input_data)?.try_into().map_err(|_| ServerError::InvalidLength)?; + let mut body = result.encode(); + if body.len() > MAX_RESPONSE_SIZE { + tracing::error!("Generated evidence exceeds provider size limit"); + body = ProviderResponse::Err(ProviderError::GenerationFailed).encode(); + } - let attestation = shared_state.attestation_generator.generate_attestation(input_data)?.encode(); + timeout(Duration::from_secs(1), async { + stream.write_all(&(body.len() as u32).to_be_bytes()).await?; + stream.write_all(&body).await?; + stream.shutdown().await + }) + .await??; - Ok((StatusCode::OK, attestation)) + Ok(()) } -/// A client helper which makes a request to `/attest` +/// Request evidence and verify it using the supplied policy. pub async fn attestation_provider_client( - server_addr: SocketAddr, - attestation_verifier: AttestationVerifier, + path: PathBuf, + verifier: AttestationVerifier, ) -> anyhow::Result { let _ = rustls::crypto::aws_lc_rs::default_provider().install_default(); + let message = tokio::task::spawn_blocking(move || { + attestation::provider::request_attestation(&path, [0; 64]) + }) + .await??; + verifier.verify_attestation(message.clone(), [0; 64]).await?; + Ok(message) +} - let input_data = [0; 64]; - let response = reqwest::Client::builder() - .timeout(Duration::from_secs(1)) - .build()? - .get(format!("http://{server_addr}/attest/{}", hex::encode(input_data))) - .send() - .await? - .bytes() - .await?; - - let remote_attestation_message = AttestationExchangeMessage::decode(&mut &response[..])?; - let remote_attestation_type = remote_attestation_message.attestation_type(); +#[cfg(test)] +mod tests { + use attestation::{AttestationType, Decode, provider::request_attestation}; - println!("Remote attestation type: {remote_attestation_type}"); + use super::*; - attestation_verifier.verify_attestation(remote_attestation_message.clone(), input_data).await?; + #[tokio::test] + async fn unix_generator_round_trip_and_lifecycle() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("provider.sock"); + std::fs::set_permissions(dir.path(), std::fs::Permissions::from_mode(0o2750)).unwrap(); + let socket = ProviderSocket::bind(&path).unwrap(); + let metadata = std::fs::metadata(&path).unwrap(); + assert_eq!(metadata.mode() & 0o777, 0o660); + assert_eq!(metadata.gid(), std::fs::metadata(dir.path()).unwrap().gid()); + assert!(ProviderSocket::bind(&path).is_err()); + let client_path = path.clone(); + let client = tokio::task::spawn_blocking(move || { + let generator = + AttestationGenerator::new(AttestationType::DcapTdx, Some(client_path)).unwrap(); + generator.generate_attestation([42; 64]).unwrap() + }); + let (stream, _) = socket.listener.accept().await.unwrap(); + serve_connection(stream, AttestationGenerator::with_no_attestation()).await.unwrap(); + assert!(client.await.unwrap().attestation_evidence.is_none()); + drop(socket); + assert!(!path.exists()); + } - Ok(remote_attestation_message) -} + #[tokio::test] + async fn invalid_requests_never_generate() { + for input in [vec![1; 63], vec![1; 65]] { + let (mut client, server) = UnixStream::pair().unwrap(); + let worker = + tokio::spawn(serve_connection(server, AttestationGenerator::with_no_attestation())); + client.write_all(&input).await.unwrap(); + client.shutdown().await.unwrap(); + let len = client.read_u32().await.unwrap(); + let mut body = vec![0; len as usize]; + client.read_exact(&mut body).await.unwrap(); + assert!(matches!( + ProviderResponse::decode(&mut &body[..]).unwrap(), + Err(ProviderError::InvalidRequest) + )); + worker.await.unwrap().unwrap(); + } + } -#[derive(Debug, thiserror::Error)] -enum ServerError { - #[error(transparent)] - InvalidHex(#[from] hex::FromHexError), - #[error("Input data must be 64 bytes")] - InvalidLength, - #[error(transparent)] - AttestationFailed(#[from] AttestationError), -} + #[tokio::test] + async fn rejects_unsafe_parent_and_preserves_replacement() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("provider.sock"); + std::fs::set_permissions(dir.path(), std::fs::Permissions::from_mode(0o770)).unwrap(); + assert!(ProviderSocket::bind(&path).is_err()); + std::fs::set_permissions(dir.path(), std::fs::Permissions::from_mode(0o700)).unwrap(); + std::fs::write(&path, b"keep").unwrap(); + assert!(ProviderSocket::bind(&path).is_err()); + assert_eq!(std::fs::read(&path).unwrap(), b"keep"); + std::fs::remove_file(&path).unwrap(); + let target = dir.path().join("target"); + std::fs::write(&target, b"target").unwrap(); + std::os::unix::fs::symlink(&target, &path).unwrap(); + assert!(ProviderSocket::bind(&path).is_err()); + assert_eq!(std::fs::read_link(&path).unwrap(), target); + std::fs::remove_file(&path).unwrap(); + let socket = ProviderSocket::bind(&path).unwrap(); + std::fs::remove_file(&path).unwrap(); + std::fs::write(&path, b"replacement").unwrap(); + drop(socket); + assert_eq!(std::fs::read(&path).unwrap(), b"replacement"); + } -impl IntoResponse for ServerError { - fn into_response(self) -> Response { - let (status, message) = match &self { - ServerError::InvalidHex(_) | ServerError::InvalidLength => { - (StatusCode::BAD_REQUEST, self.to_string()) - } - ServerError::AttestationFailed(_) => { - tracing::error!("{self:?}"); - (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error".to_string()) - } + #[test] + fn client_rejects_invalid_frames() { + use std::{ + io::{Read, Write}, + os::unix::net::UnixListener, }; - (status, message).into_response() + let valid = + ProviderResponse::Ok(AttestationExchangeMessage::without_attestation()).encode(); + let mut frames = + vec![vec![], vec![0; 4], ((MAX_RESPONSE_SIZE + 1) as u32).to_be_bytes().to_vec()]; + for body in [ + vec![99], + ProviderResponse::Err(ProviderError::GenerationFailed).encode(), + [valid.clone(), vec![99]].concat(), + ] { + frames.push([(body.len() as u32).to_be_bytes().to_vec(), body].concat()); + } + frames.push([10u32.to_be_bytes().to_vec(), valid.clone()].concat()); + frames.push([(valid.len() as u32).to_be_bytes().to_vec(), valid, vec![99]].concat()); + for frame in frames { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("test.sock"); + let listener = UnixListener::bind(&path).unwrap(); + let server = std::thread::spawn(move || { + let (mut stream, _) = listener.accept().unwrap(); + let mut request = Vec::new(); + stream.read_to_end(&mut request).unwrap(); + assert_eq!(request, [42; 64]); + for byte in frame { + if stream.write_all(&[byte]).is_err() { + break; + } + } + }); + assert!(request_attestation(&path, [42; 64]).is_err()); + server.join().unwrap(); + } } -} - -#[cfg(test)] -mod tests { - use super::*; #[tokio::test] - async fn test_attestation_provider_server() { - let attestation_generator = AttestationGenerator::with_no_attestation(); + async fn cli_helper_verifies_over_socket() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("provider.sock"); + let socket = ProviderSocket::bind(&path).unwrap(); + let client = + tokio::spawn(attestation_provider_client(path, AttestationVerifier::expect_none())); + let (stream, _) = socket.listener.accept().await.unwrap(); + serve_connection(stream, AttestationGenerator::with_no_attestation()).await.unwrap(); + assert!(client.await.unwrap().unwrap().attestation_evidence.is_none()); + } - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let server_addr = listener.local_addr().unwrap(); + #[tokio::test] + async fn missing_request_eof_times_out() { + let (mut client, server) = UnixStream::pair().unwrap(); + client.write_all(&[42; 64]).await.unwrap(); + let result = serve_connection(server, AttestationGenerator::with_no_attestation()).await; + assert!(result.is_err()); + } - tokio::spawn(async move { - attestation_provider_server(listener, attestation_generator).await.unwrap(); - }); - attestation_provider_client(server_addr, AttestationVerifier::expect_none()).await.unwrap(); + #[test] + fn successful_fragmented_evidence_and_stalled_response() { + use std::{ + io::{Read, Write}, + os::unix::net::UnixListener, + }; + for stalled in [false, true] { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("provider.sock"); + let listener = UnixListener::bind(&path).unwrap(); + let server = std::thread::spawn(move || { + let (mut stream, _) = listener.accept().unwrap(); + let mut request = Vec::new(); + stream.read_to_end(&mut request).unwrap(); + assert_eq!(request, [42; 64]); + if stalled { + std::thread::sleep(Duration::from_millis(1200)); + return; + } + let evidence = attestation::AttestationEvidence { + quote: request, + platform: attestation::PlatformMetadata { + attestation_type: attestation::AttestationType::DcapTdx.try_into().unwrap(), + ram_bytes: 1234, + num_disks: 2, + acpi: None, + smbios_handoff: None, + dm_verity_boot: true, + }, + }; + let body = ProviderResponse::Ok(evidence.into()).encode(); + for byte in [(body.len() as u32).to_be_bytes().to_vec(), body].concat() { + stream.write_all(&[byte]).unwrap(); + } + }); + let result = attestation::provider::request_attestation(&path, [42; 64]); + if stalled { + assert!(result.is_err()); + } else { + let evidence = result.unwrap().attestation_evidence.unwrap(); + assert_eq!(evidence.quote, [42; 64]); + assert_eq!(evidence.platform.ram_bytes, 1234); + assert_eq!(evidence.platform.num_disks, 2); + assert!(evidence.platform.dm_verity_boot); + } + server.join().unwrap(); + } } } diff --git a/crates/attestation-provider-server/src/main.rs b/crates/attestation-provider-server/src/main.rs index c6d2fcd2..26965c81 100644 --- a/crates/attestation-provider-server/src/main.rs +++ b/crates/attestation-provider-server/src/main.rs @@ -1,4 +1,4 @@ -use std::{net::SocketAddr, path::PathBuf}; +use std::{os::fd::AsFd, path::PathBuf}; use attestation::{ AttestationGenerator, @@ -6,9 +6,12 @@ use attestation::{ AttestationVerifier, measurements::MeasurementPolicy, }; -use attestation_provider_server::{attestation_provider_client, attestation_provider_server}; +use attestation_provider_server::{ + ProviderSocket, + attestation_provider_client, + attestation_provider_server, +}; use clap::{Parser, Subcommand}; -use tokio::net::TcpListener; use tracing::level_filters::LevelFilter; const GIT_REV: &str = match option_env!("GIT_REV") { @@ -21,6 +24,14 @@ const GIT_REV: &str = match option_env!("GIT_REV") { struct Cli { #[clap(subcommand)] command: CliCommand, + /// Filesystem socket used by both server and client + #[arg( + long, + global = true, + env = "ATTESTATION_PROVIDER_SOCKET", + default_value = "/run/attestation-provider/attestation.sock" + )] + socket_path: PathBuf, /// Log debug messages #[arg(long, global = true)] log_debug: bool, @@ -34,17 +45,12 @@ struct Cli { #[derive(Subcommand, Debug, Clone)] enum CliCommand { Server { - /// Socket address to listen on - #[arg(short, long, default_value = "127.0.0.1:0", env = "LISTEN_ADDR")] - listen_addr: SocketAddr, - /// Type of attestation to present (will attempt to detect if not - /// given) + /// Type of attestation to present (will attempt to detect if + /// not given) #[arg(long)] server_attestation_type: Option, }, Client { - /// Socket address of a attestation provider server - server_addr: SocketAddr, /// Optional path to file containing JSON measurements to be /// enforced on the remote party #[arg(long, global = true, env = "MEASUREMENTS_FILE")] @@ -75,7 +81,7 @@ async fn main() -> anyhow::Result<()> { } match cli.command { - CliCommand::Server { listen_addr, server_attestation_type } => { + CliCommand::Server { server_attestation_type } => { let none_requested = server_attestation_type.as_deref() == Some("none"); let attestation_generator = AttestationGenerator::new_with_detection(server_attestation_type, None)?; @@ -86,12 +92,19 @@ async fn main() -> anyhow::Result<()> { ); } - let listener = TcpListener::bind(listen_addr).await?; - - println!("Listening on {}", listener.local_addr()?); - attestation_provider_server(listener, attestation_generator).await?; + let socket = ProviderSocket::bind(&cli.socket_path)?; + println!("Listening on {}", cli.socket_path.display()); + let listener = std::os::unix::net::UnixListener::from( + socket.listener.as_fd().try_clone_to_owned()?, + ); + let listener = tokio::net::UnixListener::from_std(listener)?; + tokio::select! { + result = attestation_provider_server(listener, attestation_generator) => result?, + _ = shutdown_signal() => {}, + } + drop(socket); } - CliCommand::Client { server_addr, measurements_file } => { + CliCommand::Client { measurements_file } => { let measurement_policy = match measurements_file { Some(measurements_file) => MeasurementPolicy::from_file(measurements_file).await?, None => MeasurementPolicy::accept_anything(), @@ -102,7 +115,7 @@ async fn main() -> anyhow::Result<()> { .build(); let attestation_message = - attestation_provider_client(server_addr, attestation_verifier).await?; + attestation_provider_client(cli.socket_path, attestation_verifier).await?; println!("{attestation_message:?}") } @@ -110,3 +123,9 @@ async fn main() -> anyhow::Result<()> { Ok(()) } + +async fn shutdown_signal() { + let mut terminate = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) + .expect("Install SIGTERM handler"); + tokio::select! { _ = tokio::signal::ctrl_c() => {}, _ = terminate.recv() => {} } +} diff --git a/crates/attestation/Cargo.toml b/crates/attestation/Cargo.toml index f193e49a..e1713d89 100644 --- a/crates/attestation/Cargo.toml +++ b/crates/attestation/Cargo.toml @@ -8,6 +8,7 @@ repository = "https://github.com/flashbots/attested-tls" keywords = ["attestation", "CVM", "TDX"] [dependencies] +socket2 = "0.6.3" dcap-qvl = { workspace = true } pccs = { workspace = true } tokio = { workspace = true, features = ["fs", "rt", "rt-multi-thread", "time"] } diff --git a/crates/attestation/README.md b/crates/attestation/README.md index e0839c43..209750cc 100644 --- a/crates/attestation/README.md +++ b/crates/attestation/README.md @@ -118,7 +118,7 @@ be rejected with an error. Enables verification of Microsoft Azure vTPM attestation evidence. Verification is pure computation over the evidence bytes; it requires -`openssl` but no TPM stack, and builds and runs on any platform, including +`openssl` but no TPM stack, and builds and runs on Unix platforms, including MacOS. *** Note *** @@ -161,8 +161,11 @@ interface. This means that the binary must be run with access to configfs-tsm is unavailable, quote generation via vSOCK to the QGS will be attempted. -Alternatively, an external 'attestation provider service' URL can be provided -which outsources the attestation generation to another process. +Alternatively, an absolute Unix socket path (`Option`) can be provided +to `AttestationGenerator::new` or `new_with_detection` to outsource both quote +generation and platform metadata collection to another process. TCP/HTTP provider +URLs are no longer supported. See the [provider documentation](../attestation-provider-server/README.md) +for socket configuration and permissions. When verifying DCAP attestations, collateral is retrieved according to the configured collateral source and cache policy. The source defaults to Intel PCS diff --git a/crates/attestation/src/lib.rs b/crates/attestation/src/lib.rs index 18c4b0ba..d02c7e15 100644 --- a/crates/attestation/src/lib.rs +++ b/crates/attestation/src/lib.rs @@ -9,13 +9,12 @@ pub mod azure; pub mod dcap; mod gcp; pub mod measurements; +pub mod provider; mod trusted_firmware; #[cfg(test)] use std::sync::OnceLock; use std::{ fmt::{self, Display, Formatter}, - io::Read, - net::IpAddr, sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard}, time::{Duration, SystemTime, UNIX_EPOCH}, }; @@ -225,21 +224,20 @@ impl Display for AttestationType { #[derive(Debug, Clone)] pub struct AttestationGenerator { pub attestation_type: AttestationType, - attestation_provider_url: Option, + attestation_provider_socket: Option, } impl AttestationGenerator { /// Create an attestation generator with given attestation type pub fn new( attestation_type: AttestationType, - attestation_provider_url: Option, + attestation_provider_socket: Option, ) -> Result { - // If an attestation provider is given, normalize the URL and check - // that it looks like a local IP - let attestation_provider_url = - attestation_provider_url.map(map_attestation_provider_url).transpose()?; + if let Some(path) = &attestation_provider_socket { + provider::validate_path(path)?; + } - Ok(Self { attestation_type, attestation_provider_url }) + Ok(Self { attestation_type, attestation_provider_socket }) } /// Detect what confidential compute platform is present and create the @@ -250,21 +248,21 @@ impl AttestationGenerator { /// Do not generate attestations pub fn with_no_attestation() -> Self { - Self { attestation_type: AttestationType::None, attestation_provider_url: None } + Self { attestation_type: AttestationType::None, attestation_provider_socket: None } } /// Create an [AttestationGenerator] detecting the attestation type if /// it is not given pub fn new_with_detection( attestation_type_string: Option, - attestation_provider_url: Option, + attestation_provider_socket: Option, ) -> Result { - if attestation_provider_url.is_some() { + if attestation_provider_socket.is_some() { // If a remote provider is used, dont do detection let attestation_type = serde_json::from_value(serde_json::Value::String( attestation_type_string.ok_or(AttestationError::AttestationTypeNotGiven)?, ))?; - return Self::new(attestation_type, attestation_provider_url); + return Self::new(attestation_type, attestation_provider_socket); }; let attestation_type_string = attestation_type_string.unwrap_or_else(|| "auto".to_string()); @@ -284,8 +282,8 @@ impl AttestationGenerator { &self, input_data: [u8; 64], ) -> Result { - if let Some(url) = &self.attestation_provider_url { - Self::use_attestation_provider(url, self.attestation_type, input_data) + if let Some(path) = &self.attestation_provider_socket { + Self::use_attestation_provider(path, self.attestation_type, input_data) } else { match self.attestation_type { AttestationType::None => Ok(AttestationExchangeMessage::without_attestation()), @@ -330,35 +328,14 @@ impl AttestationGenerator { /// Generate an attestation by using an external service for the /// attestation generation fn use_attestation_provider( - url: &str, + path: &std::path::Path, attestation_type: AttestationType, input_data: [u8; 64], ) -> Result { if attestation_type == AttestationType::None { return Ok(AttestationExchangeMessage::without_attestation()); } - - let url = format!("{}/attest/{}", url, hex::encode(input_data)); - - let timeout = Duration::from_secs(1); - let agent: ureq::Agent = ureq::Agent::config_builder() - .proxy(None) - .max_redirects(5) - .timeout_global(Some(timeout)) - .build() - .into(); - let response = agent - .get(&url) - .call() - .map_err(|err| AttestationError::AttestationProvider(err.to_string()))?; - let mut response = response.into_body().into_reader(); - let mut body = Vec::new(); - response - .read_to_end(&mut body) - .map_err(|err| AttestationError::AttestationProvider(err.to_string()))?; - - AttestationExchangeMessage::decode(&mut &body[..]) - .map_err(|err| AttestationError::AttestationProvider(err.to_string())) + provider::request_attestation(path, input_data) } } @@ -1123,57 +1100,6 @@ fn running_on_gcp() -> Result { Ok(false) } -/// If an attestation provider service is used, we ensure that it looks like -/// a local IP -/// -/// This is to avoid dangerous configuration where the attestation is -/// provided by a remote machine -/// -/// This by no means guarantees a safe configuration -fn map_attestation_provider_url(url: String) -> Result { - // Fist put it in the format that reqwest expects - let url = if url.starts_with("http://") || url.starts_with("https://") { - url.to_string() - } else { - format!("http://{}", url.trim_start_matches("http://")) - }; - - let url = url.strip_suffix('/').unwrap_or(&url).to_string(); - let url = url.strip_suffix("/attest").unwrap_or(&url).to_string(); - - // If compiled in test mode, skip this check - if !cfg!(test) { - let parsed = url - .parse::() - .or_else(|_| { - // Try parsing as a URL to extract host - let parsed = url.parse::().map_err(|_| "Invalid URL")?; - - let host = parsed.host().ok_or("URL missing host")?; - - host.parse::() - .map_err(|_| "Only local IP addresses may be used as attestation provider URL") - .map(|ip| std::net::SocketAddr::new(ip, 0)) - }) - .map_err(|e| AttestationError::AttestationProviderUrl(e.to_string()))?; - - if !is_local_ip(parsed.ip()) { - return Err(AttestationError::AttestationProviderUrl( - "Given URL does not appear to contain a local IP address".to_string(), - )); - } - } - Ok(url) -} - -/// Check if an IP address looks like it is local -fn is_local_ip(ip: IpAddr) -> bool { - match ip { - IpAddr::V4(v4) => v4.is_private() || v4.is_loopback() || v4.is_link_local(), - IpAddr::V6(v6) => v6.is_loopback() || v6.is_unique_local() || v6.is_unicast_link_local(), - } -} - #[cfg(any(test, feature = "mock"))] /// Create mock platform metadata for tests pub fn mock_platform_metadata( @@ -1223,8 +1149,8 @@ pub enum AttestationError { AttestationTypeNotGiven, #[error("Attestation provider server: {0}")] AttestationProvider(String), - #[error("Attestation provider URL: {0}")] - AttestationProviderUrl(String), + #[error("Attestation provider socket: {0}")] + AttestationProviderPath(String), #[error("JSON: {0}")] SerdeJson(#[from] serde_json::Error), #[error("HTTP client: {0}")] diff --git a/crates/attestation/src/provider.rs b/crates/attestation/src/provider.rs new file mode 100644 index 00000000..370a1459 --- /dev/null +++ b/crates/attestation/src/provider.rs @@ -0,0 +1,113 @@ +//! Attestation provider service over Unix domain sockets +use std::{ + io::{self, Read, Write}, + net::Shutdown, + os::unix::net::UnixStream, + path::Path, + time::{Duration, Instant}, +}; + +use parity_scale_codec::{Decode, Encode}; + +use crate::{AttestationError, AttestationExchangeMessage}; + +/// Maximum encoded result size, including SCALE discriminants. +pub const MAX_RESPONSE_SIZE: usize = 256 * 1024; +/// Wire errors deliberately exclude internal diagnostic details. +#[derive(Debug, Encode, Decode)] +pub enum ProviderError { + #[codec(index = 0)] + InvalidRequest, + #[codec(index = 1)] + GenerationFailed, +} +pub type ProviderResponse = Result; + +pub(crate) fn validate_path(path: &Path) -> Result<(), AttestationError> { + if !path.is_absolute() { + return Err(AttestationError::AttestationProviderPath( + "Expected an absolute filesystem path".into(), + )); + } + Ok(()) +} + +/// Send 64 bytes and a write-half EOF. Receive a length-prefixed SCALE +/// result. This blocks for at most one second and requires no async +/// runtime. +pub fn request_attestation( + path: &Path, + input: [u8; 64], +) -> Result { + validate_path(path)?; + request_unix(path, input).map_err(|e| AttestationError::AttestationProvider(e.to_string())) +} + +/// Request an attestation over a unix socket +fn request_unix(path: &Path, input: [u8; 64]) -> std::io::Result { + let deadline = Instant::now() + Duration::from_secs(1); + let remaining = || { + deadline + .checked_duration_since(Instant::now()) + .filter(|d| !d.is_zero()) + .ok_or_else(|| io::Error::new(io::ErrorKind::TimedOut, "Provider deadline exceeded")) + }; + + let socket = socket2::Socket::new(socket2::Domain::UNIX, socket2::Type::STREAM, None)?; + socket.connect_timeout(&socket2::SockAddr::unix(path)?, remaining()?)?; + + let mut stream = UnixStream::from(socket); + let mut pending = &input[..]; + + while !pending.is_empty() { + stream.set_write_timeout(Some(remaining()?))?; + let n = stream.write(pending)?; + if n == 0 { + return Err(io::ErrorKind::WriteZero.into()); + } + pending = &pending[n..]; + } + + stream.shutdown(Shutdown::Write)?; + + let mut read_exact = |mut buf: &mut [u8]| -> io::Result<()> { + while !buf.is_empty() { + stream.set_read_timeout(Some(remaining()?))?; + let n = stream.read(buf)?; + if n == 0 { + return Err(io::ErrorKind::UnexpectedEof.into()); + } + buf = &mut buf[n..]; + } + Ok(()) + }; + + let mut header = [0; 4]; + read_exact(&mut header)?; + let len = u32::from_be_bytes(header) as usize; + + if len == 0 || len > MAX_RESPONSE_SIZE { + return Err(invalid("Invalid provider response length")); + } + + let mut body = vec![0; len]; + read_exact(&mut body)?; + stream.set_read_timeout(Some(remaining()?))?; + + if stream.read(&mut [0])? != 0 { + return Err(invalid("Trailing provider response bytes")); + } + + let mut bytes = &body[..]; + let result = ProviderResponse::decode(&mut bytes).map_err(|e| invalid(e.to_string()))?; + + if !bytes.is_empty() { + return Err(invalid("Trailing SCALE data")); + } + + result.map_err(|e| invalid(format!("Provider returned {e:?}"))) +} + +fn invalid(message: impl Into>) -> io::Error { + io::Error::new(io::ErrorKind::InvalidData, message) +} diff --git a/readme.md b/readme.md index 3a1e06d5..4a4821c2 100644 --- a/readme.md +++ b/readme.md @@ -48,7 +48,7 @@ More details in the individual READMEs of the provided crates: quotes, collateral, and trust roots for tests and development on non-TDX hardware. - [`attestation-provider-server`](./crates/attestation-provider-server) - - HTTP server and client for attestation generation and verification. + Unix socket server and client for attestation generation and verification. The included `shell.nix` file can be used with `nix-shell`, `direnv`, or `nix develop` to add the dependencies needed by the optional `azure-attester` From 5ae8a930e5ca099fe9b4c6f5cf53b4d97d4e9b41 Mon Sep 17 00:00:00 2001 From: peg Date: Mon, 9 Nov 2026 17:16:44 +0100 Subject: [PATCH 2/4] Validate socket path fully --- crates/attestation-provider-server/README.md | 6 ++ crates/attestation-provider-server/src/lib.rs | 73 ++++++++++++++++--- 2 files changed, 67 insertions(+), 12 deletions(-) diff --git a/crates/attestation-provider-server/README.md b/crates/attestation-provider-server/README.md index 65da6990..6ae83dde 100644 --- a/crates/attestation-provider-server/README.md +++ b/crates/attestation-provider-server/README.md @@ -7,4 +7,10 @@ privileges. Use `--socket-path` and provision its parent directory with the application's access group and mode `2750`. +Use an absolute socket path without symlink directories or `..` components. +Every directory in the path must be owned by root or the service user and must +not be group/other writable. Sticky ancestors such as `/tmp` are allowed, but +the socket's immediate parent must never be group/other writable. For example, +use `/run/attestation-provider/attestation.sock` with a protected parent directory. + The service creates the socket with mode `0660`. diff --git a/crates/attestation-provider-server/src/lib.rs b/crates/attestation-provider-server/src/lib.rs index a1954cdf..8dbb39c5 100644 --- a/crates/attestation-provider-server/src/lib.rs +++ b/crates/attestation-provider-server/src/lib.rs @@ -2,7 +2,7 @@ //! socket. use std::{ os::unix::fs::{MetadataExt, PermissionsExt}, - path::{Path, PathBuf}, + path::{Component, Path, PathBuf}, time::Duration, }; @@ -30,17 +30,7 @@ pub struct ProviderSocket { impl ProviderSocket { /// Existing paths are never removed at startup. pub fn bind(path: &Path) -> anyhow::Result { - anyhow::ensure!(path.is_absolute(), "Expected an absolute socket path"); - let parent = std::fs::symlink_metadata( - path.parent().ok_or_else(|| anyhow::anyhow!("Missing parent"))?, - )?; - let uid = nix::unistd::geteuid().as_raw(); - anyhow::ensure!( - parent.is_dir() && - (parent.uid() == 0 || parent.uid() == uid) && - parent.mode() & 0o022 == 0, - "Socket parent must be service/root-owned and not group/other writable" - ); + validate_socket_path(path)?; let socket = UnixSocket::new_stream()?; socket.bind(path)?; let metadata = std::fs::symlink_metadata(path)?; @@ -65,6 +55,40 @@ impl ProviderSocket { } } +/// Walk from the root so each directory is protected against replacement +/// before looking up its child. Only root and the service uid are trusted +/// to change these directories. This keeps subsequent path-based +/// bind/chmod/unlink calls from being redirected by another user. +fn validate_socket_path(path: &Path) -> anyhow::Result<()> { + anyhow::ensure!(path.is_absolute(), "Expected an absolute socket path"); + anyhow::ensure!( + !path.components().any(|component| matches!(component, Component::ParentDir)), + "Socket path must not contain '..'" + ); + anyhow::ensure!(path.file_name().is_some(), "Missing socket filename"); + let parent = path.parent().ok_or_else(|| anyhow::anyhow!("Missing parent"))?; + let uid = nix::unistd::geteuid().as_raw(); + let mut directory = PathBuf::new(); + for component in parent.components() { + directory.push(component); + let metadata = std::fs::symlink_metadata(&directory)?; + anyhow::ensure!( + metadata.is_dir() && (metadata.uid() == 0 || metadata.uid() == uid), + "Socket directory {} must be a service/root-owned directory, not a symlink", + directory.display() + ); + // A trusted sticky ancestor (e.g. /tmp) protects its trusted-owned + // children from replacement. The immediate parent must additionally + // prevent other users from creating entries, including the socket. + anyhow::ensure!( + metadata.mode() & 0o022 == 0 || (directory != parent && metadata.mode() & 0o1000 != 0), + "Socket directory {} must not be group/other writable (except sticky ancestors)", + directory.display() + ); + } + Ok(()) +} + struct SocketCleanup { path: PathBuf, device: u64, @@ -170,6 +194,31 @@ mod tests { use super::*; + #[tokio::test] + async fn rejects_replaceable_ancestors() { + let dir = tempfile::tempdir().unwrap(); + let ancestor = dir.path().join("ancestor"); + let parent = ancestor.join("service"); + std::fs::create_dir_all(&parent).unwrap(); + std::fs::set_permissions(&parent, std::fs::Permissions::from_mode(0o750)).unwrap(); + let path = parent.join("provider.sock"); + for mode in [0o777, 0o770] { + std::fs::set_permissions(&ancestor, std::fs::Permissions::from_mode(mode)).unwrap(); + assert!(ProviderSocket::bind(&path).is_err()); + assert!(!path.exists()); + } + std::fs::set_permissions(&ancestor, std::fs::Permissions::from_mode(0o1777)).unwrap(); + drop(ProviderSocket::bind(&path).unwrap()); + assert!(validate_socket_path(&ancestor.join("provider.sock")).is_err()); + std::fs::set_permissions(&ancestor, std::fs::Permissions::from_mode(0o750)).unwrap(); + drop(ProviderSocket::bind(&path).unwrap()); + + let alias = dir.path().join("alias"); + std::os::unix::fs::symlink(&ancestor, &alias).unwrap(); + assert!(validate_socket_path(&alias.join("service/provider.sock")).is_err()); + assert!(validate_socket_path(&parent.join("../provider.sock")).is_err()); + } + #[tokio::test] async fn unix_generator_round_trip_and_lifecycle() { let dir = tempfile::tempdir().unwrap(); From 4f31d1b9524d7a8b18549bcc553759da13002d74 Mon Sep 17 00:00:00 2001 From: peg Date: Tue, 10 Nov 2026 11:49:35 +0100 Subject: [PATCH 3/4] When failing to accept connection, re-try if the error is recoverable --- crates/attestation-provider-server/src/lib.rs | 75 ++++++++++++++++++- 1 file changed, 74 insertions(+), 1 deletion(-) diff --git a/crates/attestation-provider-server/src/lib.rs b/crates/attestation-provider-server/src/lib.rs index 8dbb39c5..976f2efd 100644 --- a/crates/attestation-provider-server/src/lib.rs +++ b/crates/attestation-provider-server/src/lib.rs @@ -1,6 +1,7 @@ //! Attestation generation through a group-accessible filesystem Unix //! socket. use std::{ + io, os::unix::fs::{MetadataExt, PermissionsExt}, path::{Component, Path, PathBuf}, time::Duration, @@ -19,6 +20,9 @@ use tokio::{ time::timeout, }; +/// How long to wait before retrying on a recoverable accept error +const ACCEPT_RETRY_DELAY: Duration = Duration::from_millis(100); + /// The underlying unix socket for the service pub struct ProviderSocket { pub listener: UnixListener, @@ -126,7 +130,7 @@ pub async fn attestation_provider_server( generator: AttestationGenerator, ) -> anyhow::Result<()> { loop { - let (stream, _) = listener.accept().await?; + let (stream, _) = accept_with_retry(|| listener.accept()).await?; let generator = generator.clone(); tokio::spawn(async move { if let Err(error) = serve_connection(stream, generator).await { @@ -136,6 +140,41 @@ pub async fn attestation_provider_server( } } +/// Retry connection failures and resource exhaustion without spinning. +/// Errors indicating a broken listener still propagate to the caller. +async fn accept_with_retry(mut accept: F) -> io::Result +where + F: FnMut() -> Fut, + Fut: std::future::Future>, +{ + loop { + match accept().await { + Ok(connection) => return Ok(connection), + Err(error) if retryable_accept_error(&error) => { + tracing::warn!(%error, "Temporary accept failure; retrying in 100ms"); + tokio::time::sleep(ACCEPT_RETRY_DELAY).await; + } + Err(error) => return Err(error), + } + } +} + +fn retryable_accept_error(error: &io::Error) -> bool { + use nix::errno::Errno; + + matches!( + error.kind(), + io::ErrorKind::Interrupted | + io::ErrorKind::WouldBlock | + io::ErrorKind::ConnectionAborted | + io::ErrorKind::ConnectionReset | + io::ErrorKind::TimedOut + ) || matches!( + error.raw_os_error().map(Errno::from_i32), + Some(Errno::EMFILE | Errno::ENFILE | Errno::ENOBUFS | Errno::ENOMEM) + ) +} + async fn serve_connection( mut stream: UnixStream, generator: AttestationGenerator, @@ -194,6 +233,40 @@ mod tests { use super::*; + #[tokio::test] + async fn accept_recovers_after_resource_exhaustion_with_backoff() { + use nix::errno::Errno; + + let mut errors = [Errno::EMFILE, Errno::ENFILE, Errno::ENOBUFS, Errno::ENOMEM].into_iter(); + let start = tokio::time::Instant::now(); + let connection = accept_with_retry(|| { + std::future::ready(match errors.next() { + Some(error) => Err(io::Error::from_raw_os_error(error as i32)), + None => Ok(42), + }) + }) + .await + .unwrap(); + assert_eq!(connection, 42); + assert!(start.elapsed() >= ACCEPT_RETRY_DELAY * 4); + } + + #[tokio::test] + async fn accept_propagates_broken_listener_errors_without_retrying() { + use nix::errno::Errno; + + for error in [Errno::EBADF, Errno::EINVAL, Errno::ENOTSOCK, Errno::EACCES] { + let mut attempts = 0; + let result = accept_with_retry(|| { + attempts += 1; + assert_eq!(attempts, 1, "permanent errors must not be retried"); + std::future::ready(Err::<(), _>(io::Error::from_raw_os_error(error as i32))) + }) + .await; + assert_eq!(result.unwrap_err().raw_os_error(), Some(error as i32)); + } + } + #[tokio::test] async fn rejects_replaceable_ancestors() { let dir = tempfile::tempdir().unwrap(); From 4e363681cbf12e68b2d76aea0184c87c8eba4e10 Mon Sep 17 00:00:00 2001 From: peg Date: Tue, 10 Nov 2026 12:59:07 +0100 Subject: [PATCH 4/4] Fix response reads in attestation provider --- crates/attestation/src/provider.rs | 85 ++++++++++++++++++++++++------ 1 file changed, 70 insertions(+), 15 deletions(-) diff --git a/crates/attestation/src/provider.rs b/crates/attestation/src/provider.rs index 370a1459..0de0653a 100644 --- a/crates/attestation/src/provider.rs +++ b/crates/attestation/src/provider.rs @@ -46,22 +46,17 @@ pub fn request_attestation( /// Request an attestation over a unix socket fn request_unix(path: &Path, input: [u8; 64]) -> std::io::Result { let deadline = Instant::now() + Duration::from_secs(1); - let remaining = || { - deadline - .checked_duration_since(Instant::now()) - .filter(|d| !d.is_zero()) - .ok_or_else(|| io::Error::new(io::ErrorKind::TimedOut, "Provider deadline exceeded")) - }; - let socket = socket2::Socket::new(socket2::Domain::UNIX, socket2::Type::STREAM, None)?; - socket.connect_timeout(&socket2::SockAddr::unix(path)?, remaining()?)?; + socket.connect_timeout(&socket2::SockAddr::unix(path)?, remaining(deadline)?)?; let mut stream = UnixStream::from(socket); let mut pending = &input[..]; while !pending.is_empty() { - stream.set_write_timeout(Some(remaining()?))?; - let n = stream.write(pending)?; + let n = io_with_deadline(deadline, |left| { + stream.set_write_timeout(Some(left))?; + stream.write(pending) + })?; if n == 0 { return Err(io::ErrorKind::WriteZero.into()); } @@ -72,8 +67,10 @@ fn request_unix(path: &Path, input: [u8; 64]) -> std::io::Result io::Result<()> { while !buf.is_empty() { - stream.set_read_timeout(Some(remaining()?))?; - let n = stream.read(buf)?; + let n = io_with_deadline(deadline, |left| { + stream.set_read_timeout(Some(left))?; + stream.read(buf) + })?; if n == 0 { return Err(io::ErrorKind::UnexpectedEof.into()); } @@ -92,9 +89,11 @@ fn request_unix(path: &Path, input: [u8; 64]) -> std::io::Result std::io::Result io::Result { + deadline + .checked_duration_since(Instant::now()) + .filter(|d| !d.is_zero()) + .ok_or_else(|| io::Error::new(io::ErrorKind::TimedOut, "Provider deadline exceeded")) +} + +/// Retry interrupted I/O with the remaining budget, never a fresh timeout. +fn io_with_deadline( + deadline: Instant, + mut operation: impl FnMut(Duration) -> io::Result, +) -> io::Result { + loop { + match operation(remaining(deadline)?) { + Err(error) if error.kind() == io::ErrorKind::Interrupted => continue, + result => return result, + } + } +} + fn invalid(message: impl Into>) -> io::Error { io::Error::new(io::ErrorKind::InvalidData, message) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn interrupted_io_retries_then_returns_the_result() { + let mut attempts = 0; + let result = io_with_deadline(Instant::now() + Duration::from_secs(1), |_| { + attempts += 1; + if attempts < 3 { Err(io::ErrorKind::Interrupted.into()) } else { Ok(42) } + }); + assert_eq!(result.unwrap(), 42); + assert_eq!(attempts, 3); + + let error = io_with_deadline::<()>(Instant::now() + Duration::from_secs(1), |_| { + Err(io::ErrorKind::ConnectionReset.into()) + }) + .unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::ConnectionReset); + } + + #[test] + fn repeated_interruptions_cannot_extend_the_deadline() { + let deadline = Instant::now() + Duration::from_millis(20); + let mut previous = Duration::from_secs(1); + let error = io_with_deadline::<()>(deadline, |left| { + assert!(left <= previous); + previous = left; + std::thread::sleep(Duration::from_millis(5)); + Err(io::ErrorKind::Interrupted.into()) + }) + .unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::TimedOut); + } +}