Simplify SSH tunneling and honor system HTTPS proxies (#61975)

## What changed

- Make `codex tcp-tunnel` an SSH stdio helper, removing the loopback listener, stdin control protocol, and JSON diagnostics.
- Add `--token-file` for one-use credentials, consumed only after gateway verification, with environment-based OAuth routing or a legacy IPv4 `--target`.
- Honor system HTTPS proxy settings without attempting direct QUIC, and keep gateway credentials inside verified TLS.
- Race direct TCP addresses through TLS and HTTP/2 readiness so stalled peers do not block a working address.

## Testing

Add coverage for proxy credential isolation and stalled TLS peers, plus an opt-in Linux OpenSSH integration test for complete uploads and remote exit while local stdin remains open.

GitOrigin-RevId: 62423c8a8267842c9e401b3f9094c7278c47a490
This commit is contained in:
richardopenai
2026-11-17 06:03:45 +00:00
committed by copyberry
parent 9a5a78925d
commit 98323eddf9
16 changed files with 597 additions and 1697 deletions
+3 -2
View File
@@ -5148,15 +5148,16 @@ dependencies = [
"h3",
"h3-quinn",
"http 1.4.0",
"hyper-rustls",
"hyper-util",
"pretty_assertions",
"quinn",
"rand 0.9.3",
"rcgen",
"rustls",
"rustls-native-certs",
"serde_json",
"tokio",
"tokio-rustls",
"tower-service",
"url",
]
+8 -22
View File
@@ -1164,8 +1164,8 @@ async fn dispatch_cli(
arg0_paths,
)));
}
Some(Subcommand::TcpTunnel(args)) if args.auth_token_stdin => {
codex_tcp_tunnel::run(args).await?;
Some(Subcommand::TcpTunnel(args)) if args.token_file.is_some() => {
codex_tcp_tunnel::run_ssh_proxy_from_file(args, tokio::io::stdout()).await?;
}
Some(Subcommand::TcpTunnel(args)) => {
let config =
@@ -3516,32 +3516,18 @@ enabled = true
}
#[test]
fn tcp_tunnel_is_hidden_and_accepts_its_control_input_contract() {
fn tcp_tunnel_is_hidden_and_accepts_an_ssh_proxy_route() {
let root_help = help_from_args(&["codex", "--help"]);
assert!(!root_help.contains("tcp-tunnel"), "{root_help}");
let help = help_from_args(&["codex", "tcp-tunnel", "--help"]);
for option in [
"--target",
"--auth-token-stdin",
"--auth-token-updates-stdin",
"--connect-headers-stdin",
] {
assert!(help.contains(option), "{help}");
}
let cli = MultitoolCli::try_parse_from([
"codex",
"tcp-tunnel",
"--proxy-url",
"https://proxy.example.org",
"--proxy-origins-file",
"/tmp/approved-origins",
"--target",
"[::1]:22",
"--auth-token-stdin",
"--auth-token-updates-stdin",
"--connect-headers-stdin",
"--environment-id",
"ccarenv_test",
"--token-file",
"/private/token",
])
.expect("generic tunnel should parse");
.expect("SSH proxy route should parse");
assert!(matches!(cli.subcommand, Some(Subcommand::TcpTunnel(_))));
}
+3 -2
View File
@@ -15,13 +15,14 @@ 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 }
hyper-rustls = { version = "0.27", default-features = false, features = ["http1", "ring", "tls12"] }
hyper-util = { workspace = true, features = ["client-legacy", "client-proxy", "client-proxy-system", "http1"] }
quinn = { version = "0.11", default-features = false, features = ["runtime-tokio", "rustls-ring"] }
rand = { workspace = true }
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 }
tower-service = "0.3"
url = { workspace = true }
[dev-dependencies]
+5 -40
View File
@@ -1,44 +1,9 @@
# HTTP/3 TCP tunnel
# SSH portal transport
The ordinary Codex binary includes the hidden `codex tcp-tunnel` command. In listener mode, it forwards a loopback TCP listener to an explicitly selected host and port through a TLS-verified HTTP/3 CONNECT proxy. The proxy URL must be an exact HTTPS origin in the supplied policy file; the target is provided separately as `host:port` or `[IPv6]:port`.
Use `codex tcp-tunnel --environment-id ENV` as an OpenSSH `ProxyCommand`. The helper prefers QUIC/HTTP/3, starts TLS/HTTP/2 after 250 ms, and selects the first authenticated CONNECT accepted by the verified gateway. A single ten-second setup deadline covers transport, credential retrieval, and admission. SSH bytes are never replayed across transports.
The initial bearer must be provided as a single line on standard input (`--auth-token-stdin`). With `--auth-token-updates-stdin`, later lines replace the bearer for new connections, emit `AUTH_UPDATED`, and closure of the controlling pipe stops the tunnel. With `--connect-headers-stdin`, the first line is instead a JSON list of `["x-name","value"]` pairs; token lines follow. Only non-forwarding `x-` extension headers are accepted. No header values or credentials belong in the command arguments.
When standard HTTPS proxy settings select a proxy, the helper uses that route without attempting direct QUIC. It honors `HTTPS_PROXY`, `ALL_PROXY`, `NO_PROXY`, and supported OS proxy configuration, tunnels to the gateway, and verifies the gateway's TLS certificate before sending the admission credential. Direct TCP races resolved addresses through TLS and HTTP/2 readiness.
The process emits `LISTENING 127.0.0.1:<port>` after connecting to the proxy. A proxy handshake does not authorize the target; each local connection makes its own authenticated CONNECT. The listener survives transport reconnects, but TCP streams are never replayed.
Desktop uses the same stdio path with a one-use `--token-file` in a private directory. OAuth uses the environment ID and published port; legacy JWT admission additionally uses `--target IP:PORT`. The helper reads and removes the token file only after verifying the gateway. SSH owns each helper process; multiplexing belongs to OpenSSH ControlMaster.
`--diagnostics-json` opts into newline-delimited JSON on stderr. Version 1 contains
`v`, `phase` (`startup`, `connect`, `transport`, or `control`), `code` (`failed`,
`timeout`, `rejected`, `closed`, `draining`, or `invalid_input`), and `terminal`.
A rejected CONNECT may also include a numeric `http_status` (100–599, excluding
2xx). Records contain no credentials, addresses, headers, or raw error messages
and are less than 256 bytes. Stdout readiness and credential acknowledgments are
unchanged. A terminal record is flushed before an unsuccessful return; closing
the controlling pipe normally emits no failure. The CLI may append a generic
error line after the terminal record. Nonterminal events may concern
one TCP stream or a reconnecting shared transport and do not identify the cause
of a later child-process failure. Consumers must ignore records with unknown versions or fields and keep a generic
fallback for helpers without this flag.
Version 1 terminal combinations are `startup/{failed,timeout}`,
`control/{failed,invalid_input}`, and `transport/failed`. Nonterminal combinations
are `connect/{failed,rejected}` and `transport/{failed,timeout,closed,draining}`.
Other combinations are unknown records and must use the generic fallback.
## OpenSSH ProxyCommand
With `--environment-id ENV --port PORT`, `codex tcp-tunnel` opens one
HTTP/3 CONNECT and carries SSH bytes on stdin and stdout.
The defaults are the public Portals gateway and port 22. You can also specify
`--proxy-url ORIGIN --target ENV:PORT`. The gateway resolves the environment
and port.
A rejected CONNECT ends the command with its HTTP status on stderr.
This example uses a verified host key stored under `ccarenv_example` in
`known_hosts`.
```sshconfig
Host ccarenv_example
User dev
StrictHostKeyChecking yes
ProxyCommand /opt/codex/bin/codex tcp-tunnel --environment-id ccarenv_example --port %p
```
On Linux, run `codex-rs/tcp-tunnel/tests/real-ssh.sh` to verify a complete upload and a remote exit with local stdin still open through a real OpenSSH server and HTTP/3 tunnel. It requires OpenSSH, Python, `timeout`, and the normal Rust test tools.
-81
View File
@@ -1,81 +0,0 @@
//! Bounded parsing of HTTP/3 CONNECT metadata and bearer input.
//! Extension values remain sensitive and may never replace authorization or forwarding headers.
use std::io::BufRead;
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use anyhow::ensure;
use http::HeaderMap;
use http::HeaderValue;
use http::header;
pub(super) const MAX_TOKEN_BYTES: usize = 64 * 1024;
pub(super) const MAX_CONNECT_METADATA_BYTES: usize = 16 * 1024;
pub(super) const MAX_CONNECT_HEADERS: usize = 16;
pub(super) const MAX_CONNECT_HEADER_VALUE_BYTES: usize = 4 * 1024;
pub(super) fn read_connect_headers(reader: &mut impl BufRead) -> Result<HeaderMap> {
let mut line = Vec::new();
std::io::Read::take(&mut *reader, (MAX_CONNECT_METADATA_BYTES + 1) as u64)
.read_until(b'\n', &mut line)
.context("reading CONNECT metadata")?;
ensure!(
!line.is_empty() && line.len() <= MAX_CONNECT_METADATA_BYTES && line.ends_with(b"\n"),
"invalid or oversized CONNECT metadata"
);
let pairs: Vec<(String, String)> =
serde_json::from_slice(&line).map_err(|_| anyhow!("invalid CONNECT metadata"))?;
ensure!(
pairs.len() <= MAX_CONNECT_HEADERS,
"too many CONNECT metadata headers"
);
let mut headers = HeaderMap::new();
for (name, value) in pairs {
let name = header::HeaderName::from_bytes(name.as_bytes())
.map_err(|_| anyhow!("invalid CONNECT metadata header name"))?;
ensure!(
!headers.contains_key(&name),
"duplicate CONNECT metadata header"
);
let extension = name.as_str();
ensure!(
extension.starts_with("x-")
&& !extension.starts_with("x-forwarded-")
&& extension != "x-real-ip",
"CONNECT metadata must use non-forwarding extension headers"
);
let mut value = HeaderValue::from_str(&value)
.map_err(|_| anyhow!("invalid CONNECT metadata header value"))?;
ensure!(
value.as_bytes().len() <= MAX_CONNECT_HEADER_VALUE_BYTES,
"CONNECT metadata header value is too long"
);
value.set_sensitive(true);
headers.insert(name, value);
}
Ok(headers)
}
pub(super) fn read_bearer(reader: &mut impl BufRead) -> Result<Option<HeaderValue>> {
let mut line = Vec::new();
std::io::Read::take(&mut *reader, (MAX_TOKEN_BYTES + 1) as u64)
.read_until(b'\n', &mut line)
.context("reading MASQUE token")?;
if line.is_empty() {
return Ok(None);
}
ensure!(line.len() <= MAX_TOKEN_BYTES, "MASQUE token is too long");
let token = std::str::from_utf8(&line)
.context("invalid MASQUE token encoding")?
.trim();
Ok(Some(bearer_header(token)?))
}
pub(super) fn bearer_header(token: &str) -> Result<HeaderValue> {
ensure!(!token.is_empty(), "empty MASQUE token");
let mut auth =
HeaderValue::from_str(&format!("Bearer {token}")).context("invalid MASQUE token header")?;
auth.set_sensitive(true);
Ok(auth)
}
-139
View File
@@ -1,139 +0,0 @@
//! Opt-in, bounded diagnostics contain only classifications, never error-chain or wire values.
//! Nonterminal records describe one stream or a recoverable shared-transport event.
use std::fmt;
use std::io::Write;
use anyhow::Result;
use anyhow::anyhow;
use http::StatusCode;
#[derive(Clone, Copy)]
pub(super) enum Diagnostics {
Human,
Json,
}
#[derive(Clone, Copy, Debug)]
pub(super) enum Phase {
Startup,
Connect,
Transport,
Control,
}
impl fmt::Display for Phase {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Startup => "startup",
Self::Connect => "connect",
Self::Transport => "transport",
Self::Control => "control",
})
}
}
#[derive(Debug)]
pub(super) enum Code {
Failed,
Timeout,
HandshakeTimeout,
Rejected(StatusCode),
Closed,
Draining,
InvalidInput,
}
impl fmt::Display for Code {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Failed => f.write_str("failed"),
Self::HandshakeTimeout => {
f.write_str("QUIC handshake failed: QUIC handshake timed out")
}
Self::Timeout => f.write_str("connecting to MASQUE proxy timed out"),
Self::Rejected(status) => {
write!(f, "MASQUE CONNECT rejected with status {}", status.as_u16())
}
Self::Closed => f.write_str("closed"),
Self::Draining => f.write_str("draining"),
Self::InvalidInput => f.write_str("invalid control input"),
}
}
}
impl std::error::Error for Code {}
impl Diagnostics {
pub(super) fn with_phase<T>(self, result: Result<T>, phase: Phase) -> Result<T> {
match self {
Self::Human => result,
Self::Json => result.map_err(|error| error.context(phase)),
}
}
pub(super) fn finish(
self,
result: Result<()>,
phase: Phase,
output: &mut impl Write,
) -> Result<()> {
match (self, result) {
(Self::Json, Err(error)) => {
Self::write(output, phase, &error, /*terminal*/ true);
// The CLI formats returned errors. Do not let its top-level handler print the raw chain.
Err(anyhow!("TCP tunnel failed"))
}
(_, result) => result,
}
}
pub(super) fn report(self, phase: Phase, error: &anyhow::Error, human: fmt::Arguments<'_>) {
match self {
Self::Human => eprintln!("{human}"),
Self::Json => Self::write(
&mut std::io::stderr().lock(),
phase,
error,
/*terminal*/ false,
),
}
}
fn write(output: &mut impl Write, phase: Phase, error: &anyhow::Error, terminal: bool) {
let phase = error.downcast_ref::<Phase>().copied().unwrap_or(phase);
let fallback = if matches!(phase, Phase::Control)
&& error.downcast_ref::<std::io::Error>().is_none()
{
Code::InvalidInput
} else {
Code::Failed
};
let code = error.downcast_ref::<Code>().unwrap_or(&fallback);
let mut record = serde_json::json!({
"v": 1,
"phase": phase.to_string(),
"code": match code {
Code::Failed => "failed",
Code::Timeout | Code::HandshakeTimeout => "timeout",
Code::Rejected(_) => "rejected",
Code::Closed => "closed",
Code::Draining => "draining",
Code::InvalidInput => "invalid_input",
},
"terminal": terminal,
});
if let (Phase::Connect, Code::Rejected(status)) = (phase, code)
&& (100..600).contains(&status.as_u16())
&& !status.is_success()
{
record["http_status"] = status.as_u16().into();
}
// All fields are bounded enums or numbers; one locked, flushed line precedes process exit.
let _ = writeln!(output, "{record}");
let _ = output.flush();
}
}
#[cfg(test)]
#[path = "diagnostics_tests.rs"]
mod tests;
@@ -1,132 +0,0 @@
use super::Code;
use super::Diagnostics;
use super::Phase;
use anyhow::Context;
use anyhow::anyhow;
use http::StatusCode;
use pretty_assertions::assert_eq;
use serde_json::json;
#[test]
fn fatal_diagnostic_drops_untrusted_error_chain_and_flushes_one_record() {
#[derive(Default)]
struct Output {
bytes: Vec<u8>,
flushes: usize,
}
impl std::io::Write for Output {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.bytes.extend_from_slice(bytes);
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
self.flushes += 1;
Ok(())
}
}
let mut output = Output::default();
let error = Diagnostics::Json
.finish(
Err(anyhow!(
"Bearer secret; x-route: private; https://private.example/path"
))
.context(Code::Timeout),
Phase::Startup,
&mut output,
)
.unwrap_err();
assert_eq!(format!("{error:#}"), "TCP tunnel failed");
assert_eq!(output.flushes, 1);
assert!(output.bytes.len() < 256);
assert_eq!(
output.bytes.iter().filter(|&&byte| byte == b'\n').count(),
1
);
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&output.bytes).unwrap(),
json!({
"v": 1, "phase": "startup", "code": "timeout", "terminal": true,
})
);
}
#[test]
fn control_io_failure_and_invalid_input_have_distinct_safe_codes() {
for (error, code) in [
(anyhow!("invalid private bearer"), "invalid_input"),
(
anyhow!(std::io::Error::other("private input failure")),
"failed",
),
] {
let mut output = Vec::new();
Diagnostics::Json
.finish(
Err(error).context(Phase::Control),
Phase::Startup,
&mut output,
)
.unwrap_err();
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&output).unwrap(),
json!({
"v": 1, "phase": "control", "code": code, "terminal": true,
})
);
}
}
#[test]
fn connect_rejection_is_nonterminal_and_contains_only_valid_status() {
for status in [403, 407, 503, 999] {
let mut output = Vec::new();
let error = anyhow!("private proxy response body")
.context(Code::Rejected(StatusCode::from_u16(status).unwrap()));
Diagnostics::write(&mut output, Phase::Connect, &error, /*terminal*/ false);
let mut expected =
json!({"v": 1, "phase": "connect", "code": "rejected", "terminal": false});
if status < 600 {
expected["http_status"] = status.into();
}
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&output).unwrap(),
expected
);
}
}
#[test]
fn legacy_errors_and_successful_shutdown_produce_no_json() {
let mut output = Vec::new();
let result = Diagnostics::Human.with_phase(Err(anyhow!("legacy error")), Phase::Transport);
let error = Diagnostics::Human
.finish(result, Phase::Startup, &mut output)
.unwrap_err();
assert_eq!(format!("{error:#}"), "legacy error");
Diagnostics::Json
.finish(Ok(()), Phase::Control, &mut output)
.unwrap();
assert!(output.is_empty());
}
#[test]
fn handshake_timeout_preserves_legacy_debug_output() {
let error = anyhow!(Code::HandshakeTimeout);
assert_eq!(
format!("{error:?}"),
"QUIC handshake failed: QUIC handshake timed out"
);
let mut output = Vec::new();
Diagnostics::write(
&mut output,
Phase::Transport,
&error,
/*terminal*/ false,
);
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&output).unwrap(),
json!({
"v": 1, "phase": "transport", "code": "timeout", "terminal": false,
})
);
}
+116 -42
View File
@@ -14,6 +14,10 @@ use anyhow::anyhow;
use anyhow::ensure;
use bytes::Bytes;
use http::Request;
use hyper_util::client::legacy::connect::proxy::Tunnel;
use hyper_util::client::proxy::matcher::Intercept;
use hyper_util::client::proxy::matcher::Matcher;
use hyper_util::rt::TokioIo;
use rustls::pki_types::ServerName;
use tokio::io::AsyncRead;
use tokio::io::AsyncReadExt;
@@ -21,77 +25,148 @@ use tokio::io::AsyncWrite;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;
use tower_service::Service;
use crate::MAX_FIELD_SECTION_SIZE;
use crate::ProxyTarget;
use crate::diagnostics::Code;
use crate::SetupError;
const COPY_BUFFER_SIZE: usize = 64 * 1024;
pub(super) type Sender = h2::client::SendRequest<Bytes>;
pub(super) trait GatewayIo: AsyncRead + AsyncWrite + Send + Unpin {}
impl<T: AsyncRead + AsyncWrite + Send + Unpin> GatewayIo for T {}
pub(super) type Connection =
h2::client::Connection<tokio_rustls::client::TlsStream<TcpStream>, Bytes>;
h2::client::Connection<tokio_rustls::client::TlsStream<Box<dyn GatewayIo>>, Bytes>;
pub(super) async fn connect(
target: &ProxyTarget,
tls: Arc<rustls::ClientConfig>,
) -> Result<(Sender, Connection)> {
let addresses: Vec<_> = tokio::net::lookup_host((target.host.as_str(), target.port))
.await?
.collect();
connect_addresses(target, tls, &addresses).await
}
pub(super) fn system_proxy(target: &ProxyTarget) -> Result<Option<(http::Uri, Intercept)>> {
let uri = gateway_uri(target)?;
Ok(Matcher::from_system()
.intercept(&uri)
.map(|proxy| (uri, proxy)))
}
async fn connect_addresses(
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);
let mut attempts = tokio::task::JoinSet::new();
for &address in addresses {
let attempt = async {
let connector = connector.clone();
let name = name.clone();
attempts.spawn(async move {
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 {
handshake(Box::new(socket), connector, name).await
});
}
let mut invalid_certificate = false;
while let Some(result) = attempts.join_next().await {
match result {
Ok(Ok(connection)) => return Ok(connection),
Ok(Err(error))
if error.chain().any(|cause| {
Ok(Err(error)) => {
invalid_certificate |= error.chain().any(|cause| {
matches!(
cause.downcast_ref::<rustls::Error>(),
Some(rustls::Error::InvalidCertificate(_))
)
}) =>
{
return Err(anyhow!("HTTP/2 proxy certificate verification failed"));
});
}
_ => {}
}
}
if invalid_certificate {
return Err(anyhow!("HTTP/2 proxy certificate verification failed"));
}
Err(anyhow!("HTTP/2 proxy connection failed"))
}
fn gateway_uri(target: &ProxyTarget) -> Result<http::Uri> {
let host = if target.host.contains(':') {
format!("[{}]", target.host)
} else {
target.host.clone()
};
Ok(format!("https://{host}:{}/", target.port).parse()?)
}
pub(super) async fn connect_through_proxy(
target: &ProxyTarget,
tls: Arc<rustls::ClientConfig>,
uri: http::Uri,
proxy: Intercept,
) -> Result<(Sender, Connection)> {
ensure!(
matches!(proxy.uri().scheme_str(), Some("http" | "https")),
"unsupported HTTPS proxy scheme"
);
let mut proxy_tls = (*tls).clone();
proxy_tls.alpn_protocols.clear();
let connector = hyper_rustls::HttpsConnectorBuilder::new()
.with_tls_config(proxy_tls)
.https_or_http()
.enable_http1()
.build();
let mut tunnel = Tunnel::new(proxy.uri().clone(), connector);
if let Some(auth) = proxy.basic_auth() {
tunnel = tunnel.with_auth(auth.clone());
}
let socket = TokioIo::new(tunnel.call(uri).await?);
let name = ServerName::try_from(target.host.clone())
.map_err(|_| anyhow!("invalid proxy TLS server name"))?;
handshake(Box::new(socket), TlsConnector::from(tls), name).await
}
async fn handshake(
socket: Box<dyn GatewayIo>,
connector: TlsConnector,
name: ServerName<'static>,
) -> Result<(Sender, Connection)> {
let stream = connector.connect(name, 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((sender, connection))
}
pub(super) async fn admit(
sender: Sender,
request: Request<()>,
@@ -104,7 +179,7 @@ pub(super) async fn admit(
let status = response.status();
if !status.is_success() {
send.send_reset(h2::Reason::CANCEL);
return Err(Code::Rejected(status).into());
return Err(SetupError::Rejected(status).into());
}
Ok((send, response.into_body()))
}
@@ -114,7 +189,6 @@ pub(super) async fn bridge(
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];
@@ -152,7 +226,7 @@ pub(super) async fn bridge(
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 } }
result = &mut download => { result?; Ok(()) }
}
}
+83 -17
View File
@@ -20,9 +20,11 @@ use tokio::net::TcpListener;
use tokio::time::timeout;
use tokio_rustls::TlsAcceptor;
use super::connect;
use super::connect_addresses as connect;
use super::connect_through_proxy;
use super::gateway_uri;
use crate::ProxyTarget;
use crate::diagnostics::Code;
use crate::SetupError;
use crate::transport::Connection;
pub(crate) fn tls_configs() -> Result<(rustls::ServerConfig, rustls::ClientConfig)> {
@@ -95,9 +97,9 @@ async fn trusted_h2_requires_settings_and_certificate() -> Result<()> {
}
#[tokio::test]
async fn forwards_bounded_data_in_both_half_close_orders_and_rejects_before_upload() -> Result<()> {
async fn forwards_upload_before_response_and_rejects_before_upload() -> Result<()> {
timeout(Duration::from_secs(15), async {
for (remote_first, status) in [(false, 200), (true, 200), (false, 403)] {
for status in [200, 403] {
let (server, client) = tls_configs()?;
let listener = TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
@@ -119,12 +121,11 @@ async fn forwards_bounded_data_in_both_half_close_orders_and_rejects_before_uplo
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)?; }
send.send_data(Bytes::from(response_bytes), true)?;
Ok(())
};
let complete = async { handler.await?; finished.await?; Ok::<_, anyhow::Error>(()) };
@@ -141,19 +142,18 @@ async fn forwards_bounded_data_in_both_half_close_orders_and_rejects_before_uplo
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
.relay(input, output).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?; }
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));
assert!(matches!(error.downcast_ref::<SetupError>(), Some(SetupError::Rejected(status)) if status.as_u16() == 403));
}
let _ = done.send(());
peer.await??;
@@ -163,14 +163,20 @@ async fn forwards_bounded_data_in_both_half_close_orders_and_rejects_before_uplo
}
#[tokio::test]
async fn retries_next_address_after_non_certificate_tls_failure() -> Result<()> {
timeout(Duration::from_secs(5), async {
async fn reaches_third_address_while_two_tls_peers_stall() -> Result<()> {
timeout(Duration::from_secs(2), async {
let (server, client) = tls_configs()?;
let bad = TcpListener::bind("127.0.0.1:0").await?;
let first = TcpListener::bind("127.0.0.1:0").await?;
let second = 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 addresses = [
first.local_addr()?,
second.local_addr()?,
good.local_addr()?,
];
let stalls = tokio::spawn(async move {
let (_first, _second) = tokio::join!(first.accept(), second.accept());
std::future::pending::<()>().await;
});
let good_task = tokio::spawn(async move {
let tls = TlsAcceptor::from(Arc::new(server))
@@ -183,9 +189,69 @@ async fn retries_next_address_after_non_certificate_tls_failure() -> Result<()>
});
let connection = connect(&target(addresses[0]), Arc::new(client), &addresses).await?;
drop(connection);
bad_task.await?;
stalls.abort();
good_task.await??;
Ok::<_, anyhow::Error>(())
})
.await?
}
#[tokio::test]
async fn proxy_only_egress_keeps_gateway_credentials_inside_tls() -> Result<()> {
timeout(Duration::from_secs(3), async {
let (server, client) = tls_configs()?;
let gateway = TcpListener::bind("127.0.0.1:0").await?;
let gateway_address = gateway.local_addr()?;
let proxy = TcpListener::bind("127.0.0.1:0").await?;
let proxy_address = proxy.local_addr()?;
let proxy_task = tokio::spawn(async move {
let (mut socket, _) = proxy.accept().await?;
let mut header = Vec::new();
while !header.ends_with(b"\r\n\r\n") {
header.push(socket.read_u8().await?);
anyhow::ensure!(header.len() < 4096);
}
let header = String::from_utf8(header)?;
assert!(header.starts_with(&format!("CONNECT {gateway_address} HTTP/1.1")));
assert!(!header.to_lowercase().contains("authorization: bearer"));
socket
.write_all(b"HTTP/1.1 200 Connection established\r\n\r\n")
.await?;
let mut upstream = tokio::net::TcpStream::connect(gateway_address).await?;
tokio::io::copy_bidirectional(&mut socket, &mut upstream).await?;
Ok::<_, anyhow::Error>(())
});
let gateway_task = tokio::spawn(async move {
let tls = TlsAcceptor::from(Arc::new(server))
.accept(gateway.accept().await?.0)
.await?;
let mut conn: h2::server::Connection<_, Bytes> = h2::server::handshake(tls).await?;
let (request, mut response) = conn.accept().await.unwrap()?;
assert_eq!(request.headers()["authorization"], "Bearer fixture");
response.send_response(Response::new(()), /*end_of_stream*/ true)?;
let _ = conn.accept().await;
Ok::<_, anyhow::Error>(())
});
let target = target(gateway_address);
let uri = gateway_uri(&target)?;
let intercept = hyper_util::client::proxy::matcher::Matcher::builder()
.https(format!("http://{proxy_address}"))
.build()
.intercept(&uri)
.unwrap();
let (sender, mut connection) =
connect_through_proxy(&target, Arc::new(client), uri, intercept).await?;
let request =
target.request(HeaderMap::new(), HeaderValue::from_static("Bearer fixture"))?;
let result = tokio::select! {
result = super::admit(sender, request) => result,
_ = &mut connection => anyhow::bail!("gateway closed"),
};
drop(result?);
drop(connection);
gateway_task.await??;
proxy_task.await??;
Ok::<_, anyhow::Error>(())
})
.await?
}
+53 -431
View File
@@ -1,8 +1,5 @@
//! TCP forwarding through a verified HTTP/3 CONNECT proxy, for listeners and SSH stdio.
//! The listener survives transport loss; individual TCP streams are never replayed.
use std::io::BufRead;
use std::io::Write;
use std::net::IpAddr;
//! One SSH-owned, authenticated tunnel to a verified Cloud Portals gateway.
use std::fmt;
use std::net::SocketAddr;
use std::num::NonZeroU16;
use std::path::PathBuf;
@@ -12,117 +9,83 @@ use std::time::Duration;
use anyhow::Context;
use anyhow::Result;
use anyhow::anyhow;
use anyhow::bail;
use anyhow::ensure;
use bytes::Buf;
use bytes::Bytes;
use clap::Args as ClapArgs;
use clap::builder::ArgPredicate;
use http::HeaderMap;
use http::HeaderValue;
use http::Method;
use http::Request;
use http::StatusCode;
use http::Uri;
use http::header;
use http::uri::Authority;
use quinn::crypto::rustls::QuicClientConfig;
use tokio::io::AsyncRead;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWrite;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::sync::watch;
use url::Host;
use url::Url;
mod control;
mod diagnostics;
mod http2;
mod ssh;
mod transport;
pub use ssh::run_ssh_proxy;
use diagnostics::Code;
use diagnostics::Diagnostics;
use diagnostics::Phase;
use control::read_bearer;
use control::read_connect_headers;
pub use ssh::run_ssh_proxy_from_file;
const PROXY_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
// Bound decoded QPACK fields before h3 constructs its capacity-limited HeaderMap.
const MAX_FIELD_SECTION_SIZE: u64 = 64 * 1024;
const MAX_TOKEN_BYTES: usize = 64 * 1024;
#[derive(Debug, ClapArgs)]
pub struct Args {
/// HTTPS proxy origin. With --environment-id, defaults to the public Portals gateway.
#[arg(
long,
required = false,
required_unless_present = "environment_id",
default_value_if("environment_id", ArgPredicate::IsPresent, ssh::PUBLIC_GATEWAY)
)]
/// Verified HTTPS gateway origin.
#[arg(long, default_value = ssh::PUBLIC_GATEWAY)]
pub proxy_url: Url,
/// Listener mode: file containing one exact approved HTTPS proxy origin per line.
#[arg(long, requires = "auth_token_stdin")]
proxy_origins_file: Option<PathBuf>,
/// SSH environment ID and port (ENV:PORT), or the CONNECT authority in listener mode.
#[arg(
long,
required_unless_present = "environment_id",
conflicts_with = "environment_id"
)]
target: Option<String>,
/// Open an SSH stdio tunnel to this canonical Portals environment.
#[arg(long, conflicts_with = "auth_token_stdin")]
/// Canonical Cloud environment ID.
#[arg(long, required_unless_present = "target", conflicts_with = "target")]
environment_id: Option<String>,
/// Published SSH port for --environment-id (default 22).
/// Published SSH port.
#[arg(long, requires = "environment_id")]
port: Option<NonZeroU16>,
/// Loopback listener address (default 127.0.0.1:0).
#[arg(long, requires = "auth_token_stdin")]
listen_addr: Option<SocketAddr>,
/// Start a listener and read its bearer from stdin. Otherwise relay SSH over stdio using the Codex login.
#[arg(long, requires = "proxy_origins_file")]
pub auth_token_stdin: bool,
/// Read replacement bearers from stdin and stop when the controlling pipe closes.
#[arg(long, requires = "auth_token_stdin")]
auth_token_updates_stdin: bool,
/// Read a JSON list of extension-header name/value pairs before the first bearer.
#[arg(long, requires = "auth_token_stdin")]
connect_headers_stdin: bool,
/// Emit credential-safe JSON diagnostics on stderr instead of human-readable errors.
#[arg(long, requires = "auth_token_stdin")]
diagnostics_json: bool,
/// ERS-issued legacy CONNECT authority; requires a private token file.
#[arg(long, requires = "token_file", conflicts_with = "environment_id")]
target: Option<SocketAddr>,
/// One-use bearer in a private file, supplied by Desktop. Never read from SSH stdin.
#[arg(long)]
pub token_file: Option<PathBuf>,
}
#[derive(Debug)]
enum SetupError {
Timeout,
Rejected(StatusCode),
}
impl fmt::Display for SetupError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Timeout => f.write_str("SSH tunnel setup timed out"),
Self::Rejected(status) => write!(f, "CONNECT rejected with status {}", status.as_u16()),
}
}
}
impl std::error::Error for SetupError {}
#[derive(Debug, PartialEq, Eq)]
struct ProxyTarget {
host: String,
port: u16,
authority: String,
}
struct TunnelHeaders {
auth: watch::Receiver<HeaderValue>,
connect: HeaderMap,
}
struct ProxyConnection {
endpoint: quinn::Endpoint,
quic: quinn::Connection,
_endpoint: quinn::Endpoint,
_quic: quinn::Connection,
connection: h3::client::Connection<h3_quinn::Connection, Bytes>,
sender: h3::client::SendRequest<h3_quinn::OpenStreams, Bytes>,
}
enum ProxyClosure {
Draining,
Closed(anyhow::Error),
}
impl ProxyTarget {
fn request(&self, mut headers: HeaderMap, bearer: HeaderValue) -> Result<Request<()>> {
let mut request = Request::builder()
@@ -173,165 +136,6 @@ impl ProxyTarget {
}
}
fn parse_trusted_origins(origins: &str) -> Result<Vec<String>> {
let trusted_origins = origins
.lines()
.map(str::trim)
.filter(|line| !line.is_empty())
.map(|line| {
let origin = Url::parse(line).context("invalid trusted proxy origin")?;
ensure!(
origin.scheme() == "https"
&& origin.username().is_empty()
&& origin.password().is_none()
&& origin.query().is_none()
&& origin.fragment().is_none()
&& origin.path() == "/"
&& line == origin.origin().ascii_serialization(),
"trusted proxy origins must be exact HTTPS origins"
);
Ok(line.to_owned())
})
.collect::<Result<Vec<_>>>()?;
ensure!(!trusted_origins.is_empty(), "no trusted proxy origins");
Ok(trusted_origins)
}
#[cfg(test)]
#[path = "lib_tests.rs"]
mod tests;
pub async fn run(args: Args) -> Result<()> {
let diagnostics = if args.diagnostics_json {
Diagnostics::Json
} else {
Diagnostics::Human
};
let mut phase = Phase::Startup;
let result = async {
ensure!(args.auth_token_stdin, "--auth-token-stdin is required");
let listen_addr = args.listen_addr.unwrap_or(SocketAddr::from(([127, 0, 0, 1], 0)));
ensure!(
listen_addr.ip().is_loopback(),
"listener must be loopback"
);
let origins = std::fs::read_to_string(args.proxy_origins_file.context("missing proxy origins file")?)
.context("reading trusted proxy origins")?;
let trusted_origins = parse_trusted_origins(&origins)?;
let authority = args.target.as_deref().context("missing CONNECT target")?;
let target = ProxyTarget::parse(&args.proxy_url, &trusted_origins, authority)?;
phase = Phase::Control;
let (metadata, mut tokens) = control_input(
std::io::BufReader::new(std::io::stdin()),
args.connect_headers_stdin,
ssh::GATEWAY_ORIGINS.contains(&args.proxy_url.origin().ascii_serialization().as_str()),
)?;
let connect = metadata.await.context("CONNECT metadata input closed")??;
let initial_auth = tokens
.recv()
.await
.context("MASQUE credential input closed")??
.context("empty MASQUE token")?;
phase = Phase::Startup;
let (updates, auth) = watch::channel(initial_auth);
let headers = TunnelHeaders { auth, connect };
let listener = TcpListener::bind(listen_addr)
.await
.context("binding loopback listener")?;
let config = client_config(quinn::TransportConfig::default())?;
let (ready, readiness) = oneshot::channel();
let tunnel = async move {
let connected = ProxyConnection::connect(&target, &config).await?;
// The line is the caller readiness contract, including the assigned port.
writeln!(std::io::stdout(), "LISTENING {}", listener.local_addr()?)?;
std::io::stdout().flush()?;
let _ = ready.send(());
diagnostics.with_phase(
serve(listener, target, config, headers, connected, diagnostics).await,
Phase::Transport,
)
};
if args.auth_token_updates_stdin {
tokio::select! {
result = tunnel => result,
result = update_auth_tokens(&mut tokens, updates, readiness, std::io::stdout()) => diagnostics.with_phase(result, Phase::Control),
}
} else {
tunnel.await
}
}
.await;
diagnostics.finish(result, phase, &mut std::io::stderr().lock())
}
type TokenStream = mpsc::Receiver<Result<Option<HeaderValue>>>;
async fn update_auth_tokens(
tokens: &mut TokenStream,
updates: watch::Sender<HeaderValue>,
readiness: oneshot::Receiver<()>,
mut output: impl Write,
) -> Result<()> {
let mut readiness = Some(readiness);
while let Some(result) = tokens.recv().await {
let Some(token) = result? else {
break;
};
updates.send_replace(token);
if let Some(readiness) = readiness.take() {
readiness.await.context("MASQUE tunnel did not start")?;
}
writeln!(output, "AUTH_UPDATED")?;
output.flush()?;
}
Ok(())
}
fn control_input(
mut reader: impl BufRead + Send + 'static,
connect_headers_stdin: bool,
require_portals_oauth: bool,
) -> Result<(oneshot::Receiver<Result<HeaderMap>>, TokenStream)> {
let (metadata, initial_metadata) = oneshot::channel();
let (send, tokens) = mpsc::channel(1);
// Tokio's blocking stdin can prevent runtime shutdown after a proxy startup failure.
std::thread::Builder::new()
.name("masque-credentials".to_owned())
.spawn(move || {
let headers = if connect_headers_stdin {
read_connect_headers(&mut reader)
} else {
Ok(HeaderMap::new())
};
let headers = match headers {
Ok(headers) => headers,
Err(error) => {
let _ = metadata.send(Err(error));
return;
}
};
if require_portals_oauth
&& headers
.get("x-portals-auth-mode")
.is_none_or(|mode| mode != "oauth")
{
let _ = metadata.send(Err(anyhow!("Portals requires OAuth CONNECT metadata")));
return;
}
let _ = metadata.send(Ok(headers));
loop {
let token = read_bearer(&mut reader);
let finished = !matches!(&token, Ok(Some(_)));
if send.blocking_send(token).is_err() || finished {
break;
}
}
})
.context("starting MASQUE credential input")?;
Ok((initial_metadata, tokens))
}
fn tls_config() -> Result<rustls::ClientConfig> {
let native = rustls_native_certs::load_native_certs();
let mut roots = rustls::RootCertStore::empty();
@@ -349,219 +153,38 @@ fn tls_config() -> Result<rustls::ClientConfig> {
.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()?));
transport.keep_alive_interval(Some(Duration::from_secs(10)));
config.transport_config(Arc::new(transport));
Ok(config)
}
impl ProxyConnection {
async fn connect(target: &ProxyTarget, config: &quinn::ClientConfig) -> Result<Self> {
tokio::time::timeout(PROXY_CONNECT_TIMEOUT, async {
let mut last_error = anyhow!("MASQUE proxy resolved to no addresses");
for peer in tokio::net::lookup_host((target.host.as_str(), target.port)).await? {
let bind = match peer.ip() {
IpAddr::V4(_) => "0.0.0.0:0",
IpAddr::V6(_) => "[::]:0",
};
let mut endpoint = match quinn::Endpoint::client(bind.parse()?) {
Ok(endpoint) => endpoint,
Err(error) => {
last_error = anyhow!(error.to_string());
continue;
}
for peer in tokio::net::lookup_host((target.host.as_str(), target.port)).await? {
let attempt = async {
let bind = if peer.is_ipv4() {
"0.0.0.0:0"
} else {
"[::]:0"
};
let mut endpoint = quinn::Endpoint::client(bind.parse()?)?;
endpoint.set_default_client_config(config.clone());
let connecting = match endpoint.connect(peer, &target.host) {
Ok(connecting) => connecting,
Err(error) => {
last_error = anyhow!(error.to_string());
continue;
}
};
let quic = match tokio::time::timeout(Duration::from_secs(5), connecting).await {
Ok(Ok(quic)) => quic,
Ok(Err(error)) => {
last_error = anyhow!(error.to_string());
continue;
}
Err(_) => {
last_error = Code::HandshakeTimeout.into();
continue;
}
};
let (connection, sender) = match h3::client::builder()
let quic = endpoint.connect(peer, &target.host)?.await?;
let (connection, sender) = h3::client::builder()
.max_field_section_size(MAX_FIELD_SECTION_SIZE)
.enable_extended_connect(true)
.build(h3_quinn::Connection::new(quic.clone()))
.await
{
Ok(connection) => connection,
Err(error) => {
last_error = anyhow!(error.to_string());
continue;
}
};
return Ok(Self {
endpoint,
quic,
.await?;
Ok::<_, anyhow::Error>(Self {
_endpoint: endpoint,
_quic: quic,
connection,
sender,
});
}
if matches!(
last_error.downcast_ref::<Code>(),
Some(Code::HandshakeTimeout)
) {
Err(last_error)
} else {
bail!("QUIC handshake failed: {last_error}")
}
})
.await
.context(Code::Timeout)?
}
}
async fn serve(
listener: TcpListener,
target: ProxyTarget,
config: quinn::ClientConfig,
headers: TunnelHeaders,
mut connected: ProxyConnection,
diagnostics: Diagnostics,
) -> Result<()> {
loop {
let ProxyConnection {
endpoint,
quic,
mut connection,
sender,
} = connected;
let mut driver = tokio::spawn(async move { connection.wait_idle().await });
let (draining, mut drain_started) = mpsc::channel(1);
let failure = loop {
tokio::select! {
incoming = listener.accept() => {
let (socket, _) = incoming?;
let mut sender = sender.clone();
let draining = draining.clone();
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, draining).await {
diagnostics.report(
Phase::Connect,
&error,
format_args!("MASQUE TCP connection failed: {error:#}"),
);
}
});
}
_ = drain_started.recv() => break ProxyClosure::Draining,
closed = &mut driver => break ProxyClosure::Closed(match closed {
Ok(error) => anyhow!("MASQUE HTTP/3 connection closed: {error}"),
Err(error) => anyhow!("MASQUE HTTP/3 driver stopped: {error}"),
}),
closed = quic.closed() => break ProxyClosure::Closed(anyhow!(closed).context("MASQUE QUIC connection closed")),
}
};
drop(sender);
match failure {
ProxyClosure::Draining => {
diagnostics.report(
Phase::Transport,
&Code::Draining.into(),
format_args!("MASQUE HTTP/3 proxy is draining; reconnecting"),
);
// A refused new CONNECT is not replayed. Accepted streams keep their old transport.
tokio::spawn(async move {
tokio::select! {
_ = &mut driver => {},
_ = quic.closed() => driver.abort(),
}
drop(endpoint);
});
}
ProxyClosure::Closed(error) => {
driver.abort();
quic.close(/*error_code*/ 0_u8.into(), b"reconnecting");
drop(endpoint);
diagnostics.report(
Phase::Transport,
&Code::Closed.into(),
format_args!("MASQUE proxy connection lost; reconnecting: {error:#}"),
);
}
}
let mut retry_delay = Duration::from_secs(1);
loop {
let result = {
let attempt = async {
tokio::time::sleep(rand::random_range(retry_delay / 2..=retry_delay)).await;
ProxyConnection::connect(&target, &config).await
};
tokio::pin!(attempt);
loop {
tokio::select! {
incoming = listener.accept() => {
// Offline local connections fail promptly; their traffic is never queued or replayed.
let (socket, _) = incoming?;
drop(socket);
}
result = &mut attempt => break result,
}
}
})
};
match result {
Ok(reconnected) => {
connected = reconnected;
break;
}
Err(error) => {
diagnostics.report(
Phase::Transport,
&error,
format_args!("MASQUE proxy reconnect failed: {error:#}"),
);
retry_delay = (retry_delay * 2).min(Duration::from_secs(15));
}
if let Ok(Ok(connection)) = tokio::time::timeout(Duration::from_secs(5), attempt).await
{
return Ok(connection);
}
}
Err(anyhow!("HTTP/3 proxy connection failed"))
}
}
async fn bridge(
local_read: impl AsyncRead + Unpin,
local_write: impl AsyncWrite + Unpin,
sender: &mut h3::client::SendRequest<h3_quinn::OpenStreams, Bytes>,
request: Request<()>,
draining: mpsc::Sender<()>,
) -> Result<()> {
let mut stream = match sender.send_request(request).await {
Ok(stream) => stream,
Err(error) => {
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<()> {
@@ -571,7 +194,7 @@ async fn check_h3_response(stream: &mut H3Stream) -> Result<()> {
.context("receiving CONNECT response")?
.status();
if !status.is_success() {
return Err(Code::Rejected(status).into());
return Err(SetupError::Rejected(status).into());
}
Ok(())
}
@@ -580,7 +203,6 @@ 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 {
@@ -612,7 +234,7 @@ async fn bridge_h3_stream(
result = &mut upload => { result?; download.await }
result = &mut download => {
result?;
if exit_on_remote_eof { Ok(()) } else { upload.await }
Ok(())
}
}
}
-639
View File
@@ -1,639 +0,0 @@
use std::io::Cursor;
use std::sync::Arc;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use std::time::Duration;
use anyhow::Result;
use bytes::Buf;
use bytes::Bytes;
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::net::TcpStream;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::sync::watch;
use tokio::time::timeout;
use url::Url;
use super::ProxyConnection;
use super::ProxyTarget;
use super::TunnelHeaders;
use super::control::MAX_CONNECT_HEADER_VALUE_BYTES;
use super::control::MAX_CONNECT_HEADERS;
use super::control::MAX_CONNECT_METADATA_BYTES;
use super::control::MAX_TOKEN_BYTES;
use super::control::read_connect_headers;
use super::control_input;
use super::diagnostics::Diagnostics;
use super::parse_trusted_origins;
use super::serve;
use super::update_auth_tokens;
#[test]
fn proxy_policy_and_target_admission() {
let origins = parse_trusted_origins("\nhttps://proxy.example.org\n").unwrap();
assert_eq!(origins, vec!["https://proxy.example.org".to_string()]);
let proxy = Url::parse("https://proxy.example.org").unwrap();
for target in ["127.0.0.1:22", "[::1]:2222", "target.example:443"] {
assert_eq!(
ProxyTarget::parse(&proxy, &origins, target).unwrap(),
ProxyTarget {
host: "proxy.example.org".into(),
port: 443,
authority: target.into()
},
);
}
let ipv6 = "https://[::1]:8443";
assert_eq!(
ProxyTarget::parse(
&Url::parse(ipv6).unwrap(),
&parse_trusted_origins(ipv6).unwrap(),
"target.example:22"
)
.unwrap(),
ProxyTarget {
host: "::1".into(),
port: 8443,
authority: "target.example:22".into()
},
);
for origin in [
"http://proxy.example.org",
"https://proxy.example.org/path",
"https://user@proxy.example.org",
"https://proxy.example.org?query",
"https://proxy.example.org#fragment",
] {
assert!(parse_trusted_origins(origin).is_err(), "{origin}");
assert!(
ProxyTarget::parse(&Url::parse(origin).unwrap(), &origins, "127.0.0.1:22").is_err(),
"{origin}"
);
}
for origin in [
"",
"https://proxy.example.org:443",
"https://proxy.example.org/",
] {
assert!(parse_trusted_origins(origin).is_err(), "{origin}");
}
for (proxy, target) in [
("https://evil.example", "127.0.0.1:22"),
("https://proxy.example.org.attacker.net", "127.0.0.1:22"),
("https://proxy.example.org", "127.0.0.1:0"),
("https://proxy.example.org", "target.example"),
("https://proxy.example.org", "user@target.example:22"),
("https://proxy.example.org", "target.example:65536"),
("https://proxy.example.org", "target.example:22/path"),
] {
assert!(
ProxyTarget::parse(&Url::parse(proxy).unwrap(), &origins, target).is_err(),
"{proxy} {target}"
);
}
}
#[tokio::test]
async fn control_input_acknowledges_bearer_renewal_with_or_without_metadata() -> Result<()> {
for (input, includes_metadata) in [
(&b"first-secret\nsecond-secret\n"[..], false),
(
&b"[[\"x-test-route\",\"private-value\"]]\nfirst-secret\nsecond-secret\n"[..],
true,
),
] {
let (metadata, mut tokens) = control_input(
Cursor::new(input),
includes_metadata,
/*require_portals_oauth*/ false,
)?;
let metadata = metadata.await??;
if includes_metadata {
assert_eq!(metadata["x-test-route"], "private-value");
assert!(metadata["x-test-route"].is_sensitive());
} else {
assert!(metadata.is_empty());
}
let initial = tokens.recv().await.unwrap()?.unwrap();
assert_eq!(initial, "Bearer first-secret");
assert!(initial.is_sensitive());
let (updates, latest) = watch::channel(initial);
let (ready, readiness) = oneshot::channel();
let mut output = Vec::new();
ready.send(()).unwrap();
update_auth_tokens(&mut tokens, updates, readiness, &mut output).await?;
assert_eq!(*latest.borrow(), "Bearer second-secret");
assert!(latest.borrow().is_sensitive());
assert_eq!(output, b"AUTH_UPDATED\n");
}
Ok(())
}
#[tokio::test]
async fn portals_listener_requires_oauth_metadata() -> Result<()> {
let (headers, mut tokens) = control_input(
Cursor::new(b"opaque-access-token\n"),
/*connect_headers_stdin*/ false,
/*require_portals_oauth*/ true,
)?;
assert_eq!(
headers.await?.unwrap_err().to_string(),
"Portals requires OAuth CONNECT metadata"
);
assert!(tokens.recv().await.is_none());
let (headers, mut tokens) = control_input(
Cursor::new(b"[[\"x-portals-auth-mode\",\"oauth\"]]\nopaque-access-token\n"),
/*connect_headers_stdin*/ true,
/*require_portals_oauth*/ true,
)?;
assert_eq!(headers.await??["x-portals-auth-mode"], "oauth");
assert_eq!(
tokens.recv().await.unwrap()?.unwrap(),
"Bearer opaque-access-token"
);
Ok(())
}
#[tokio::test]
async fn closed_parent_pipe_finishes_even_before_proxy_readiness() -> Result<()> {
let (_, mut tokens) = control_input(
Cursor::new([]),
/*connect_headers_stdin*/ false,
/*require_portals_oauth*/ false,
)?;
let (updates, _) = watch::channel("Bearer initial".parse()?);
let (_ready, readiness) = oneshot::channel();
let mut output = Vec::new();
timeout(
Duration::from_secs(1),
update_auth_tokens(&mut tokens, updates, readiness, &mut output),
)
.await??;
assert!(output.is_empty());
Ok(())
}
#[tokio::test]
async fn invalid_control_input_stops_credentials_without_exposing_secrets() -> Result<()> {
let oversized_header = format!(
"[[\"x-test\",\"private-value{}\"]]\n",
"x".repeat(MAX_CONNECT_HEADER_VALUE_BYTES)
);
let oversized_metadata = vec![b'x'; MAX_CONNECT_METADATA_BYTES + 1];
let mut oversized_count = serde_json::to_vec(
&(0..=MAX_CONNECT_HEADERS)
.map(|index| (format!("x-test-{index}"), "private-value"))
.collect::<Vec<_>>(),
)?;
oversized_count.push(b'\n');
let invalid_metadata: &[(&str, &[u8])] = &[
(
"authorization",
b"[[\"authorization\",\"private-value\"]]\n",
),
("forwarding", b"[[\"x-forwarded-for\",\"private-value\"]]\n"),
("real IP", b"[[\"x-real-ip\",\"private-value\"]]\n"),
(
"duplicate",
b"[[\"x-test\",\"one\"],[\"X-Test\",\"private-value\"]]\n",
),
(
"invalid value",
b"[[\"x-test\",\"private-value\\nmore\"]]\n",
),
("invalid JSON", b"\"private-value\"\n"),
("missing newline", b"[[\"x-test\",\"private-value\"]]"),
("value limit", oversized_header.as_bytes()),
("metadata limit", &oversized_metadata),
("header count", &oversized_count),
];
for &(case, input) in invalid_metadata {
let mut input = input.to_vec();
input.extend_from_slice(b"private-secret\n");
let (metadata, mut tokens) = control_input(
Cursor::new(input),
/*connect_headers_stdin*/ true,
/*require_portals_oauth*/ false,
)?;
let error = metadata.await?.expect_err(case);
assert!(!format!("{error:#}").contains("private-"), "{case}");
assert!(tokens.recv().await.is_none(), "{case}");
}
for (case, input) in [
("invalid bearer", b" private-secret\0 \n".to_vec()),
("empty bearer", b"\n".to_vec()),
("bearer limit", vec![b'x'; MAX_TOKEN_BYTES + 1]),
] {
let (metadata, mut tokens) = control_input(
Cursor::new(input),
/*connect_headers_stdin*/ false,
/*require_portals_oauth*/ false,
)?;
assert!(metadata.await??.is_empty(), "{case}");
let error = tokens.recv().await.expect(case).expect_err(case);
assert!(!format!("{error:#}").contains("private-"), "{case}");
assert!(tokens.recv().await.is_none(), "{case}");
}
Ok(())
}
fn local_proxy() -> Result<(quinn::Endpoint, quinn::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_tls = 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_tls.alpn_protocols = vec![b"h3".to_vec()];
let server_config = quinn::ServerConfig::with_crypto(Arc::new(
quinn::crypto::rustls::QuicServerConfig::try_from(server_tls)?,
));
let endpoint = quinn::Endpoint::server(server_config, "127.0.0.1:0".parse()?)?;
let mut roots = rustls::RootCertStore::empty();
roots.add(cert.der().clone())?;
let mut client_tls = rustls::ClientConfig::builder_with_provider(provider)
.with_safe_default_protocol_versions()?
.with_root_certificates(roots)
.with_no_client_auth();
client_tls.alpn_protocols = vec![b"h3".to_vec()];
let config = quinn::ClientConfig::new(Arc::new(
quinn::crypto::rustls::QuicClientConfig::try_from(client_tls)?,
));
Ok((endpoint, config))
}
#[tokio::test]
async fn stdio_propagates_half_close_and_exits_on_gateway_eof_or_rejection() -> Result<()> {
let (endpoint, config) = local_proxy()?;
let address = endpoint.local_addr()?;
let target = ProxyTarget {
host: address.ip().to_string(),
port: address.port(),
authority: address.to_string(),
};
let (done, keep_alive) = oneshot::channel();
let server = tokio::spawn(async move {
let quic = endpoint.accept().await.unwrap().await?;
let mut http = h3::server::Connection::new(h3_quinn::Connection::new(quic)).await?;
for (index, status) in [200, 200, 401].into_iter().enumerate() {
let (_, mut stream) = http.accept().await?.unwrap().resolve_request().await?;
stream
.send_response(Response::builder().status(status).body(())?)
.await?;
if status == 200 {
stream.send_data(Bytes::from_static(b"\0\xff")).await?;
}
// First request must forward the final bytes and FIN before reading the reply.
// The next request sees remote EOF with its own input still open.
if index == 0 {
let mut data = stream.recv_data().await?.unwrap();
let size = data.remaining();
assert_eq!(data.copy_to_bytes(size), Bytes::from_static(b"request"));
assert!(stream.recv_data().await?.is_none());
stream.send_data(Bytes::from_static(b"after FIN")).await?;
}
stream.finish().await?;
}
let _ = keep_alive.await;
anyhow::Ok(())
});
let ProxyConnection {
endpoint: _endpoint,
quic: _quic,
mut connection,
mut sender,
} = ProxyConnection::connect(&target, &config).await?;
let driver = tokio::spawn(async move { connection.wait_idle().await });
for index in 0..3 {
let request = target.request(http::HeaderMap::new(), "Bearer fixture".parse()?)?;
let (mut input, reader) = tokio::io::duplex(16);
if index == 0 {
input.write_all(b"request").await?;
input.shutdown().await?;
}
let mut output = Vec::new();
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,
stream,
/*exit_on_remote_eof*/ true,
)
.await
})
.await?;
match index {
0 => {
result?;
assert_eq!(output, b"\0\xffafter FIN");
}
1 => {
result?;
assert_eq!(output, b"\0\xff");
}
_ => {
assert_eq!(
result.unwrap_err().to_string(),
"MASQUE CONNECT rejected with status 401"
);
assert!(output.is_empty());
}
}
}
done.send(()).unwrap();
server.await??;
driver.abort();
Ok(())
}
#[tokio::test]
async fn connect_rejects_qpack_expansion_and_keeps_connection_usable() -> Result<()> {
timeout(Duration::from_secs(15), async {
let (endpoint, config) = local_proxy()?;
let address = endpoint.local_addr()?;
let (done_tx, done_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let quic = endpoint.accept().await.unwrap().await.unwrap();
let mut control = quic.open_uni().await.unwrap();
// HTTP/3 control stream with empty SETTINGS.
control.write_all(&[0x00, 0x04, 0x00]).await.unwrap();
for fields in [648_u32, 649, 32_768, 1] {
let (mut send, _recv) = quic.accept_bi().await.unwrap();
// Bypass the server library's enforcement of peer SETTINGS.
// HEADERS with a four-byte QUIC varint length, QPACK prefix,
// :status=200, then one-byte static references to a 101-byte field.
let mut response = vec![0x01];
response.extend_from_slice(&(0x8000_0000 | (fields + 3)).to_be_bytes());
response.extend_from_slice(&[0x00, 0x00, 0xd9]);
response.resize(response.len() + fields as usize, 0xfa);
send.write_all(&response).await.unwrap();
send.finish().unwrap();
}
let _ = done_rx.await;
});
let target = ProxyTarget {
host: address.ip().to_string(),
port: address.port(),
authority: "127.0.0.1:22".to_string(),
};
let ProxyConnection {
endpoint: _endpoint,
quic: _quic,
mut connection,
mut sender,
} = ProxyConnection::connect(&target, &config).await?;
let driver = tokio::spawn(async move { connection.wait_idle().await });
for oversized in [false, true, true, false] {
let request = http::Request::builder()
.method(http::Method::CONNECT)
.uri(http::Uri::builder().authority("127.0.0.1:22").build()?)
.body(())?;
let mut stream = sender.send_request(request).await?;
let result = stream.recv_response().await;
if oversized {
let error = result.expect_err("oversized response must be rejected");
assert!(matches!(
error,
h3::error::StreamError::HeaderTooBig {
actual_size,
max_size: 65_536,
..
} if actual_size > 65_536
));
} else {
assert_eq!(result?.status(), http::StatusCode::OK);
}
}
done_tx.send(()).unwrap();
server.await?;
driver.abort();
Ok(())
})
.await?
}
#[tokio::test]
async fn transport_reconnect_keeps_listener_and_does_not_replay_old_tcp_streams() -> Result<()> {
let (endpoint, config) = local_proxy()?;
let proxy_address = endpoint.local_addr()?;
let request_count = Arc::new(AtomicUsize::new(0));
let server_request_count = request_count.clone();
let (accepted, mut connections) = mpsc::unbounded_channel();
let (authorizations, mut tokens) = mpsc::unbounded_channel();
let server = tokio::spawn(async move {
while let Some(incoming) = endpoint.accept().await {
let accepted = accepted.clone();
let request_count = server_request_count.clone();
let authorizations = authorizations.clone();
tokio::spawn(async move {
let quic = incoming.await.unwrap();
let (shutdown, mut shutdown_requests) = mpsc::channel::<oneshot::Sender<()>>(1);
accepted.send((quic.clone(), shutdown)).unwrap();
let mut http = h3::server::builder()
.enable_extended_connect(true)
.build(h3_quinn::Connection::new(quic))
.await
.unwrap();
loop {
let request = tokio::select! {
Some(finished) = shutdown_requests.recv() => {
http.shutdown(/*max_requests*/ 0).await.unwrap();
let _ = finished.send(());
continue;
}
request = http.accept() => match request {
Ok(Some(request)) => request,
_ => break,
},
};
let (request, mut stream) = request.resolve_request().await.unwrap();
authorizations
.send((
request.headers()[http::header::AUTHORIZATION].clone(),
request.headers()["x-test-route"].clone(),
))
.unwrap();
if request.headers()[http::header::AUTHORIZATION] == "Bearer rejected-test" {
stream
.send_response(Response::builder().status(403).body(()).unwrap())
.await
.unwrap();
stream.finish().await.unwrap();
continue;
}
request_count.fetch_add(1, Ordering::SeqCst);
tokio::spawn(async move {
if stream
.send_response(Response::builder().status(200).body(()).unwrap())
.await
.is_ok()
&& stream.send_data(Bytes::from_static(b"ready")).await.is_ok()
{
while let Ok(Some(mut data)) = stream.recv_data().await {
let count = data.remaining();
if stream.send_data(data.copy_to_bytes(count)).await.is_err() {
break;
}
}
}
});
}
});
}
});
let listener = TcpListener::bind("127.0.0.1:0").await?;
let address = listener.local_addr()?;
let target = ProxyTarget {
host: proxy_address.ip().to_string(),
port: proxy_address.port(),
authority: "127.0.0.1:22".to_string(),
};
let (updates, auth) = watch::channel("Bearer local-test".parse()?);
let headers = TunnelHeaders {
auth,
connect: read_connect_headers(&mut &b"[[\"x-test-route\",\"custom-route\"]]\n"[..])?,
};
let initial = ProxyConnection::connect(&target, &config).await?;
let client = tokio::spawn(serve(
listener,
target,
config,
headers,
initial,
Diagnostics::Json,
));
let (first_connection, _) = timeout(Duration::from_secs(5), connections.recv())
.await?
.unwrap();
let mut first = TcpStream::connect(address).await?;
let mut data = [0; 5];
timeout(Duration::from_secs(5), first.read_exact(&mut data)).await??;
assert_eq!(data, *b"ready");
assert_eq!(
tokens.recv().await.unwrap(),
("Bearer local-test".parse()?, "custom-route".parse()?)
);
updates.send_replace("Bearer rejected-test".parse()?);
let mut rejected = TcpStream::connect(address).await?;
assert_eq!(
timeout(Duration::from_secs(5), rejected.read(&mut data)).await??,
0
);
assert_eq!(
tokens.recv().await.unwrap(),
("Bearer rejected-test".parse()?, "custom-route".parse()?)
);
updates.send_replace("Bearer replacement-test".parse()?);
let mut refreshed = TcpStream::connect(address).await?;
timeout(Duration::from_secs(5), refreshed.read_exact(&mut data)).await??;
assert_eq!(
tokens.recv().await.unwrap(),
("Bearer replacement-test".parse()?, "custom-route".parse()?)
);
first_connection.close(/*error_code*/ 0_u8.into(), b"test interruption");
let old_stream = timeout(Duration::from_secs(5), first.read(&mut data)).await?;
assert!(matches!(old_stream, Ok(0) | Err(_)));
let (_, graceful_shutdown) = timeout(Duration::from_secs(10), connections.recv())
.await?
.unwrap();
assert_eq!(request_count.load(Ordering::SeqCst), 2);
let connect_ready_listener = move || async move {
loop {
let mut candidate = TcpStream::connect(address).await?;
let mut data = [0; 5];
if timeout(Duration::from_millis(250), candidate.read_exact(&mut data))
.await
.is_ok_and(|result| result.is_ok())
{
return Ok::<_, anyhow::Error>((data, candidate));
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
};
let (recovered, mut persistent) =
timeout(Duration::from_secs(5), connect_ready_listener()).await??;
assert_eq!(recovered, *b"ready");
assert_eq!(
tokens.recv().await.unwrap(),
("Bearer replacement-test".parse()?, "custom-route".parse()?)
);
assert_eq!(request_count.load(Ordering::SeqCst), 3);
let (sent, goaway_sent) = oneshot::channel();
graceful_shutdown.send(sent).await?;
goaway_sent.await?;
persistent.write_all(b"still").await?;
timeout(Duration::from_secs(5), persistent.read_exact(&mut data)).await??;
assert_eq!(data, *b"still");
let new_request = tokio::spawn(connect_ready_listener());
timeout(Duration::from_secs(10), connections.recv())
.await?
.unwrap();
let (ready, _) = timeout(Duration::from_secs(5), new_request).await???;
assert_eq!(ready, *b"ready");
persistent.write_all(b"alive").await?;
timeout(Duration::from_secs(5), persistent.read_exact(&mut data)).await??;
assert_eq!(data, *b"alive");
client.abort();
server.abort();
Ok(())
}
#[test]
fn diagnostics_flag_is_optional_and_advertised() {
#[derive(clap::Parser)]
struct Cli {
#[command(flatten)]
args: super::Args,
}
use clap::CommandFactory;
use clap::Parser;
let args = [
"tcp-tunnel",
"--proxy-url",
"https://proxy.example",
"--proxy-origins-file",
"origins",
"--target",
"target:22",
"--auth-token-stdin",
];
assert!(!Cli::try_parse_from(args).unwrap().args.diagnostics_json);
assert!(
Cli::try_parse_from(args.into_iter().chain(["--diagnostics-json"]))
.unwrap()
.args
.diagnostics_json
);
assert!(
Cli::command()
.render_help()
.to_string()
.contains("--diagnostics-json")
);
}
+58 -26
View File
@@ -13,9 +13,8 @@ use tokio::io::AsyncWrite;
use tokio::io::AsyncWriteExt;
use super::Args;
use super::Code;
use super::ProxyTarget;
use super::control::bearer_header;
use super::SetupError;
use super::transport::Config as TransportConfig;
// Only gateways shipped with the CLI may receive the signed-in account's credential.
@@ -24,22 +23,20 @@ pub(super) const GATEWAY_ORIGINS: &[&str] = &[PUBLIC_GATEWAY];
impl Args {
fn ssh_destination(&self) -> Result<(ProxyTarget, HeaderMap)> {
let (environment_id, port) = match self.environment_id.as_deref() {
Some(id) => (id, self.port.map_or(/*default*/ 22, NonZeroU16::get)),
None => {
let (id, port) = self
.target
.as_deref()
.and_then(|target| target.rsplit_once(':'))
.context("SSH target must be ENV:PORT")?;
(
id,
port.parse::<NonZeroU16>()
.context("invalid SSH target port")?
.get(),
)
}
};
if let Some(target) = self.target {
ensure!(
target.is_ipv4() && target.port() != 0 && self.token_file.is_some(),
"invalid legacy CONNECT target"
);
return Ok((
ProxyTarget::parse(&self.proxy_url, GATEWAY_ORIGINS, &target.to_string())?,
HeaderMap::new(),
));
}
let environment_id = self
.environment_id
.as_deref()
.context("missing environment ID")?;
ensure!(
(1..=256).contains(&environment_id.len())
&& environment_id
@@ -56,7 +53,10 @@ impl Args {
"x-portals-environment-id",
HeaderValue::from_str(environment_id)?,
);
headers.insert("x-portals-port", port.into());
headers.insert(
"x-portals-port",
self.port.map_or(/*default*/ 22, NonZeroU16::get).into(),
);
Ok((target, headers))
}
}
@@ -65,13 +65,45 @@ fn oauth_bearer(token: &str) -> Result<HeaderValue> {
let unpadded = token.trim_end_matches('=');
ensure!(
!unpadded.is_empty()
&& token.len() < super::control::MAX_TOKEN_BYTES
&& token.len() < super::MAX_TOKEN_BYTES
&& unpadded
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"-._~+/".contains(&b)),
"invalid OAuth access token"
"invalid access token"
);
bearer_header(token)
let mut bearer =
HeaderValue::from_str(&format!("Bearer {token}")).context("invalid access token")?;
bearer.set_sensitive(true);
Ok(bearer)
}
pub async fn run_ssh_proxy_from_file(args: Args, stdout: impl AsyncWrite + Unpin) -> Result<()> {
let path = args.token_file.clone().context("missing token file")?;
run_ssh_proxy(
args,
async move {
let mut file = std::fs::File::open(&path).context("opening private token file")?;
let metadata = file.metadata()?;
ensure!(
metadata.is_file() && metadata.len() < super::MAX_TOKEN_BYTES as u64,
"invalid private token file"
);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
ensure!(
metadata.permissions().mode() & 0o077 == 0,
"token file must be private"
);
}
std::fs::remove_file(&path).context("removing one-use token file")?;
let mut token = String::new();
file.read_to_string(&mut token)?;
Ok(token)
},
stdout,
)
.await
}
/// Relay one SSH session. Poll the active account's token only after verifying the gateway.
@@ -112,7 +144,7 @@ pub async fn run_ssh_proxy(
};
let _ = outcome.send(result);
})?;
let relay = tunnel.relay(reader, stdout, /*exit_on_remote_eof*/ true);
let relay = tunnel.relay(reader, stdout);
let forward = async {
tokio::pin!(relay);
tokio::select! {
@@ -126,9 +158,9 @@ pub async fn run_ssh_proxy(
}
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(),
match err.downcast_ref::<SetupError>() {
Some(SetupError::Rejected(status)) => SetupError::Rejected(*status).into(),
Some(SetupError::Timeout) => SetupError::Timeout.into(),
_ => anyhow::anyhow!("SSH tunnel stream failed"),
}
}
+70 -103
View File
@@ -1,24 +1,12 @@
#![cfg(test)]
//! Check route authority and credential isolation before any network I/O.
use clap::Parser;
use http::Method;
//! Exercise route selection, credential boundaries, and the native OAuth CONNECT request.
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;
use pretty_assertions::assert_eq;
use crate::Args;
use crate::SetupError;
#[derive(Parser)]
struct Cli {
@@ -26,110 +14,82 @@ struct Cli {
args: Args,
}
fn tcp_tunnel_args<'a>(gateway: &'a str, target: &'a str) -> [&'a str; 5] {
["tcp-tunnel", "--proxy-url", gateway, "--target", target]
}
#[test]
fn listener_options_require_the_separate_stdin_control_protocol() {
let ssh = tcp_tunnel_args(PUBLIC_GATEWAY, "ccarenv_test:22");
assert!(!Cli::try_parse_from(ssh).unwrap().args.auth_token_stdin);
for incomplete in [
&["--auth-token-stdin"][..],
&["--proxy-origins-file", "origins"],
&["--listen-addr", "127.0.0.1:0"],
&["--connect-headers-stdin"],
&["--auth-token-updates-stdin"],
&["--diagnostics-json"],
] {
assert!(Cli::try_parse_from(ssh.into_iter().chain(incomplete.iter().copied())).is_err());
}
}
#[test]
fn connect_routes_by_gateway_authority_and_published_port() -> anyhow::Result<()> {
let args = Cli::try_parse_from(tcp_tunnel_args(PUBLIC_GATEWAY, "ccarenv_test-1:2222"))?.args;
let named = Cli::try_parse_from([
fn routes_oauth_and_legacy_without_ambiguous_authority() -> anyhow::Result<()> {
let oauth = Cli::try_parse_from([
"tcp-tunnel",
"--environment-id",
"ccarenv_test-1",
"ccarenv_test",
"--port",
"2222",
])?
.args;
let (target, metadata) = named.ssh_destination()?;
let (explicit_target, explicit_headers) = args.ssh_destination()?;
assert_eq!(target, explicit_target);
assert_eq!(metadata, explicit_headers);
let request = target.request(metadata, oauth_bearer("local-fixture==")?)?;
assert!(request.headers()[http::header::AUTHORIZATION].is_sensitive());
let (target, headers) = oauth.ssh_destination()?;
let request = target.request(headers, oauth_bearer("fixture==")?)?;
assert_eq!(request.method(), Method::CONNECT);
assert_eq!(
request.uri().to_string(),
"codex-portals.api.openai.com:443"
);
let expected = HeaderMap::from_iter([
(
http::header::AUTHORIZATION,
"Bearer local-fixture==".parse()?,
),
("x-portals-auth-mode".parse()?, "oauth".parse()?),
(
"x-portals-environment-id".parse()?,
"ccarenv_test-1".parse()?,
),
("x-portals-port".parse()?, "2222".parse()?),
]);
assert_eq!(request.headers(), &expected);
assert_eq!(
request.headers()["x-portals-environment-id"],
"ccarenv_test"
);
assert_eq!(request.headers()["x-portals-port"], "2222");
assert!(request.headers()["authorization"].is_sensitive());
let legacy = Cli::try_parse_from([
"tcp-tunnel",
"--token-file",
"/private/token",
"--target",
"10.0.0.1:22",
])?
.args;
let (target, headers) = legacy.ssh_destination()?;
assert_eq!(target.authority, "10.0.0.1:22");
assert!(headers.is_empty());
assert!(Cli::try_parse_from(["tcp-tunnel", "--target", "10.0.0.1:22"]).is_err());
assert!(
Cli::try_parse_from([
"tcp-tunnel",
"--environment-id",
"env",
"--target",
"10.0.0.1:22",
"--token-file",
"/private/token"
])
.is_err()
);
Ok(())
}
#[tokio::test]
async fn invalid_routes_fail_before_reading_oauth_or_writing_stdout() -> anyhow::Result<()> {
for (url, target) in [
(PUBLIC_GATEWAY, ":22"),
(PUBLIC_GATEWAY, "env"),
(PUBLIC_GATEWAY, "env:0"),
(PUBLIC_GATEWAY, "env:65536"),
(PUBLIC_GATEWAY, "id\r\nother: value:22"),
("https://codex-portals.api.openai.com.bad", "valid:22"),
("https://codex-portals.api.openai.com:4443", "valid:22"),
async fn rejects_bad_origin_and_route_before_loading_credentials() -> anyhow::Result<()> {
for (url, id) in [
(PUBLIC_GATEWAY, "bad\r\nvalue"),
("https://codex-portals.api.openai.com.attacker.net", "valid"),
("https://codex-portals.api.openai.com:4443", "valid"),
] {
let args = Cli::try_parse_from(tcp_tunnel_args(url, target))?.args;
let mut out = Vec::new();
let result = run_ssh_proxy(
args,
async { panic!("unexpected credential lookup") },
&mut out,
)
.await;
assert!(result.is_err());
assert!(out.is_empty());
let args =
Cli::try_parse_from(["tcp-tunnel", "--environment-id", id, "--proxy-url", url])?.args;
let mut stdout = Vec::new();
assert!(
run_ssh_proxy(
args,
async { panic!("credential lookup before gateway validation") },
&mut stdout
)
.await
.is_err()
);
assert!(stdout.is_empty());
}
Ok(())
}
#[test]
fn environment_id_defaults_to_ssh_and_rejects_ambiguous_routes() -> anyhow::Result<()> {
let named = ["tcp-tunnel", "--environment-id", "ccarenv_test"];
assert_eq!(
Cli::try_parse_from(named)?.args.ssh_destination()?.1["x-portals-port"],
"22"
);
for extra in [
&["--port", "0"][..],
&["--port", "65536"],
&["--target", "other:22"],
&["--auth-token-stdin", "--proxy-origins-file", "origins"],
] {
assert!(Cli::try_parse_from(named.into_iter().chain(extra.iter().copied())).is_err());
}
assert!(Cli::try_parse_from(["tcp-tunnel", "--target", "env:22"]).is_err());
Ok(())
}
#[test]
fn rejects_invalid_oauth_credentials_without_echoing_them() {
fn rejects_invalid_credentials_and_sanitizes_peer_errors() {
for token in [
"",
"=",
@@ -137,9 +97,16 @@ fn rejects_invalid_oauth_credentials_without_echoing_them() {
"private\r\nvalue",
"private secret",
] {
assert_eq!(
oauth_bearer(token).unwrap_err().to_string(),
"invalid OAuth access token"
);
assert!(oauth_bearer(token).is_err());
}
assert!(
!super::safe_tunnel_error(anyhow::anyhow!("peer supplied secret"))
.to_string()
.contains("secret")
);
assert!(
super::safe_tunnel_error(SetupError::Rejected(http::StatusCode::FORBIDDEN).into())
.to_string()
.contains("403")
);
}
+14 -12
View File
@@ -15,7 +15,7 @@ use tokio::io::AsyncWrite;
use crate::PROXY_CONNECT_TIMEOUT;
use crate::ProxyConnection;
use crate::ProxyTarget;
use crate::diagnostics::Code;
use crate::SetupError;
use crate::http2;
const QUIC_HEAD_START: Duration = Duration::from_millis(250);
@@ -50,6 +50,13 @@ impl Config {
request: impl Future<Output = Result<Request<()>>>,
) -> Result<Tunnel> {
tokio::time::timeout(PROXY_CONNECT_TIMEOUT, async {
if let Some((uri, proxy)) = http2::system_proxy(target)? {
let (sender, connection) =
http2::connect_through_proxy(target, self.tls.clone(), uri, proxy).await?;
return Connection::Http2(sender, Box::new(connection))
.admit(request.await?)
.await;
}
let quic = async {
ProxyConnection::connect(target, &self.quic)
.await
@@ -57,11 +64,7 @@ impl Config {
};
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)
http2::connect(target, self.tls.clone())
.await
.map(|(sender, connection)| Connection::Http2(sender, Box::new(connection)))
};
@@ -73,7 +76,7 @@ impl Config {
}
})
.await
.context(Code::Timeout)?
.context(SetupError::Timeout)?
}
}
@@ -105,8 +108,8 @@ async fn complete_or_try_other(
Ok(tunnel) => Ok(tunnel),
Err(error)
if error
.downcast_ref::<Code>()
.is_some_and(|c| matches!(c, Code::Rejected(_))) =>
.downcast_ref::<SetupError>()
.is_some_and(|c| matches!(c, SetupError::Rejected(_))) =>
{
Err(error)
}
@@ -167,12 +170,11 @@ impl Tunnel {
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);
let forward = crate::bridge_h3_stream(input, output, stream);
tokio::pin!(forward);
tokio::select! {
result = &mut forward => result,
@@ -185,7 +187,7 @@ impl Tunnel {
recv,
} => {
let result = {
let forward = http2::bridge(input, output, send, recv, exit_on_remote_eof);
let forward = http2::bridge(input, output, send, recv);
tokio::pin!(forward);
tokio::select! {
result = &mut forward => result,
+144 -9
View File
@@ -22,8 +22,8 @@ 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 {
let tcp = TcpListener::bind("127.0.0.1:0").await?;
if let Ok(udp) = UdpSocket::bind(tcp.local_addr()?) {
udp.set_nonblocking(true)?;
return Ok((tcp, udp));
}
@@ -150,8 +150,8 @@ async fn admission_rejection_is_terminal() -> Result<()> {
.err()
.unwrap();
assert!(matches!(
error.downcast_ref::<crate::diagnostics::Code>(),
Some(crate::diagnostics::Code::Rejected(StatusCode::FORBIDDEN))
error.downcast_ref::<crate::SetupError>(),
Some(crate::SetupError::Rejected(StatusCode::FORBIDDEN))
));
assert!(
timeout(Duration::from_millis(20), tcp.accept())
@@ -191,13 +191,148 @@ async fn setup_deadline_includes_connect_response() -> Result<()> {
)
.await?;
assert!(matches!(
result
.err()
.unwrap()
.downcast_ref::<crate::diagnostics::Code>(),
Some(crate::diagnostics::Code::Timeout)
result.err().unwrap().downcast_ref::<crate::SetupError>(),
Some(crate::SetupError::Timeout)
));
quic.abort();
h2.abort();
Ok(())
}
/// Run with a local, unprivileged sshd and a simple stdio-to-TCP ProxyCommand.
/// This tests the SSH guarantee: a successful remote command has consumed the
/// complete upload, even while QUIC delivery and remote EOF race.
#[cfg(target_os = "linux")]
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires a local sshd fixture; see PORTALS_TEST_SSHD_PORT, PORTALS_TEST_KEY, and PORTALS_TEST_PROXY"]
async fn real_ssh_delivery_over_http3() -> Result<()> {
real_ssh_case(/*remote_exits_early*/ false).await?;
real_ssh_case(/*remote_exits_early*/ true).await
}
#[cfg(target_os = "linux")]
async fn real_ssh_case(remote_exits_early: bool) -> Result<()> {
use bytes::Buf;
use std::io::Write;
use std::process::Command;
use std::process::Stdio;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;
let sshd_port: u16 = std::env::var("PORTALS_TEST_SSHD_PORT")?.parse()?;
let key = std::env::var("PORTALS_TEST_KEY")?;
let proxy_script = std::env::var("PORTALS_TEST_PROXY")?;
let user = std::env::var("USER")?;
let (tls, client) = tls_configs()?;
let (tcp, udp) = sockets().await?;
let address = tcp.local_addr()?;
let endpoint = endpoint(udp, tls)?;
let gateway = 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::new(())).await?;
let socket = tokio::net::TcpStream::connect(("127.0.0.1", sshd_port)).await?;
let (mut read, mut write) = socket.into_split();
let (mut send, mut recv) = stream.split();
let upload = async {
while let Some(mut data) = recv.recv_data().await? {
while data.has_remaining() {
let part = data.chunk();
write.write_all(part).await?;
data.advance(part.len());
}
}
write.shutdown().await?;
Ok::<_, anyhow::Error>(())
};
let download = async {
let mut buf = vec![0; 65536];
loop {
let n = read.read(&mut buf).await?;
if n == 0 {
send.finish().await?;
return Ok::<_, anyhow::Error>(());
}
send.send_data(Bytes::copy_from_slice(&buf[..n])).await?;
}
};
tokio::pin!(upload, download);
tokio::select! {
result = &mut download => result?,
result = &mut upload => { result?; download.await?; }
}
quic.closed().await;
Ok::<_, anyhow::Error>(())
});
let front = TcpListener::bind("127.0.0.1:0").await?;
let port = front.local_addr()?.port();
let ssh = tokio::task::spawn_blocking(move || -> Result<_> {
let mut command = Command::new("timeout");
command.args([
"15",
"ssh",
"-F",
"/dev/null",
"-T",
"-i",
&key,
"-o",
"BatchMode=yes",
"-o",
"StrictHostKeyChecking=no",
"-o",
"UserKnownHostsFile=/dev/null",
"-o",
"LogLevel=ERROR",
"-o",
&format!("ProxyCommand=python3 {proxy_script} {port}"),
&format!("{user}@localhost"),
if remote_exits_early {
"exit 0"
} else {
"wc -c"
},
]);
let mut child = command
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()?;
let mut stdin = child.stdin.take().unwrap();
if remote_exits_early {
let output = child.wait_with_output()?;
drop(stdin);
Ok(output)
} else {
stdin.write_all(&vec![b'x'; 1024 * 1024 + 17])?;
drop(stdin);
Ok(child.wait_with_output()?)
}
});
let (socket, _) = front.accept().await?;
let tunnel = Config::new(client)?
.open(&target(address), async { request(address) })
.await?;
assert!(matches!(tunnel, Tunnel::Http3(_)));
let (input, output) = socket.into_split();
let relay = tokio::spawn(tunnel.relay(input, output));
let output = ssh.await??;
assert!(
output.status.success(),
"ssh failed: {}",
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(
String::from_utf8(output.stdout)?.trim(),
if remote_exits_early { "" } else { "1048593" }
);
relay
.await?
.map_err(|error| anyhow::anyhow!("client relay: {error:#}"))?;
gateway
.await?
.map_err(|error| anyhow::anyhow!("gateway: {error:#}"))?;
Ok(())
}
+40
View File
@@ -0,0 +1,40 @@
#!/usr/bin/env bash
set -euo pipefail
# Opt-in Linux integration test using an unprivileged OpenSSH server.
fixture="$(mktemp -d)"
sshd_pid=""
trap 'if [[ -n "$sshd_pid" ]]; then kill "$sshd_pid" 2>/dev/null || true; fi; rm -rf "$fixture"' EXIT
ssh-keygen -q -t ed25519 -N "" -f "$fixture/host"
ssh-keygen -q -t ed25519 -N "" -f "$fixture/client"
cp "$fixture/client.pub" "$fixture/authorized_keys"
port="$(python3 -c 'import socket; s=socket.socket(); s.bind(("127.0.0.1",0)); print(s.getsockname()[1])')"
cat > "$fixture/proxy.py" <<'PY'
import socket
import sys
import threading
peer = socket.create_connection(("127.0.0.1", int(sys.argv[1])))
def upload():
try:
while chunk := sys.stdin.buffer.read1(65536):
peer.sendall(chunk)
peer.shutdown(socket.SHUT_WR)
except OSError:
pass
threading.Thread(target=upload, daemon=True).start()
while chunk := peer.recv(65536):
sys.stdout.buffer.write(chunk)
sys.stdout.buffer.flush()
PY
"$(command -v sshd)" -D -e -f /dev/null -p "$port" -h "$fixture/host" \
-o ListenAddress=127.0.0.1 -o PidFile=none -o UsePAM=no -o StrictModes=no \
-o "AuthorizedKeysFile=$fixture/authorized_keys" -o PasswordAuthentication=no \
-o KbdInteractiveAuthentication=no -o LogLevel=ERROR &
sshd_pid=$!
export PORTALS_TEST_SSHD_PORT="$port" PORTALS_TEST_KEY="$fixture/client"
export PORTALS_TEST_PROXY="$fixture/proxy.py"
cd "$(dirname "$0")/../.."
just test -p codex-tcp-tunnel --lib real_ssh_delivery_over_http3 --run-ignored all