diff --git a/crates/openshell-sandbox/src/l7/relay.rs b/crates/openshell-sandbox/src/l7/relay.rs
index 110f777e91..e57c86c57f 100644
--- a/crates/openshell-sandbox/src/l7/relay.rs
+++ b/crates/openshell-sandbox/src/l7/relay.rs
@@ -7,7 +7,7 @@
//! Parses each request within the tunnel, evaluates it against OPA policy,
//! and either forwards or denies the request.
-use crate::l7::provider::{L7Provider, RelayOutcome};
+use crate::l7::provider::{L7Provider, L7Request, RelayOutcome};
use crate::l7::{EnforcementMode, L7EndpointConfig, L7Protocol, L7RequestInfo};
use crate::secrets::{self, SecretResolver};
use miette::{IntoDiagnostic, Result, miette};
@@ -16,7 +16,7 @@ use openshell_ocsf::{
NetworkActivityBuilder, SeverityId, Url as OcsfUrl, ocsf_emit,
};
use std::sync::{Arc, Mutex};
-use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use tracing::{debug, info, warn};
/// Context for L7 request policy evaluation.
@@ -130,7 +130,17 @@ where
{
loop {
// Parse one HTTP request from client
- let req = match crate::l7::rest::RestProvider.parse_request(client).await {
+ let Some(parsed) = next_request_unless_upstream_closed(
+ &crate::l7::rest::RestProvider,
+ client,
+ upstream,
+ ctx,
+ )
+ .await
+ else {
+ return Ok(());
+ };
+ let req = match parsed {
Ok(Some(req)) => req,
Ok(None) => return Ok(()), // Client closed connection
Err(e) => {
@@ -288,6 +298,50 @@ where
}
}
+/// Wait for the client's next request on a keep-alive tunnel while watching
+/// the idle upstream.
+///
+/// Returns `None` when the upstream can no longer carry a request; the caller
+/// then ends the relay, which closes the client side too. An HTTP/1.1 server
+/// sends nothing between responses, so any read result on the idle upstream
+/// (EOF, an error, or unsolicited bytes such as a final `408` before closing)
+/// counts as closed. Without this, a client whose pooled connection outlives
+/// the server's keep-alive timeout writes its next request into a dead
+/// upstream and gets the connection dropped with no response (Go's
+/// `net/http` reports `EOF` and does not retry a POST). Closing the client
+/// side as soon as the upstream closes lets the client drop the connection
+/// from its pool and open a new one, as it would without the proxy.
+async fn next_request_unless_upstream_closed
(
+ provider: &P,
+ client: &mut C,
+ upstream: &mut U,
+ ctx: &L7EvalContext,
+) -> Option>>
+where
+ P: L7Provider,
+ C: AsyncRead + AsyncWrite + Unpin + Send,
+ U: AsyncRead + Unpin,
+{
+ let mut probe = [0u8; 1];
+ tokio::select! {
+ parsed = provider.parse_request(client) => Some(parsed),
+ read = upstream.read(&mut probe) => {
+ let reason = match read {
+ Ok(0) => "eof".to_string(),
+ Ok(n) => format!("{n} unsolicited byte(s)"),
+ Err(e) => e.to_string(),
+ };
+ debug!(
+ host = %ctx.host,
+ port = ctx.port,
+ reason = %reason,
+ "Upstream closed idle connection, closing L7 relay"
+ );
+ None
+ }
+ }
+}
+
/// Check if a miette error represents a benign connection close.
///
/// TLS handshake EOF, missing `close_notify`, connection resets, and broken
@@ -380,7 +434,12 @@ where
loop {
// Read next request from client.
- let req = match provider.parse_request(client).await {
+ let Some(parsed) =
+ next_request_unless_upstream_closed(&provider, client, upstream, ctx).await
+ else {
+ break;
+ };
+ let req = match parsed {
Ok(Some(req)) => req,
Ok(None) => break, // Client closed connection.
Err(e) => {
@@ -461,3 +520,143 @@ where
Ok(())
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::l7::{EnforcementMode, L7Protocol, TlsMode};
+ use std::time::Duration;
+ use tokio::io::{AsyncReadExt, DuplexStream};
+ use tokio::task::JoinHandle;
+
+ const STEP: Duration = Duration::from_secs(5);
+
+ fn test_ctx() -> L7EvalContext {
+ L7EvalContext {
+ host: "api.example.com".into(),
+ port: 443,
+ policy_name: "test".into(),
+ binary_path: "/usr/bin/test".into(),
+ ancestors: vec![],
+ cmdline_paths: vec![],
+ secret_resolver: None,
+ }
+ }
+
+ fn allow_all_engine() -> Mutex {
+ let mut engine = regorus::Engine::new();
+ engine
+ .add_policy(
+ "allow.rego".into(),
+ "package openshell.sandbox\nallow_request := true\n".into(),
+ )
+ .unwrap();
+ Mutex::new(engine)
+ }
+
+ /// Streams seen by the test: the client application side and the upstream
+ /// server side. The relay task owns the proxy-side halves, so they are
+ /// dropped (closed) as soon as the relay returns.
+ fn spawn_relay(inspect: bool) -> (DuplexStream, DuplexStream, JoinHandle>) {
+ let (client, mut client_proxy) = tokio::io::duplex(8192);
+ let (mut upstream_proxy, upstream) = tokio::io::duplex(8192);
+ let relay = tokio::spawn(async move {
+ let ctx = test_ctx();
+ if inspect {
+ let config = L7EndpointConfig {
+ protocol: L7Protocol::Rest,
+ tls: TlsMode::Auto,
+ enforcement: EnforcementMode::Enforce,
+ };
+ relay_with_inspection(
+ &config,
+ allow_all_engine(),
+ &mut client_proxy,
+ &mut upstream_proxy,
+ &ctx,
+ )
+ .await
+ } else {
+ relay_passthrough_with_credentials(&mut client_proxy, &mut upstream_proxy, &ctx)
+ .await
+ }
+ });
+ (client, upstream, relay)
+ }
+
+ async fn read_until(stream: &mut DuplexStream, needle: &[u8]) -> Vec {
+ let mut buf = Vec::new();
+ let mut chunk = [0u8; 1024];
+ while !buf.windows(needle.len()).any(|w| w == needle) {
+ let n = tokio::time::timeout(STEP, stream.read(&mut chunk))
+ .await
+ .expect("read timed out")
+ .unwrap();
+ assert_ne!(n, 0, "stream closed before the expected bytes arrived");
+ buf.extend_from_slice(&chunk[..n]);
+ }
+ buf
+ }
+
+ async fn round_trip(client: &mut DuplexStream, upstream: &mut DuplexStream, path: &str) {
+ client
+ .write_all(format!("GET {path} HTTP/1.1\r\nHost: api.example.com\r\n\r\n").as_bytes())
+ .await
+ .unwrap();
+ let req = read_until(upstream, b"\r\n\r\n").await;
+ assert!(req.starts_with(format!("GET {path} HTTP/1.1").as_bytes()));
+ upstream
+ .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+ .await
+ .unwrap();
+ let resp = read_until(client, b"\r\n\r\nok").await;
+ assert!(resp.starts_with(b"HTTP/1.1 200 OK"));
+ }
+
+ async fn assert_relay_ends_and_client_closed(
+ mut client: DuplexStream,
+ relay: JoinHandle>,
+ ) {
+ tokio::time::timeout(STEP, relay)
+ .await
+ .expect("relay must end once the idle upstream is gone")
+ .unwrap()
+ .unwrap();
+ let mut buf = [0u8; 16];
+ let n = tokio::time::timeout(STEP, client.read(&mut buf))
+ .await
+ .expect("client side must be closed")
+ .unwrap();
+ assert_eq!(n, 0, "client must see EOF, not further bytes");
+ }
+
+ #[tokio::test]
+ async fn rest_relay_closes_client_when_idle_upstream_closes() {
+ let (mut client, mut upstream, relay) = spawn_relay(true);
+ round_trip(&mut client, &mut upstream, "/first").await;
+ round_trip(&mut client, &mut upstream, "/second").await;
+ drop(upstream);
+ assert_relay_ends_and_client_closed(client, relay).await;
+ }
+
+ #[tokio::test]
+ async fn passthrough_relay_closes_client_when_idle_upstream_closes() {
+ let (mut client, mut upstream, relay) = spawn_relay(false);
+ round_trip(&mut client, &mut upstream, "/first").await;
+ round_trip(&mut client, &mut upstream, "/second").await;
+ drop(upstream);
+ assert_relay_ends_and_client_closed(client, relay).await;
+ }
+
+ #[tokio::test]
+ async fn relay_closes_client_on_unsolicited_upstream_bytes() {
+ let (mut client, mut upstream, relay) = spawn_relay(true);
+ round_trip(&mut client, &mut upstream, "/first").await;
+ upstream
+ .write_all(b"HTTP/1.1 408 Request Timeout\r\nContent-Length: 0\r\n\r\n")
+ .await
+ .unwrap();
+ assert_relay_ends_and_client_closed(client, relay).await;
+ drop(upstream);
+ }
+}