From ef2ef318bc7e5839fba1f37620eb4a30c7ade46c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 1 Nov 2026 10:22:29 -0800 Subject: [PATCH 1/3] fix(proto): redact credentials from ConnectRequest's Debug output ConnectRequest derived Debug, so every `?request` log printed the URL's query string and userinfo and every header value, including Authorization and Cookie. Replace it with a manual impl that keeps the scheme, host, port, path, protocols, and header names, but redacts the userinfo, query, fragment, and all header values except origin and user-agent (and those too when marked sensitive). Stop logging raw URLs and headers elsewhere: quiche's established log and InvalidUrl error, and the quinn, noq, and quiche examples. Co-Authored-By: Claude Opus 5.5 --- .../examples/echo-client-advanced.rs | 2 +- rs/web-transport-noq/examples/echo-client.rs | 5 +- .../examples/echo-server-advanced.rs | 3 +- rs/web-transport-noq/examples/echo-server.rs | 3 +- rs/web-transport-proto/src/connect.rs | 177 +++++++++++++++++- .../examples/echo-client.rs | 2 +- .../examples/echo-server.rs | 5 +- rs/web-transport-quiche/src/client.rs | 6 +- rs/web-transport-quiche/src/connection.rs | 2 +- .../examples/echo-client-advanced.rs | 2 +- .../examples/echo-client.rs | 5 +- .../examples/echo-server-advanced.rs | 13 +- .../examples/echo-server.rs | 3 +- 13 files changed, 199 insertions(+), 29 deletions(-) diff --git a/rs/web-transport-noq/examples/echo-client-advanced.rs b/rs/web-transport-noq/examples/echo-client-advanced.rs index ad3a4744..d26c4971 100644 --- a/rs/web-transport-noq/examples/echo-client-advanced.rs +++ b/rs/web-transport-noq/examples/echo-client-advanced.rs @@ -57,7 +57,7 @@ async fn main() -> anyhow::Result<()> { let client = web_transport_noq::Client::new(client, config); // Connect to the given URL. - tracing::info!(url = %args.url, "connecting"); + tracing::info!(host = ?args.url.host_str(), path = args.url.path(), "connecting"); let session = client.connect(args.url).await?; tracing::info!("connected"); diff --git a/rs/web-transport-noq/examples/echo-client.rs b/rs/web-transport-noq/examples/echo-client.rs index bbfc476b..f18794ee 100644 --- a/rs/web-transport-noq/examples/echo-client.rs +++ b/rs/web-transport-noq/examples/echo-client.rs @@ -63,13 +63,14 @@ async fn main() -> anyhow::Result<()> { client.with_system_roots()? }; - tracing::info!(url = %args.url, "connecting"); - // Connect to the given URL. let mut request = ConnectRequest::new(args.url); if let Some(protocol) = &args.protocol { request = request.with_protocol(protocol); } + + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(?request, "connecting"); let session = client.connect(request).await?; tracing::info!("connected"); diff --git a/rs/web-transport-noq/examples/echo-server-advanced.rs b/rs/web-transport-noq/examples/echo-server-advanced.rs index 35708e8d..84731290 100644 --- a/rs/web-transport-noq/examples/echo-server-advanced.rs +++ b/rs/web-transport-noq/examples/echo-server-advanced.rs @@ -100,7 +100,8 @@ async fn run_conn(conn: noq::Incoming) -> anyhow::Result<()> { // Perform the WebTransport handshake. let request = web_transport_noq::Request::accept(conn).await?; - tracing::info!(url = %request.url, "received WebTransport request"); + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(request = ?*request, "received WebTransport request"); // Accept the session. let session = request.ok().await.context("failed to accept session")?; diff --git a/rs/web-transport-noq/examples/echo-server.rs b/rs/web-transport-noq/examples/echo-server.rs index fe55e4ad..0edd8929 100644 --- a/rs/web-transport-noq/examples/echo-server.rs +++ b/rs/web-transport-noq/examples/echo-server.rs @@ -82,7 +82,8 @@ async fn run_conn( request: web_transport_noq::Request, protocol: Option, ) -> anyhow::Result<()> { - tracing::info!(url = %request.url, "received WebTransport request"); + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(request = ?*request, "received WebTransport request"); // Negotiate protocol if both client and server support it. let negotiated = protocol.filter(|p| request.protocols.contains(p)); diff --git a/rs/web-transport-proto/src/connect.rs b/rs/web-transport-proto/src/connect.rs index 8becec03..d00d7a4a 100644 --- a/rs/web-transport-proto/src/connect.rs +++ b/rs/web-transport-proto/src/connect.rs @@ -1,8 +1,8 @@ -use std::{str::FromStr, sync::Arc}; +use std::{fmt, str::FromStr, sync::Arc}; use bytes::{Buf, BufMut, BytesMut}; use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; -use url::Url; +use url::{Position, Url}; use super::{qpack, Frame, VarInt, MAX_FRAME_SIZE}; @@ -99,8 +99,14 @@ impl From for ConnectError { } /// A CONNECT request to initiate a WebTransport session. +/// +/// The [`Debug`](fmt::Debug) output is safe to log. It keeps the URL's scheme, +/// host, port, and path, the protocols, and the header names, but redacts the +/// URL's userinfo, query, and fragment. Header values are redacted too, except +/// `origin` and `user-agent` when not marked +/// [sensitive](http::HeaderValue::set_sensitive). #[non_exhaustive] -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct ConnectRequest { /// The URL to connect to. pub url: Url, @@ -264,6 +270,70 @@ impl From for ConnectRequest { } } +/// Header values shown by [`ConnectRequest`]'s `Debug` output. +/// +/// This is an allowlist so that credentials in unknown or custom headers +/// (`authorization`, `cookie`, `x-api-key`, ...) are redacted by default. +const DEBUG_VISIBLE_HEADERS: [http::HeaderName; 2] = + [http::header::ORIGIN, http::header::USER_AGENT]; + +/// Replaces a redacted value in `Debug` output. +struct Redacted; + +impl fmt::Debug for Redacted { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("[redacted]") + } +} + +/// Formats a URL with its userinfo, query, and fragment redacted. +struct RedactedUrl<'a>(&'a Url); + +impl fmt::Debug for RedactedUrl<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let url = self.0; + let mut redacted = String::from(&url[..Position::BeforeUsername]); + if !url.username().is_empty() || url.password().is_some() { + redacted.push_str("[redacted]@"); + } + redacted.push_str(&url[Position::BeforeHost..Position::AfterPath]); + if url.query().is_some() { + redacted.push_str("?[redacted]"); + } + if url.fragment().is_some() { + redacted.push_str("#[redacted]"); + } + fmt::Debug::fmt(&redacted, f) + } +} + +/// Formats headers with every value outside [`DEBUG_VISIBLE_HEADERS`] redacted. +struct RedactedHeaders<'a>(&'a http::HeaderMap); + +impl fmt::Debug for RedactedHeaders<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut map = f.debug_map(); + for (name, value) in self.0 { + if DEBUG_VISIBLE_HEADERS.contains(name) && !value.is_sensitive() { + map.entry(name, value); + } else { + map.entry(name, &Redacted); + } + } + map.finish() + } +} + +impl fmt::Debug for ConnectRequest { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("ConnectRequest") + .field("url", &RedactedUrl(&self.url)) + .field("protocols", &self.protocols) + .field("headers", &RedactedHeaders(&self.headers)) + .finish() + } +} + /// A CONNECT response to accept or reject a WebTransport session. #[non_exhaustive] #[derive(Debug, Clone)] @@ -944,4 +1014,105 @@ mod tests { let err = ConnectRequest::read(&mut cursor).await.unwrap_err(); assert!(matches!(err, ConnectError::UnexpectedEnd)); } + + #[test] + fn request_debug_keeps_url_without_credentials() { + let req = ConnectRequest::new(Url::parse("https://example.com:4443/moq/room").unwrap()) + .with_protocol("moq-lite-03"); + assert_eq!( + format!("{req:?}"), + r#"ConnectRequest { url: "https://example.com:4443/moq/room", protocols: ["moq-lite-03"], headers: {} }"# + ); + } + + #[test] + fn request_debug_redacts_url_credentials() { + let url = "https://alice:hunter2@example.com/moq?jwt=SECRET&x=1#access_token=SECRET"; + let req = ConnectRequest::new(Url::parse(url).unwrap()); + let debug = format!("{req:?}"); + assert!( + debug.contains(r#"url: "https://[redacted]@example.com/moq?[redacted]#[redacted]""#), + "{debug}" + ); + for secret in ["alice", "hunter2", "SECRET", "x=1"] { + assert!(!debug.contains(secret), "{secret} leaked: {debug}"); + } + + let req = ConnectRequest::new(Url::parse("https://alice@example.com/").unwrap()); + assert!(format!("{req:?}").contains(r#""https://[redacted]@example.com/""#)); + } + + #[test] + fn request_debug_redacts_header_values() { + use http::{header, HeaderName, HeaderValue}; + + let mut sensitive_agent = HeaderValue::from_static("agent-SECRET"); + sensitive_agent.set_sensitive(true); + + let req = ConnectRequest::new(Url::parse("https://example.com/").unwrap()) + .with_header( + header::AUTHORIZATION, + HeaderValue::from_static("Bearer SECRET"), + ) + .with_header( + header::PROXY_AUTHORIZATION, + HeaderValue::from_static("Basic SECRET"), + ) + .with_header(header::COOKIE, HeaderValue::from_static("session=SECRET")) + .with_header( + header::SET_COOKIE, + HeaderValue::from_static("session=SECRET"), + ) + .with_header( + HeaderName::from_static("x-api-key"), + HeaderValue::from_static("SECRET"), + ) + .with_header( + header::ORIGIN, + HeaderValue::from_static("https://app.example"), + ) + .with_header(header::USER_AGENT, sensitive_agent); + let debug = format!("{req:?}"); + + assert!(!debug.contains("SECRET"), "{debug}"); + for name in [ + "authorization", + "proxy-authorization", + "cookie", + "set-cookie", + "x-api-key", + ] { + assert!( + debug.contains(&format!(r#""{name}": [redacted]"#)), + "{name}: {debug}" + ); + } + assert!( + debug.contains(r#""origin": "https://app.example""#), + "{debug}" + ); + assert!(debug.contains(r#""user-agent": [redacted]"#), "{debug}"); + } + + #[test] + fn decoded_request_debug_redacts_credentials() { + let req = ConnectRequest::new(Url::parse("https://example.com/moq?jwt=SECRET").unwrap()) + .with_header( + http::header::AUTHORIZATION, + http::HeaderValue::from_static("Bearer SECRET"), + ) + .with_header( + http::header::USER_AGENT, + http::HeaderValue::from_static("moq-test"), + ); + let mut wire = Vec::new(); + req.encode(&mut wire).unwrap(); + + let decoded = ConnectRequest::decode(&mut wire.as_slice()).unwrap(); + assert_eq!(decoded.url.query(), Some("jwt=SECRET")); + assert_eq!( + format!("{decoded:?}"), + r#"ConnectRequest { url: "https://example.com/moq?[redacted]", protocols: [], headers: {"authorization": [redacted], "user-agent": "moq-test"} }"# + ); + } } diff --git a/rs/web-transport-quiche/examples/echo-client.rs b/rs/web-transport-quiche/examples/echo-client.rs index a8ffe38c..0c6141fe 100644 --- a/rs/web-transport-quiche/examples/echo-client.rs +++ b/rs/web-transport-quiche/examples/echo-client.rs @@ -29,7 +29,7 @@ async fn main() -> anyhow::Result<()> { let mut settings = web_transport_quiche::Settings::default(); settings.verify_peer = !args.tls_disable_verify; - tracing::info!("connecting to {}", args.url); + tracing::info!(host = ?args.url.host_str(), path = args.url.path(), "connecting"); let session = client .with_settings(settings) .connect(args.url) diff --git a/rs/web-transport-quiche/examples/echo-server.rs b/rs/web-transport-quiche/examples/echo-server.rs index 31964242..d36507e1 100644 --- a/rs/web-transport-quiche/examples/echo-server.rs +++ b/rs/web-transport-quiche/examples/echo-server.rs @@ -52,7 +52,8 @@ async fn main() -> anyhow::Result<()> { // Accept new connections. while let Some(conn) = server.accept().await { - tracing::info!("accepted connection, url={}", conn.url); + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(request = ?conn.request, "accepted connection"); tokio::spawn(async move { match run_conn(conn).await { @@ -68,8 +69,6 @@ async fn main() -> anyhow::Result<()> { } async fn run_conn(request: web_transport_quiche::h3::Request) -> anyhow::Result<()> { - tracing::info!("received WebTransport request: {}", request.url); - // Accept the session. let session = request.ok().await.context("failed to accept session")?; tracing::info!("accepted session"); diff --git a/rs/web-transport-quiche/src/client.rs b/rs/web-transport-quiche/src/client.rs index 0b25064e..7d0d546e 100644 --- a/rs/web-transport-quiche/src/client.rs +++ b/rs/web-transport-quiche/src/client.rs @@ -154,7 +154,11 @@ impl ClientBuilder { Some(url::Host::Domain(host)) => host.to_string(), Some(url::Host::Ipv4(ip)) => ip.to_string(), Some(url::Host::Ipv6(ip)) => ip.to_string(), - None => return Err(ClientError::InvalidUrl(request.url.to_string())), + // Without a host there is no userinfo, so this drops only the query and fragment. + None => { + let url = &request.url[..url::Position::AfterPath]; + return Err(ClientError::InvalidUrl(url.to_string())); + } }; Ok((host, request.url.port().unwrap_or(443))) diff --git a/rs/web-transport-quiche/src/connection.rs b/rs/web-transport-quiche/src/connection.rs index d7fb1d7b..a3922a39 100644 --- a/rs/web-transport-quiche/src/connection.rs +++ b/rs/web-transport-quiche/src/connection.rs @@ -171,7 +171,7 @@ impl Connection { // Accept logic is stateful, so use an Arc to share it. let accept = SessionAccept::new(conn.clone(), session_id); - tracing::debug!(url = %connect.request.url, "WebTransport connection established"); + tracing::debug!(request = ?connect.request, "WebTransport connection established"); let request = connect.request.clone(); let response = connect.response.clone(); diff --git a/rs/web-transport-quinn/examples/echo-client-advanced.rs b/rs/web-transport-quinn/examples/echo-client-advanced.rs index e650b098..d8f57d6b 100644 --- a/rs/web-transport-quinn/examples/echo-client-advanced.rs +++ b/rs/web-transport-quinn/examples/echo-client-advanced.rs @@ -58,7 +58,7 @@ async fn main() -> anyhow::Result<()> { let client = web_transport_quinn::Client::new(client, config); // Connect to the given URL. - tracing::info!(url = %args.url, "connecting"); + tracing::info!(host = ?args.url.host_str(), path = args.url.path(), "connecting"); let session = client.connect(args.url).await?; tracing::info!("connected"); diff --git a/rs/web-transport-quinn/examples/echo-client.rs b/rs/web-transport-quinn/examples/echo-client.rs index 8640345a..5db34f23 100644 --- a/rs/web-transport-quinn/examples/echo-client.rs +++ b/rs/web-transport-quinn/examples/echo-client.rs @@ -63,13 +63,14 @@ async fn main() -> anyhow::Result<()> { client.with_system_roots()? }; - tracing::info!(url = %args.url, "connecting"); - // Connect to the given URL. let mut request = ConnectRequest::new(args.url); if let Some(protocol) = &args.protocol { request = request.with_protocol(protocol); } + + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(?request, "connecting"); let session = client.connect(request).await?; tracing::info!("connected"); diff --git a/rs/web-transport-quinn/examples/echo-server-advanced.rs b/rs/web-transport-quinn/examples/echo-server-advanced.rs index 74f135bb..60e77bf6 100644 --- a/rs/web-transport-quinn/examples/echo-server-advanced.rs +++ b/rs/web-transport-quinn/examples/echo-server-advanced.rs @@ -103,17 +103,8 @@ async fn run_conn(conn: quinn::Incoming) -> anyhow::Result<()> { // Perform the WebTransport handshake. let request = web_transport_quinn::Request::accept(conn).await?; - tracing::info!(url = %request.url, "received WebTransport request"); - - // Log all HTTP3 headers - tracing::info!("HTTP3 headers:"); - for (name, value) in request.headers.iter() { - let value = value.to_str().context("invalid header value")?; - tracing::info!(" {}: {}", name, value); - } - if request.headers.is_empty() { - tracing::info!(" (empty)"); - } + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(request = ?*request, "received WebTransport request"); // Accept the session. let session = request.ok().await.context("failed to accept session")?; diff --git a/rs/web-transport-quinn/examples/echo-server.rs b/rs/web-transport-quinn/examples/echo-server.rs index 521eefe4..65447119 100644 --- a/rs/web-transport-quinn/examples/echo-server.rs +++ b/rs/web-transport-quinn/examples/echo-server.rs @@ -82,7 +82,8 @@ async fn run_conn( request: web_transport_quinn::Request, protocol: Option, ) -> anyhow::Result<()> { - tracing::info!(url = %request.url, "received WebTransport request"); + // The Debug output redacts credentials, such as the query and header values. + tracing::info!(request = ?*request, "received WebTransport request"); // Negotiate protocol if both client and server support it. let negotiated = protocol.filter(|p| request.protocols.contains(p)); From f23fd62fe5615af0354ed48de4478fbb2f12873f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 1 Nov 2026 21:06:55 -0800 Subject: [PATCH 2/3] test(proto): don't depend on decoded header order qpack::Headers stores fields in a HashMap, so a decoded ConnectRequest's headers come back in random order. The decoded Debug test compared the whole string and failed about half the time. Check each entry instead. Co-Authored-By: Claude Opus 5.5 --- rs/web-transport-proto/src/connect.rs | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/rs/web-transport-proto/src/connect.rs b/rs/web-transport-proto/src/connect.rs index d00d7a4a..ecb62710 100644 --- a/rs/web-transport-proto/src/connect.rs +++ b/rs/web-transport-proto/src/connect.rs @@ -1110,9 +1110,16 @@ mod tests { let decoded = ConnectRequest::decode(&mut wire.as_slice()).unwrap(); assert_eq!(decoded.url.query(), Some("jwt=SECRET")); - assert_eq!( - format!("{decoded:?}"), - r#"ConnectRequest { url: "https://example.com/moq?[redacted]", protocols: [], headers: {"authorization": [redacted], "user-agent": "moq-test"} }"# - ); + + // Decoded header order is unspecified, so check each entry separately. + let debug = format!("{decoded:?}"); + assert!(!debug.contains("SECRET"), "{debug}"); + for expected in [ + r#"url: "https://example.com/moq?[redacted]""#, + r#""authorization": [redacted]"#, + r#""user-agent": "moq-test""#, + ] { + assert!(debug.contains(expected), "{expected}: {debug}"); + } } } From 9783d04b9a5353d73ef91668a980b807e40d6303 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 1 Nov 2026 22:32:35 -0800 Subject: [PATCH 3/3] fix(quiche): keep only the scheme in the hostless InvalidUrl error A hostless URL keeps its data in the path, so `data:text/plain,SECRET` still leaked through the error's URL prefix. Report only the scheme. Co-Authored-By: Claude Opus 5.5 --- rs/web-transport-quiche/src/client.rs | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/rs/web-transport-quiche/src/client.rs b/rs/web-transport-quiche/src/client.rs index 7d0d546e..deaf156e 100644 --- a/rs/web-transport-quiche/src/client.rs +++ b/rs/web-transport-quiche/src/client.rs @@ -154,10 +154,11 @@ impl ClientBuilder { Some(url::Host::Domain(host)) => host.to_string(), Some(url::Host::Ipv4(ip)) => ip.to_string(), Some(url::Host::Ipv6(ip)) => ip.to_string(), - // Without a host there is no userinfo, so this drops only the query and fragment. + // Keep only the scheme: a hostless URL's path can carry data, such as + // `data:text/plain,SECRET`. None => { - let url = &request.url[..url::Position::AfterPath]; - return Err(ClientError::InvalidUrl(url.to_string())); + let scheme = request.url.scheme(); + return Err(ClientError::InvalidUrl(format!("{scheme} URL has no host"))); } }; @@ -181,3 +182,16 @@ impl Connecting { Connection::connect(conn, self.request).await } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn hostless_url_error_omits_url_content() { + let request = + ConnectRequest::new(url::Url::parse("data:text/plain,SECRET?q=SECRET").unwrap()); + let err = ClientBuilder::target(&request).unwrap_err(); + assert_eq!(err.to_string(), "invalid URL: data URL has no host"); + } +}