Add HTTP/2 fallback for SSH tunnels (#61964)

## Why

SSH tunnels need a working transport when UDP is blocked or a QUIC connection cannot complete an HTTP/3 CONNECT request.

## What changed

- Race TLS HTTP/2 CONNECT against HTTP/3 after a 250 ms QUIC head start, selecting the first successful CONNECT response.
- Verify the gateway before obtaining credentials, treat CONNECT rejection as terminal, and include admission in the setup timeout.
- Preserve bounded buffering, TCP half-close behavior, and SSH exit on remote EOF over HTTP/2. Keep peer-supplied debug text out of SSH errors.

## Testing

Add local TLS HTTP/2 and HTTP/3 peer tests for transport selection, blocked UDP, stalled HTTP/3, terminal rejection, setup deadlines, certificate verification, address retries, and bidirectional forwarding with both half-close orders.

GitOrigin-RevId: a1cde88dff7a4e5e6574cf12eacb453551f01b72
This commit is contained in:
richardopenai
2026-11-17 04:41:39 +00:00
committed by copyberry
parent d8d840d32a
commit c8d1ba814e
10 changed files with 845 additions and 57 deletions
+2
View File
@@ -5144,6 +5144,7 @@ dependencies = [
"anyhow",
"bytes",
"clap",
"h2",
"h3",
"h3-quinn",
"http 1.4.0",
@@ -5155,6 +5156,7 @@ dependencies = [
"rustls-native-certs",
"serde_json",
"tokio",
"tokio-rustls",
"url",
]
+2
View File
@@ -11,6 +11,7 @@ doctest = false
anyhow = { workspace = true }
bytes = { workspace = true }
clap = { workspace = true, features = ["derive"] }
h2 = "0.4.19"
h3 = { git = "https://github.com/hyperium/h3", rev = "e07e69412876f7e26f026bd75a48b2704d8c8283" }
h3-quinn = { git = "https://github.com/hyperium/h3", rev = "e07e69412876f7e26f026bd75a48b2704d8c8283" }
http = { workspace = true }
@@ -20,6 +21,7 @@ rustls = { workspace = true, features = ["ring", "std"] }
rustls-native-certs = { workspace = true }
serde_json = { workspace = true }
tokio = { workspace = true, features = ["io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }
tokio-rustls = { workspace = true }
url = { workspace = true }
[dev-dependencies]
+166
View File
@@ -0,0 +1,166 @@
//! TLS HTTP/2 CONNECT transport for the same trusted proxy origin as HTTP/3.
//! Each connection carries one CONNECT and preserves TCP half-close and bounded buffering.
use std::future::Future;
use std::future::poll_fn;
use std::net::SocketAddr;
use std::pin::Pin;
use std::sync::Arc;
use std::task::Poll;
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use anyhow::ensure;
use bytes::Bytes;
use http::Request;
use rustls::pki_types::ServerName;
use tokio::io::AsyncRead;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWrite;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;
use crate::MAX_FIELD_SECTION_SIZE;
use crate::ProxyTarget;
use crate::diagnostics::Code;
const COPY_BUFFER_SIZE: usize = 64 * 1024;
pub(super) type Sender = h2::client::SendRequest<Bytes>;
pub(super) type Connection =
h2::client::Connection<tokio_rustls::client::TlsStream<TcpStream>, Bytes>;
pub(super) async fn connect(
target: &ProxyTarget,
tls: Arc<rustls::ClientConfig>,
addresses: &[SocketAddr],
) -> Result<(Sender, Connection)> {
let name = ServerName::try_from(target.host.clone())
.map_err(|_| anyhow!("invalid proxy TLS server name"))?;
let connector = TlsConnector::from(tls);
for &address in addresses {
let attempt = async {
let socket = TcpStream::connect(address).await?;
socket.set_nodelay(/*nodelay*/ true)?;
let stream = connector.connect(name.clone(), socket).await?;
ensure!(
stream.get_ref().1.alpn_protocol() == Some(b"h2"),
"proxy did not negotiate HTTP/2"
);
let (sender, mut connection) = h2::client::Builder::new()
.max_header_list_size(MAX_FIELD_SECTION_SIZE as u32)
.max_send_buffer_size(COPY_BUFFER_SIZE)
.initial_max_send_streams(0)
.enable_push(/*enabled*/ false)
.handshake(stream)
.await?;
// A TLS peer advertising h2 is not usable until it sends SETTINGS
// admitting a stream. Poll the connection without sending credentials.
poll_fn(|cx| {
if let Poll::Ready(result) = Pin::new(&mut connection).poll(cx) {
return Poll::Ready(Err(result
.err()
.map(anyhow::Error::from)
.unwrap_or_else(|| anyhow!("HTTP/2 proxy closed during setup"))));
}
if connection.max_concurrent_send_streams() > 0 {
Poll::Ready(Ok(()))
} else {
Poll::Pending
}
})
.await?;
Ok::<_, anyhow::Error>((sender, connection))
};
match tokio::time::timeout(std::time::Duration::from_secs(5), attempt).await {
Ok(Ok(connection)) => return Ok(connection),
Ok(Err(error))
if error.chain().any(|cause| {
matches!(
cause.downcast_ref::<rustls::Error>(),
Some(rustls::Error::InvalidCertificate(_))
)
}) =>
{
return Err(anyhow!("HTTP/2 proxy certificate verification failed"));
}
_ => {}
}
}
Err(anyhow!("HTTP/2 proxy connection failed"))
}
pub(super) async fn admit(
sender: Sender,
request: Request<()>,
) -> Result<(h2::SendStream<Bytes>, h2::RecvStream)> {
let mut sender = sender.ready().await.map_err(|_| stream_error())?;
let (response, mut send) = sender
.send_request(request, /*end_of_stream*/ false)
.map_err(|_| stream_error())?;
let response = response.await.map_err(|_| stream_error())?;
let status = response.status();
if !status.is_success() {
send.send_reset(h2::Reason::CANCEL);
return Err(Code::Rejected(status).into());
}
Ok((send, response.into_body()))
}
pub(super) async fn bridge(
mut read: impl AsyncRead + Unpin,
mut write: impl AsyncWrite + Unpin,
mut send: h2::SendStream<Bytes>,
mut recv: h2::RecvStream,
exit_on_remote_eof: bool,
) -> Result<()> {
let upload = async {
let mut buffer = vec![0; COPY_BUFFER_SIZE];
loop {
let count = read.read(&mut buffer).await.context("reading local TCP")?;
if count == 0 {
send.send_data(Bytes::new(), /*end_of_stream*/ true)
.map_err(|_| stream_error())?;
return Ok::<(), anyhow::Error>(());
}
let mut data = Bytes::copy_from_slice(&buffer[..count]);
send.reserve_capacity(data.len());
while !data.is_empty() {
let capacity = poll_fn(|cx| send.poll_capacity(cx))
.await
.context("HTTP/2 send stream closed")?
.map_err(|_| stream_error())?;
let count = capacity.min(data.len());
send.send_data(data.split_to(count), /*end_of_stream*/ false)
.map_err(|_| stream_error())?;
}
}
};
let download = async {
while let Some(data) = recv.data().await {
let data = data.map_err(|_| stream_error())?;
write.write_all(&data).await.context("writing local TCP")?;
recv.flow_control()
.release_capacity(data.len())
.map_err(|_| stream_error())?;
}
write.shutdown().await.context("half-closing local TCP")?;
Ok::<(), anyhow::Error>(())
};
tokio::pin!(upload, download);
tokio::select! {
result = &mut upload => { result?; download.await }
result = &mut download => { result?; if exit_on_remote_eof { Ok(()) } else { upload.await } }
}
}
fn stream_error() -> anyhow::Error {
// Peer-supplied GOAWAY debug text must not reach diagnostics.
anyhow!("HTTP/2 CONNECT stream failed")
}
#[cfg(test)]
#[path = "http2_tests.rs"]
pub(super) mod tests;
+191
View File
@@ -0,0 +1,191 @@
//! Test TLS admission, stream forwarding, and CONNECT rejection.
#![cfg(test)]
use std::sync::Arc;
use std::time::Duration;
use anyhow::Result;
use bytes::Bytes;
use http::HeaderMap;
use http::HeaderValue;
use http::Method;
use http::Response;
use pretty_assertions::assert_eq;
use rcgen::CertifiedKey;
use rcgen::generate_simple_self_signed;
use rustls::pki_types::PrivatePkcs8KeyDer;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener;
use tokio::time::timeout;
use tokio_rustls::TlsAcceptor;
use super::connect;
use crate::ProxyTarget;
use crate::diagnostics::Code;
use crate::transport::Connection;
pub(crate) fn tls_configs() -> Result<(rustls::ServerConfig, rustls::ClientConfig)> {
let CertifiedKey { cert, signing_key } =
generate_simple_self_signed(vec!["127.0.0.1".to_string()])?;
let provider = Arc::new(rustls::crypto::ring::default_provider());
let mut server = rustls::ServerConfig::builder_with_provider(provider.clone())
.with_safe_default_protocol_versions()?
.with_no_client_auth()
.with_single_cert(
vec![cert.der().clone()],
PrivatePkcs8KeyDer::from(signing_key.serialize_der()).into(),
)?;
server.alpn_protocols = vec![b"h3".to_vec(), b"h2".to_vec()];
let mut roots = rustls::RootCertStore::empty();
roots.add(cert.der().clone())?;
let mut client = rustls::ClientConfig::builder_with_provider(provider)
.with_safe_default_protocol_versions()?
.with_root_certificates(roots)
.with_no_client_auth();
client.alpn_protocols = vec![b"h2".to_vec()];
Ok((server, client))
}
pub(crate) fn target(address: std::net::SocketAddr) -> ProxyTarget {
ProxyTarget {
host: address.ip().to_string(),
port: address.port(),
authority: "127.0.0.1:22".to_string(),
}
}
#[tokio::test]
async fn trusted_h2_requires_settings_and_certificate() -> Result<()> {
timeout(Duration::from_secs(5), async {
let (server, client) = tls_configs()?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
let task = tokio::spawn(async move {
let tls = TlsAcceptor::from(Arc::new(server))
.accept(listener.accept().await?.0)
.await?;
let mut connection: h2::server::Connection<_, Bytes> =
h2::server::handshake(tls).await?;
let _ = connection.accept().await;
Ok::<_, anyhow::Error>(())
});
let (sender, connection) = connect(&target(address), Arc::new(client), &[address]).await?;
drop((sender, connection));
task.await??;
let (bad_server, _) = tls_configs()?;
let (_, client) = tls_configs()?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
let task = tokio::spawn(async move {
TlsAcceptor::from(Arc::new(bad_server))
.accept(listener.accept().await.unwrap().0)
.await
});
assert!(
connect(&target(address), Arc::new(client), &[address])
.await
.is_err()
);
let _ = task.await?;
Ok::<_, anyhow::Error>(())
})
.await?
}
#[tokio::test]
async fn forwards_bounded_data_in_both_half_close_orders_and_rejects_before_upload() -> Result<()> {
timeout(Duration::from_secs(15), async {
for (remote_first, status) in [(false, 200), (true, 200), (false, 403)] {
let (server, client) = tls_configs()?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
let upload = vec![42; 192 * 1024];
let download = vec![81; 192 * 1024];
let expected_upload = upload.clone();
let response_bytes = download.clone();
let (done, finished) = tokio::sync::oneshot::channel();
let peer = tokio::spawn(async move {
let tls = TlsAcceptor::from(Arc::new(server)).accept(listener.accept().await?.0).await?;
let mut connection = h2::server::handshake(tls).await?;
let (request, mut respond) = connection.accept().await.unwrap()?;
assert_eq!(request.method(), Method::CONNECT);
assert_eq!(request.uri().authority().unwrap().as_str(), "127.0.0.1:22");
assert_eq!(request.headers()[http::header::AUTHORIZATION], "Bearer fixture");
assert_eq!(request.headers()["x-portals-auth-mode"], "oauth");
assert_eq!(request.headers()["x-portals-environment-id"], "env_fixture");
assert_eq!(request.headers()["x-portals-port"], "22");
let mut send = respond.send_response(Response::builder().status(status).body(())?, status != 200)?;
let handler = async move {
if status != 200 { return Ok::<_, anyhow::Error>(()); }
if remote_first { send.send_data(Bytes::from(response_bytes.clone()), true)?; }
let mut body = request.into_body();
let mut received = Vec::new();
while let Some(data) = body.data().await { let data = data?; received.extend_from_slice(&data); body.flow_control().release_capacity(data.len())?; }
assert_eq!(received, expected_upload);
if !remote_first { send.send_data(Bytes::from(response_bytes), true)?; }
Ok(())
};
let complete = async { handler.await?; finished.await?; Ok::<_, anyhow::Error>(()) };
tokio::pin!(complete);
tokio::select! { result = &mut complete => result, closed = std::future::poll_fn(|cx| connection.poll_closed(cx)) => { closed?; complete.await } }
});
let (sender, connection) = connect(&target(address), Arc::new(client), &[address]).await?;
let mut headers = HeaderMap::new();
headers.insert("x-portals-auth-mode", HeaderValue::from_static("oauth"));
headers.insert("x-portals-environment-id", HeaderValue::from_static("env_fixture"));
headers.insert("x-portals-port", HeaderValue::from_static("22"));
let request = target(address).request(headers, HeaderValue::from_static("Bearer fixture"))?;
let (mut local, socket) = tokio::io::duplex(256 * 1024);
let (input, output) = tokio::io::split(socket);
let relay = tokio::spawn(async move {
Connection::Http2(sender, Box::new(connection)).admit(request).await?
.relay(input, output, /*exit_on_remote_eof*/ false).await
});
if status == 200 {
let mut received = Vec::new();
if remote_first { local.read_to_end(&mut received).await?; local.write_all(&upload).await?; local.shutdown().await?; }
else { local.write_all(&upload).await?; local.shutdown().await?; local.read_to_end(&mut received).await?; }
assert_eq!(received.len(), download.len());
assert!(received == download);
relay.await??;
} else {
local.write_all(b"must not be forwarded").await?;
let error = relay.await?.unwrap_err();
assert!(matches!(error.downcast_ref::<Code>(), Some(Code::Rejected(status)) if status.as_u16() == 403));
}
let _ = done.send(());
peer.await??;
}
Ok::<_, anyhow::Error>(())
}).await?
}
#[tokio::test]
async fn retries_next_address_after_non_certificate_tls_failure() -> Result<()> {
timeout(Duration::from_secs(5), async {
let (server, client) = tls_configs()?;
let bad = TcpListener::bind("127.0.0.1:0").await?;
let good = TcpListener::bind("127.0.0.1:0").await?;
let addresses = [bad.local_addr()?, good.local_addr()?];
let bad_task = tokio::spawn(async move {
drop(bad.accept().await.unwrap());
});
let good_task = tokio::spawn(async move {
let tls = TlsAcceptor::from(Arc::new(server))
.accept(good.accept().await?.0)
.await?;
let mut connection: h2::server::Connection<_, Bytes> =
h2::server::handshake(tls).await?;
let _ = connection.accept().await;
Ok::<_, anyhow::Error>(())
});
let connection = connect(&target(addresses[0]), Arc::new(client), &addresses).await?;
drop(connection);
bad_task.await?;
good_task.await??;
Ok::<_, anyhow::Error>(())
})
.await?
}
+37 -19
View File
@@ -39,7 +39,9 @@ use url::Url;
mod control;
mod diagnostics;
mod http2;
mod ssh;
mod transport;
pub use ssh::run_ssh_proxy;
@@ -330,7 +332,7 @@ fn control_input(
Ok((initial_metadata, tokens))
}
fn client_config(mut transport: quinn::TransportConfig) -> Result<quinn::ClientConfig> {
fn tls_config() -> Result<rustls::ClientConfig> {
let native = rustls_native_certs::load_native_certs();
let mut roots = rustls::RootCertStore::empty();
roots.add_parsable_certificates(native.certs);
@@ -339,12 +341,16 @@ fn client_config(mut transport: quinn::TransportConfig) -> Result<quinn::ClientC
"no native TLS roots: {:?}",
native.errors
);
let mut tls = rustls::ClientConfig::builder_with_provider(Arc::new(
Ok(rustls::ClientConfig::builder_with_provider(Arc::new(
rustls::crypto::ring::default_provider(),
))
.with_safe_default_protocol_versions()?
.with_root_certificates(roots)
.with_no_client_auth();
.with_no_client_auth())
}
fn client_config(mut transport: quinn::TransportConfig) -> Result<quinn::ClientConfig> {
let mut tls = tls_config()?;
tls.alpn_protocols = vec![b"h3".to_vec()];
let mut config = quinn::ClientConfig::new(Arc::new(QuicClientConfig::try_from(tls)?));
transport.max_idle_timeout(Some(Duration::from_secs(30).try_into()?));
@@ -447,7 +453,7 @@ async fn serve(
let request = target.request(headers.connect.clone(), headers.auth.borrow().clone())?;
tokio::spawn(async move {
let (read, write) = socket.into_split();
if let Err(error) = bridge(read, write, &mut sender, request, BridgeMode::Listener(draining)).await {
if let Err(error) = bridge(read, write, &mut sender, request, draining).await {
diagnostics.report(
Phase::Connect,
&error,
@@ -530,29 +536,35 @@ async fn serve(
}
}
enum BridgeMode {
Listener(mpsc::Sender<()>),
ProxyCommand,
}
async fn bridge(
mut local_read: impl AsyncRead + Unpin,
mut local_write: impl AsyncWrite + Unpin,
local_read: impl AsyncRead + Unpin,
local_write: impl AsyncWrite + Unpin,
sender: &mut h3::client::SendRequest<h3_quinn::OpenStreams, Bytes>,
request: Request<()>,
mode: BridgeMode,
draining: mpsc::Sender<()>,
) -> Result<()> {
let mut stream = match sender.send_request(request).await {
Ok(stream) => stream,
Err(error) => {
if let BridgeMode::Listener(draining) = &mode
&& matches!(error, h3::error::StreamError::RemoteClosing { .. })
{
if matches!(error, h3::error::StreamError::RemoteClosing { .. }) {
let _ = draining.try_send(());
}
return Err(error).context("sending CONNECT");
}
};
check_h3_response(&mut stream).await?;
bridge_h3_stream(
local_read,
local_write,
stream,
/*exit_on_remote_eof*/ false,
)
.await
}
type H3Stream = h3::client::RequestStream<h3_quinn::BidiStream<Bytes>, Bytes>;
async fn check_h3_response(stream: &mut H3Stream) -> Result<()> {
let status = stream
.recv_response()
.await
@@ -561,6 +573,15 @@ async fn bridge(
if !status.is_success() {
return Err(Code::Rejected(status).into());
}
Ok(())
}
async fn bridge_h3_stream(
mut local_read: impl AsyncRead + Unpin,
mut local_write: impl AsyncWrite + Unpin,
stream: H3Stream,
exit_on_remote_eof: bool,
) -> Result<()> {
let (mut send, mut recv) = stream.split();
let upload = async {
let mut buffer = vec![0; 64 * 1024];
@@ -591,10 +612,7 @@ async fn bridge(
result = &mut upload => { result?; download.await }
result = &mut download => {
result?;
match mode {
BridgeMode::Listener(_) => upload.await,
BridgeMode::ProxyCommand => Ok(()),
}
if exit_on_remote_eof { Ok(()) } else { upload.await }
}
}
}
+9 -8
View File
@@ -327,16 +327,17 @@ async fn stdio_propagates_half_close_and_exits_on_gateway_eof_or_rejection() ->
input.shutdown().await?;
}
let mut output = Vec::new();
let result = timeout(
Duration::from_secs(3),
super::bridge(
let result = timeout(Duration::from_secs(3), async {
let mut stream = sender.send_request(request).await?;
super::check_h3_response(&mut stream).await?;
super::bridge_h3_stream(
reader,
&mut output,
&mut sender,
request,
super::BridgeMode::ProxyCommand,
),
)
stream,
/*exit_on_remote_eof*/ true,
)
.await
})
.await?;
match index {
0 => {
+16 -30
View File
@@ -13,13 +13,10 @@ use tokio::io::AsyncWrite;
use tokio::io::AsyncWriteExt;
use super::Args;
use super::BridgeMode;
use super::Code;
use super::ProxyConnection;
use super::ProxyTarget;
use super::bridge;
use super::client_config;
use super::control::bearer_header;
use super::transport::Config as TransportConfig;
// Only gateways shipped with the CLI may receive the signed-in account's credential.
pub(super) const PUBLIC_GATEWAY: &str = "https://codex-portals.api.openai.com";
@@ -84,17 +81,12 @@ pub async fn run_ssh_proxy(
stdout: impl AsyncWrite + Unpin,
) -> Result<()> {
let (target, headers) = args.ssh_destination()?;
// Linux can advertise UDP segmentation on paths where batched packets are lost.
// Single datagrams keep bulk SSH transfers moving on those paths.
let mut transport = quinn::TransportConfig::default();
transport.enable_segmentation_offload(!cfg!(target_os = "linux"));
let ProxyConnection {
endpoint: _endpoint,
quic: _quic,
mut connection,
mut sender,
} = ProxyConnection::connect(&target, &client_config(transport)?).await?;
let request = target.request(headers, oauth_bearer(&access_token.await?)?)?;
let tunnel = TransportConfig::new(super::tls_config()?)?
.open(&target, async {
target.request(headers, oauth_bearer(&access_token.await?)?)
})
.await
.map_err(safe_tunnel_error)?;
// OpenSSH needs EOF when the peer finishes, even if it still holds stdin open.
// A detached blocking reader lets the Tokio runtime exit in that case.
@@ -120,13 +112,7 @@ pub async fn run_ssh_proxy(
};
let _ = outcome.send(result);
})?;
let relay = bridge(
reader,
stdout,
&mut sender,
request,
BridgeMode::ProxyCommand,
);
let relay = tunnel.relay(reader, stdout, /*exit_on_remote_eof*/ true);
let forward = async {
tokio::pin!(relay);
tokio::select! {
@@ -134,17 +120,17 @@ pub async fn run_ssh_proxy(
result = input_done => { result??; relay.await }
}
};
tokio::pin!(forward);
let result = tokio::select! {
result = &mut forward => result,
// A closing connection may still have a complete status or payload buffered.
_ = connection.wait_idle() => forward.await,
};
let result = forward.await;
// A peer's close reason can contain arbitrary text. Only surface the HTTP status.
result.map_err(|err| match err.downcast_ref::<Code>() {
result.map_err(safe_tunnel_error)
}
fn safe_tunnel_error(err: anyhow::Error) -> anyhow::Error {
match err.downcast_ref::<Code>() {
Some(Code::Rejected(status)) => Code::Rejected(*status).into(),
Some(Code::Timeout) => Code::Timeout.into(),
_ => anyhow::anyhow!("SSH tunnel stream failed"),
})
}
}
#[cfg(test)]
+10
View File
@@ -5,6 +5,16 @@ use super::Args;
use super::PUBLIC_GATEWAY;
use super::oauth_bearer;
use super::run_ssh_proxy;
#[test]
fn setup_and_relay_errors_do_not_expose_peer_debug_text() {
let error = super::safe_tunnel_error(anyhow::anyhow!("peer supplied secret"));
assert!(!error.to_string().contains("secret"));
let denied = super::safe_tunnel_error(
crate::diagnostics::Code::Rejected(http::StatusCode::FORBIDDEN).into(),
);
assert!(denied.to_string().contains("403"));
}
use clap::Parser;
use http::HeaderMap;
use http::Method;
+209
View File
@@ -0,0 +1,209 @@
//! Select the first authenticated CONNECT, preferring QUIC with a short head start.
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use bytes::Bytes;
use http::Request;
use quinn::crypto::rustls::QuicClientConfig;
use tokio::io::AsyncRead;
use tokio::io::AsyncWrite;
use crate::PROXY_CONNECT_TIMEOUT;
use crate::ProxyConnection;
use crate::ProxyTarget;
use crate::diagnostics::Code;
use crate::http2;
const QUIC_HEAD_START: Duration = Duration::from_millis(250);
#[derive(Clone)]
pub(super) struct Config {
quic: quinn::ClientConfig,
tls: Arc<rustls::ClientConfig>,
}
impl Config {
pub(super) fn new(mut tls: rustls::ClientConfig) -> Result<Self> {
tls.enable_early_data = false;
tls.alpn_protocols = vec![b"h3".to_vec()];
let mut quic = quinn::ClientConfig::new(Arc::new(QuicClientConfig::try_from(tls.clone())?));
let mut transport = quinn::TransportConfig::default();
transport.enable_segmentation_offload(!cfg!(target_os = "linux"));
transport.max_idle_timeout(Some(Duration::from_secs(30).try_into()?));
transport.keep_alive_interval(Some(Duration::from_secs(10)));
quic.transport_config(Arc::new(transport));
tls.alpn_protocols = vec![b"h2".to_vec()];
Ok(Self {
quic,
tls: Arc::new(tls),
})
}
/// The request future is polled only after a gateway has passed TLS verification.
pub(super) async fn open(
&self,
target: &ProxyTarget,
request: impl Future<Output = Result<Request<()>>>,
) -> Result<Tunnel> {
tokio::time::timeout(PROXY_CONNECT_TIMEOUT, async {
let quic = async {
ProxyConnection::connect(target, &self.quic)
.await
.map(|p| Connection::Http3(Box::new(p)))
};
let tcp = async {
tokio::time::sleep(QUIC_HEAD_START).await;
let addresses: Vec<_> =
tokio::net::lookup_host((target.host.as_str(), target.port))
.await?
.collect();
http2::connect(target, self.tls.clone(), &addresses)
.await
.map(|(sender, connection)| Connection::Http2(sender, Box::new(connection)))
};
tokio::pin!(quic, tcp);
tokio::select! {
biased;
first = &mut quic => finish_setup(first, tcp, request).await,
first = &mut tcp => finish_setup(first, quic, request).await,
}
})
.await
.context(Code::Timeout)?
}
}
async fn finish_setup(
first: Result<Connection>,
other: impl Future<Output = Result<Connection>>,
request: impl Future<Output = Result<Request<()>>>,
) -> Result<Tunnel> {
let first = match first {
Ok(connection) => connection,
Err(_) => return other.await?.admit(request.await?).await,
};
let request = request.await?;
let preferred = first.admit(request.clone());
let alternate = async { other.await?.admit(request).await };
tokio::pin!(preferred, alternate);
tokio::select! {
biased;
result = &mut preferred => complete_or_try_other(result, alternate).await,
result = &mut alternate => complete_or_try_other(result, preferred).await,
}
}
async fn complete_or_try_other(
result: Result<Tunnel>,
other: impl Future<Output = Result<Tunnel>>,
) -> Result<Tunnel> {
match result {
Ok(tunnel) => Ok(tunnel),
Err(error)
if error
.downcast_ref::<Code>()
.is_some_and(|c| matches!(c, Code::Rejected(_))) =>
{
Err(error)
}
Err(_) => other.await,
}
}
pub(super) enum Connection {
Http3(Box<ProxyConnection>),
Http2(http2::Sender, Box<http2::Connection>),
}
pub(super) enum Tunnel {
Http3(Box<(ProxyConnection, crate::H3Stream)>),
Http2 {
connection: Box<http2::Connection>,
send: h2::SendStream<Bytes>,
recv: h2::RecvStream,
},
}
impl Connection {
pub(super) async fn admit(self, request: Request<()>) -> Result<Tunnel> {
match self {
Self::Http3(mut proxy) => {
let admit = async {
let mut stream = proxy
.sender
.send_request(request)
.await
.context("sending CONNECT")?;
crate::check_h3_response(&mut stream).await?;
Ok::<_, anyhow::Error>(stream)
};
let stream = tokio::select! {
result = admit => result?,
_ = proxy.connection.wait_idle() => return Err(anyhow!("HTTP/3 proxy transport closed")),
};
Ok(Tunnel::Http3(Box::new((*proxy, stream))))
}
Self::Http2(sender, mut connection) => {
let (send, recv) = tokio::select! {
result = http2::admit(sender, request) => result?,
_ = &mut *connection => return Err(anyhow!("HTTP/2 proxy transport closed")),
};
Ok(Tunnel::Http2 {
connection,
send,
recv,
})
}
}
}
}
impl Tunnel {
pub(super) async fn relay(
self,
input: impl AsyncRead + Unpin,
output: impl AsyncWrite + Unpin,
exit_on_remote_eof: bool,
) -> Result<()> {
match self {
Self::Http3(tunnel) => {
let (mut proxy, stream) = *tunnel;
let forward = crate::bridge_h3_stream(input, output, stream, exit_on_remote_eof);
tokio::pin!(forward);
tokio::select! {
result = &mut forward => result,
_ = proxy.connection.wait_idle() => forward.await,
}
}
Self::Http2 {
mut connection,
send,
recv,
} => {
let result = {
let forward = http2::bridge(input, output, send, recv, exit_on_remote_eof);
tokio::pin!(forward);
tokio::select! {
result = &mut forward => result,
result = &mut *connection => {
result.map_err(|_| anyhow!("HTTP/2 proxy transport closed"))?;
return forward.await;
},
}
};
result?;
connection
.await
.map_err(|_| anyhow!("HTTP/2 proxy transport closed"))
}
}
}
}
#[cfg(test)]
#[path = "transport_tests.rs"]
mod tests;
+203
View File
@@ -0,0 +1,203 @@
//! Exercise admission, QUIC preference, and fallback against real H2/H3 peers.
#![cfg(test)]
use std::net::UdpSocket;
use std::sync::Arc;
use std::time::Duration;
use anyhow::Result;
use bytes::Bytes;
use http::HeaderMap;
use http::HeaderValue;
use http::Request;
use http::Response;
use http::StatusCode;
use tokio::net::TcpListener;
use tokio::time::timeout;
use super::Config;
use super::Tunnel;
use crate::http2::tests::target;
use crate::http2::tests::tls_configs;
async fn sockets() -> Result<(TcpListener, UdpSocket)> {
for _ in 0..32 {
let udp = UdpSocket::bind("127.0.0.1:0")?;
if let Ok(tcp) = TcpListener::bind(udp.local_addr()?).await {
udp.set_nonblocking(true)?;
return Ok((tcp, udp));
}
}
anyhow::bail!("could not reserve TCP and UDP test port")
}
fn endpoint(udp: UdpSocket, tls: rustls::ServerConfig) -> Result<quinn::Endpoint> {
let crypto = quinn::crypto::rustls::QuicServerConfig::try_from(tls)?;
Ok(quinn::Endpoint::new(
quinn::EndpointConfig::default(),
Some(quinn::ServerConfig::with_crypto(Arc::new(crypto))),
udp,
Arc::new(quinn::TokioRuntime),
)?)
}
fn request(address: std::net::SocketAddr) -> Result<Request<()>> {
target(address).request(HeaderMap::new(), HeaderValue::from_static("Bearer fixture"))
}
async fn h2_peer(tcp: TcpListener, tls: rustls::ServerConfig) -> Result<()> {
let tls = tokio_rustls::TlsAcceptor::from(Arc::new(tls))
.accept(tcp.accept().await?.0)
.await?;
let mut conn: h2::server::Connection<_, Bytes> = h2::server::handshake(tls).await?;
let (req, mut send) = conn.accept().await.unwrap()?;
assert_eq!(req.headers()["authorization"], "Bearer fixture");
let _stream = send.send_response(Response::new(()), false)?;
let _ = conn.accept().await;
Ok(())
}
#[tokio::test]
async fn prefers_admitted_quic_without_opening_tcp() -> Result<()> {
timeout(Duration::from_secs(5), async {
let (tls, client) = tls_configs()?;
let (tcp, udp) = sockets().await?;
let address = tcp.local_addr()?;
let endpoint = endpoint(udp, tls)?;
let peer = tokio::spawn(async move {
let quic = endpoint.accept().await.unwrap().await?;
let mut http: h3::server::Connection<_, Bytes> =
h3::server::Connection::new(h3_quinn::Connection::new(quic.clone())).await?;
let (req, mut stream) = http.accept().await?.unwrap().resolve_request().await?;
assert_eq!(req.headers()["authorization"], "Bearer fixture");
stream.send_response(Response::new(())).await?;
quic.closed().await;
Ok::<_, anyhow::Error>(())
});
let tunnel = Config::new(client)?
.open(&target(address), async { request(address) })
.await?;
assert!(matches!(tunnel, Tunnel::Http3(_)));
assert!(
timeout(Duration::from_millis(20), tcp.accept())
.await
.is_err()
);
drop(tunnel);
peer.abort();
Ok::<_, anyhow::Error>(())
})
.await?
}
#[tokio::test]
async fn blocked_udp_uses_admitted_h2() -> Result<()> {
let (tls, client) = tls_configs()?;
let (tcp, _udp) = sockets().await?;
let address = tcp.local_addr()?;
let peer = tokio::spawn(h2_peer(tcp, tls));
let tunnel = Config::new(client)?
.open(&target(address), async { request(address) })
.await?;
assert!(matches!(tunnel, Tunnel::Http2 { .. }));
drop(tunnel);
peer.await??;
Ok(())
}
#[tokio::test]
async fn quic_handshake_without_working_http3_does_not_defeat_h2() -> Result<()> {
timeout(Duration::from_secs(3), async {
let (tls, client) = tls_configs()?;
let (tcp, udp) = sockets().await?;
let address = tcp.local_addr()?;
let endpoint = endpoint(udp, tls.clone())?;
let quic = tokio::spawn(async move {
let connection = endpoint.accept().await.unwrap().await?;
connection.closed().await;
Ok::<_, anyhow::Error>(())
});
let h2 = tokio::spawn(h2_peer(tcp, tls));
let tunnel = Config::new(client)?
.open(&target(address), async { request(address) })
.await?;
assert!(matches!(tunnel, Tunnel::Http2 { .. }));
drop(tunnel);
h2.await??;
quic.abort();
Ok::<_, anyhow::Error>(())
})
.await?
}
#[tokio::test]
async fn admission_rejection_is_terminal() -> Result<()> {
let (tls, client) = tls_configs()?;
let (tcp, udp) = sockets().await?;
let address = tcp.local_addr()?;
let endpoint = endpoint(udp, tls)?;
let peer = tokio::spawn(async move {
let quic = endpoint.accept().await.unwrap().await?;
let mut http: h3::server::Connection<_, Bytes> =
h3::server::Connection::new(h3_quinn::Connection::new(quic.clone())).await?;
let (_, mut stream) = http.accept().await?.unwrap().resolve_request().await?;
stream
.send_response(Response::builder().status(StatusCode::FORBIDDEN).body(())?)
.await?;
quic.closed().await;
Ok::<_, anyhow::Error>(())
});
let error = Config::new(client)?
.open(&target(address), async { request(address) })
.await
.err()
.unwrap();
assert!(matches!(
error.downcast_ref::<crate::diagnostics::Code>(),
Some(crate::diagnostics::Code::Rejected(StatusCode::FORBIDDEN))
));
assert!(
timeout(Duration::from_millis(20), tcp.accept())
.await
.is_err()
);
peer.abort();
Ok(())
}
#[tokio::test]
async fn setup_deadline_includes_connect_response() -> Result<()> {
let (tls, client) = tls_configs()?;
let (tcp, udp) = sockets().await?;
let address = tcp.local_addr()?;
let endpoint = endpoint(udp, tls.clone())?;
let quic = tokio::spawn(async move {
let quic = endpoint.accept().await.unwrap().await?;
let mut http: h3::server::Connection<_, Bytes> =
h3::server::Connection::new(h3_quinn::Connection::new(quic.clone())).await?;
let _stream = http.accept().await?.unwrap().resolve_request().await?;
quic.closed().await;
Ok::<_, anyhow::Error>(())
});
let h2 = tokio::spawn(async move {
let tls = tokio_rustls::TlsAcceptor::from(Arc::new(tls))
.accept(tcp.accept().await?.0)
.await?;
let mut conn: h2::server::Connection<_, Bytes> = h2::server::handshake(tls).await?;
let _stream = conn.accept().await.unwrap()?;
let _ = conn.accept().await;
Ok::<_, anyhow::Error>(())
});
let result = timeout(
crate::PROXY_CONNECT_TIMEOUT + Duration::from_secs(2),
Config::new(client)?.open(&target(address), async { request(address) }),
)
.await?;
assert!(matches!(
result
.err()
.unwrap()
.downcast_ref::<crate::diagnostics::Code>(),
Some(crate::diagnostics::Code::Timeout)
));
quic.abort();
h2.abort();
Ok(())
}