Scope network approvals by environment (#28899)

Stacked on #28766.

## Why

Network approvals are environment-scoped: allowing a host in one
execution environment should not allow the same host in another
environment.

#28766 adds the inert IDs and constructor plumbing. This PR applies the
behavior on top.

## What changed

- Route managed network traffic through per-environment HTTP and SOCKS
proxy listeners.
- Stamp HTTP, HTTPS CONNECT, SOCKS TCP, and SOCKS UDP policy requests
with the source environment at the proxy boundary.
- Carry the selected execution environment through shell, unified exec,
zsh-fork, and sandbox transform paths.
- Include the environment in pending, approved-for-session, and
denied-for-session network approval cache keys.
- Include the environment in approval IDs and approval prompts.
- Preserve legacy fallback for unattributed requests, but deny when
active-call attribution is ambiguous.
- Fail closed if an environment-specific proxy endpoint cannot be
prepared.

## Validation

- just fmt
- CI will run tests and clippy
This commit is contained in:
jif authored and GitHub committed 2026-06-19 13:49:45 +02:00
1 parent dac588f413
commit bd5d31b250
20 files changed
+1026 -109

No files matched your search

+95 -29
View File
@@ -87,6 +87,7 @@ pub async fn run_http_proxy(
state: Arc<NetworkProxyState>,
addr: SocketAddr,
policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
environment_id: Option<String>,
) -> Result<()> {
let listener = TcpListener::build()
.bind(addr)
@@ -99,23 +100,25 @@ pub async fn run_http_proxy(
.map_err(anyhow::Error::from)
.with_context(|| format!("bind HTTP proxy: {addr}"))?;
run_http_proxy_with_listener(state, listener, policy_decider).await
run_http_proxy_with_listener(state, listener, policy_decider, environment_id).await
}
pub async fn run_http_proxy_with_std_listener(
state: Arc<NetworkProxyState>,
listener: StdTcpListener,
policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
environment_id: Option<String>,
) -> Result<()> {
let listener =
TcpListener::try_from(listener).context("convert std listener to HTTP proxy listener")?;
run_http_proxy_with_listener(state, listener, policy_decider).await
run_http_proxy_with_listener(state, listener, policy_decider, environment_id).await
}
async fn run_http_proxy_with_listener(
state: Arc<NetworkProxyState>,
listener: TcpListener,
policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
environment_id: Option<String>,
) -> Result<()> {
ensure_rustls_crypto_provider();
@@ -133,7 +136,10 @@ async fn run_http_proxy_with_listener(
MethodMatcher::CONNECT,
service_fn({
let policy_decider = policy_decider.clone();
move |req| http_connect_accept(policy_decider.clone(), req)
let environment_id = environment_id.clone();
move |req| {
http_connect_accept(policy_decider.clone(), environment_id.clone(), req)
}
}),
service_fn(http_connect_proxy),
),
@@ -141,7 +147,8 @@ async fn run_http_proxy_with_listener(
)
.into_layer(service_fn({
let policy_decider = policy_decider.clone();
move |req| http_plain_proxy(policy_decider.clone(), req)
let environment_id = environment_id.clone();
move |req| http_plain_proxy(policy_decider.clone(), environment_id.clone(), req)
})),
);
@@ -155,6 +162,7 @@ async fn run_http_proxy_with_listener(
async fn http_connect_accept(
policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
environment_id: Option<String>,
mut req: Request,
) -> Result<(Response, Request), Response> {
let app_state = req
@@ -200,7 +208,7 @@ async fn http_connect_accept(
protocol: NetworkProtocol::HttpsConnect,
host: host.clone(),
port: authority.port,
environment_id: None,
environment_id,
client_addr: client.clone(),
method: Some("CONNECT".to_string()),
command: None,
@@ -479,6 +487,7 @@ async fn forward_connect_tunnel(
async fn http_plain_proxy(
policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
environment_id: Option<String>,
mut req: Request,
) -> Result<Response, Infallible> {
let app_state = match req.extensions().get::<Arc<NetworkProxyState>>().cloned() {
@@ -684,7 +693,7 @@ async fn http_plain_proxy(
protocol: NetworkProtocol::Http,
host: host.clone(),
port,
environment_id: None,
environment_id,
client_addr: client.clone(),
method: Some(req.method().as_str().to_string()),
command: None,
@@ -1052,6 +1061,7 @@ mod tests {
use std::net::Ipv4Addr;
use std::net::TcpListener as StdTcpListener;
use std::sync::Arc;
use std::sync::Mutex;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener as TokioTcpListener;
@@ -1076,9 +1086,11 @@ mod tests {
.unwrap();
req.extensions_mut().insert(state);
let response = http_connect_accept(/*policy_decider*/ None, req)
.await
.unwrap_err();
let response = http_connect_accept(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap_err();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
assert_eq!(
response.headers().get("x-proxy-error").unwrap(),
@@ -1106,12 +1118,53 @@ mod tests {
.unwrap();
req.extensions_mut().insert(state);
let (response, _request) = http_connect_accept(/*policy_decider*/ None, req)
.await
.unwrap();
let (response, _request) = http_connect_accept(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn http_connect_accept_passes_environment_id_to_decider() {
let state = Arc::new(network_proxy_state_for_policy(
NetworkProxySettings::default(),
));
let seen_environment_id = Arc::new(Mutex::new(None));
let decider: Arc<dyn NetworkPolicyDecider> = Arc::new({
let seen_environment_id = seen_environment_id.clone();
move |request: NetworkPolicyRequest| {
*seen_environment_id
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner) = request.environment_id;
async { NetworkDecision::Allow }
}
});
let mut req = Request::builder()
.method(Method::CONNECT)
.uri("https://example.com:443")
.header("host", "example.com:443")
.body(Body::empty())
.unwrap();
req.extensions_mut().insert(state);
let (response, _request) =
http_connect_accept(Some(decider), Some("remote".to_string()), req)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
seen_environment_id
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.as_deref(),
Some("remote")
);
}
#[tokio::test]
async fn http_connect_accept_blocks_hooked_host_in_full_mode_without_mitm_state() {
let mut policy = NetworkProxySettings {
@@ -1138,9 +1191,11 @@ mod tests {
.unwrap();
req.extensions_mut().insert(state);
let response = http_connect_accept(/*policy_decider*/ None, req)
.await
.unwrap_err();
let response = http_connect_accept(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap_err();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
assert_eq!(
response.headers().get("x-proxy-error").unwrap(),
@@ -1177,7 +1232,7 @@ mod tests {
.local_addr()
.expect("proxy listener should expose local addr");
let proxy_task = tokio::spawn(run_http_proxy_with_std_listener(
state, listener, /*policy_decider*/ None,
state, listener, /*policy_decider*/ None, /*environment_id*/ None,
));
let mut stream = tokio::net::TcpStream::connect(proxy_addr)
@@ -1228,9 +1283,11 @@ mod tests {
.expect("request should build");
req.extensions_mut().insert(state);
let response = http_plain_proxy(/*policy_decider*/ None, req)
.await
.unwrap();
let response = http_plain_proxy(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
assert_eq!(
@@ -1253,9 +1310,11 @@ mod tests {
.expect("request should build");
req.extensions_mut().insert(state);
let response = http_plain_proxy(/*policy_decider*/ None, req)
.await
.unwrap();
let response = http_plain_proxy(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap();
if cfg!(target_os = "macos") {
assert_eq!(response.status(), StatusCode::FORBIDDEN);
@@ -1285,9 +1344,11 @@ mod tests {
.expect("request should build");
req.extensions_mut().insert(state);
let response = http_plain_proxy(/*policy_decider*/ None, req)
.await
.unwrap();
let response = http_plain_proxy(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
}
@@ -1309,9 +1370,11 @@ mod tests {
.unwrap();
req.extensions_mut().insert(state);
let response = http_connect_accept(/*policy_decider*/ None, req)
.await
.unwrap_err();
let response = http_connect_accept(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await
.unwrap_err();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
assert_eq!(
response.headers().get("x-proxy-error").unwrap(),
@@ -1332,7 +1395,10 @@ mod tests {
.unwrap();
req.extensions_mut().insert(state);
let response = http_plain_proxy(/*policy_decider*/ None, req).await;
let response = http_plain_proxy(
/*policy_decider*/ None, /*environment_id*/ None, req,
)
.await;
assert_eq!(response.unwrap().status(), StatusCode::BAD_REQUEST);
}