Lightweight coding agent that runs in your terminal
Rust
Enforce environment network policies for remote execution (#39980)
sayan-oaif580dd886fe5
diff --git a/codex-rs/core/src/config/network_proxy_spec.rs b/codex-rs/core/src/config/network_proxy_spec.rsindex 191340d407..d7921ac05f 100644--- a/codex-rs/core/src/config/network_proxy_spec.rs+++ b/codex-rs/core/src/config/network_proxy_spec.rs@@ -179,6 +179,75 @@ impl NetworkProxySpec {EnvironmentNetworkPolicy::from_config(&self.config, self.hard_deny_allowlist_misses)}+ pub(crate) fn for_environment(+ controller: Option<&Self>,+ policy: &EnvironmentNetworkPolicy,+ permission_profile: &PermissionProfile,+ exec_policy: &Policy,+ ) -> std::io::Result<Self> {+ if matches!(permission_profile, PermissionProfile::Disabled) {+ return Err(std::io::Error::new(+ std::io::ErrorKind::InvalidInput,+ "environment network policy requires managed network enforcement",+ ));+ }+ if controller.is_some_and(|controller| !controller.enabled()) {+ return Err(std::io::Error::new(+ std::io::ErrorKind::InvalidInput,+ "environment network policy cannot override a disabled controller proxy",+ ));+ }+ let mut spec = match controller {+ Some(controller) => controller.recompute_for_permission_profile(permission_profile)?,+ None => Self::from_config_and_constraints(+ NetworkProxyConfig {+ enabled: true,+ // Without a controller, the owner supplies the entire permission ceiling.+ dangerously_allow_all_unix_sockets: true,+ allow_local_binding: true,+ ..NetworkProxyConfig::default()+ },+ /*requirements*/ None,+ permission_profile,+ )?,+ };+ policy.apply_to(&mut spec.config);+ let protected_denials = spec.config.denied_domains().unwrap_or_default();++ // A fixed controller allowlist remains a ceiling; an expandable one is only a baseline.+ // Profiles without managed approvals must not reuse approvals cached by another profile.+ let fixed_allowlist = spec.hard_deny_allowlist_misses+ || spec.constraints.allowlist_expansion_enabled == Some(false);+ spec.hard_deny_allowlist_misses |= policy.managed_allowed_domains_only+ || !Self::managed_sandbox_active(permission_profile);+ let allow_owner_grants = !spec.hard_deny_allowlist_misses && !fixed_allowlist;+ if fixed_allowlist {+ spec.constraints.allowlist_expansion_enabled = None;+ } else {+ spec.constraints.allowed_domains =+ Some(spec.config.allowed_domains().unwrap_or_default());+ spec.constraints.allowlist_expansion_enabled = Some(allow_owner_grants);+ }+ spec.constraints.denylist_expansion_enabled = Some(true);++ // Saved grants can extend a reviewable owner policy; owner denials are restored last.+ let (allowed_domains, denied_domains) = exec_policy.compiled_network_domains();+ if allow_owner_grants {+ upsert_network_domains(&mut spec.config, allowed_domains, /*allow*/ true);+ }+ upsert_network_domains(&mut spec.config, denied_domains, /*allow*/ false);+ upsert_network_domains(&mut spec.config, protected_denials, /*allow*/ false);+ spec.constraints.denied_domains = spec.config.denied_domains();++ validate_policy_against_constraints(&spec.config, &spec.constraints).map_err(|error| {+ std::io::Error::new(+ std::io::ErrorKind::InvalidInput,+ format!("environment network policy violates managed requirements: {error}"),+ )+ })?;+ Ok(spec)+ }+pub(crate) fn with_exec_policy_network_rules(&self,exec_policy: &Policy,@@ -208,7 +277,7 @@ impl NetworkProxySpec {})}- fn build_state_with_audit_metadata(+ pub(crate) fn build_state_with_audit_metadata(&self,audit_metadata: NetworkProxyAuditMetadata,) -> std::io::Result<NetworkProxyState> {diff --git a/codex-rs/core/src/config/network_proxy_spec_tests.rs b/codex-rs/core/src/config/network_proxy_spec_tests.rsindex ff90af0c74..d069a1f2e4 100644--- a/codex-rs/core/src/config/network_proxy_spec_tests.rs+++ b/codex-rs/core/src/config/network_proxy_spec_tests.rs@@ -1,7 +1,11 @@use super::*;use codex_config::NetworkDomainPermissionToml;use codex_config::NetworkDomainPermissionsToml;+use codex_execpolicy::Decision::Allow;+use codex_execpolicy::NetworkRuleProtocol::Https;use codex_network_proxy::NetworkDomainPermission;+use codex_network_proxy::NetworkUnixSocketPermission;+use codex_network_proxy::NetworkUnixSocketPermissions;use codex_protocol::models::ManagedFileSystemPermissions;use codex_protocol::models::PermissionProfile;use codex_protocol::permissions::NetworkSandboxPolicy;@@ -40,6 +44,117 @@ fn build_state_with_audit_metadata_threads_metadata_to_state() {assert_eq!(state.audit_metadata(), &metadata);}+#[test]+fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials() {+ let requirements = NetworkConstraints {+ domains: Some(domain_permissions([+ ("controller.example", NetworkDomainPermissionToml::Allow),+ ("blocked.example", NetworkDomainPermissionToml::Deny),+ ])),+ ..Default::default()+ };+ let profile = PermissionProfile::workspace_write();+ let spec = NetworkProxySpec::from_config_and_constraints(+ NetworkProxyConfig {+ enabled: true,+ allow_upstream_proxy: false,+ unix_sockets: Some(NetworkUnixSocketPermissions {+ entries: [+ (+ "/tmp/controller.sock".to_string(),+ NetworkUnixSocketPermission::Deny,+ ),+ (+ "/tmp/allowed.sock".to_string(),+ NetworkUnixSocketPermission::Allow,+ ),+ ]+ .into(),+ }),+ ..NetworkProxyConfig::default()+ },+ Some(requirements),+ &profile,+ )+ .expect("controller policy should be valid");+ let mut owner = NetworkProxyConfig::default();+ owner.set_allowed_domains(vec!["owner.example".to_string()]);+ owner.set_denied_domains(vec!["owner-blocked.example".to_string()]);+ owner.set_allow_unix_sockets(vec![+ "/tmp/controller.sock".to_string(),+ "/private/tmp/controller.sock".to_string(),+ "/tmp/allowed.sock".to_string(),+ ]);+ owner.dangerously_allow_all_unix_sockets = true;+ owner.allow_local_binding = true;+ let owner_policy =+ EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false);+ let compose = NetworkProxySpec::for_environment;+ let empty = Policy::empty();+ let disabled_controller = NetworkProxySpec::from_config_and_constraints(+ NetworkProxyConfig::default(),+ /*requirements*/ None,+ &profile,+ )+ .expect("disabled controller policy should be valid");+ assert!(compose(Some(&disabled_controller), &owner_policy, &profile, &empty).is_err());+ let restricted = compose(Some(&spec), &owner_policy, &profile, &empty)+ .expect("owner policy should replace soft controller grants");+ let mut saved = Policy::empty();+ for host in ["saved.example", "owner-blocked.example"] {+ saved+ .add_network_rule(host, Https, Allow, /*justification*/ None)+ .expect("saved network grant should be valid");+ }+ let rootless = compose(/*controller*/ None, &owner_policy, &profile, &saved)+ .expect("an owner policy can create executor-side proxy state");+ assert_eq!(+ rootless.config.allowed_domains().unwrap(),+ ["owner.example", "saved.example"]+ );++ owner.upsert_domain_permission(+ "blocked.example".to_string(),+ NetworkDomainPermission::Deny,+ normalize_host,+ );+ owner.unix_sockets.clone_from(&spec.config.unix_sockets);+ owner.allow_upstream_proxy = false;+ owner.dangerously_allow_all_unix_sockets = false;+ owner.allow_local_binding = false;+ assert_eq!(+ restricted.environment_policy(),+ EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false)+ );+ let external = PermissionProfile::External {+ network: NetworkSandboxPolicy::Enabled,+ };+ let external_rootless = compose(/*controller*/ None, &owner_policy, &external, &saved)+ .expect("an externally sandboxed owner policy should remain strict");+ assert_eq!(+ external_rootless.environment_policy(),+ EnvironmentNetworkPolicy {+ managed_allowed_domains_only: true,+ ..owner_policy.clone()+ }+ );+ let controller_policy = spec.environment_policy();+ let external_rooted = compose(Some(&spec), &controller_policy, &external, &saved)+ .expect("an externally sandboxed owner policy may retain its controller allowlist");+ assert_eq!(+ external_rooted.environment_policy(),+ EnvironmentNetworkPolicy {+ managed_allowed_domains_only: true,+ ..controller_policy+ }+ );+ assert!(compose(Some(&spec), &owner_policy, &external, &empty).is_err());+ owner.set_allowed_domains(vec!["*".to_string()]);+ let wildcard_policy =+ EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false);+ assert!(compose(Some(&spec), &wildcard_policy, &profile, &empty).is_err());+}+#[test]fn requirements_allowed_domains_are_a_baseline_for_user_allowlist() {let mut config = NetworkProxyConfig::default();diff --git a/codex-rs/core/src/session/environment.rs b/codex-rs/core/src/session/environment.rsindex 09b7803cc2..106be766fb 100644--- a/codex-rs/core/src/session/environment.rs+++ b/codex-rs/core/src/session/environment.rs@@ -1,7 +1,9 @@use std::collections::HashSet;+use codex_exec_server::LOCAL_ENVIRONMENT_ID;use codex_exec_server::MAX_SELECTED_CAPABILITY_ROOTS;use codex_exec_server::SelectedCapabilityRootsStatus;+use codex_execpolicy::Policy;use codex_protocol::capabilities::CapabilityRootLocation;use codex_protocol::error::CodexErr;use codex_protocol::error::Result as CodexResult;@@ -11,6 +13,7 @@ use codex_protocol::protocol::TurnEnvironmentSelection;use crate::config::ConstraintError;use crate::config::ConstraintResult;+use crate::config::NetworkProxySpec;use crate::session::session::Session;use crate::session::session::SessionConfiguration;use crate::session::session::SessionSettingsUpdate;@@ -35,12 +38,31 @@ fn validate_environment_config(selection: &TurnEnvironmentSelection,config: &EnvironmentConfig,) -> CodexResult<()> {- // The public type can be used by owners before runtime enforcement lands. Do not- // accept restrictions here until the managed proxy can actually enforce them.- if config.network_policy.is_some() {- return Err(CodexErr::InvalidRequest(- "attachment-owned network policy is not supported yet".to_string(),- ));+ if let Some(policy) = config.network_policy.as_ref() {+ if selection.environment_id == LOCAL_ENVIRONMENT_ID {+ return Err(CodexErr::InvalidRequest(+ "attachment-owned network policy requires a remote executor".to_string(),+ ));+ }+ if config+ .exec_policy+ .as_ref()+ .is_some_and(|policy| !policy.as_ref().network_rules().is_empty())+ {+ return Err(CodexErr::InvalidRequest(+ "environment network restrictions must use network_policy".to_string(),+ ));+ }+ // Validate owner policy on its own; controller compatibility is checked at execution.+ NetworkProxySpec::for_environment(+ /*controller*/ None,+ policy,+ config.permission_profile.permission_profile(),+ &Policy::empty(),+ )+ .map_err(|error| {+ CodexErr::InvalidRequest(format!("invalid environment network policy: {error}"))+ })?;}if config.selected_capability_roots.len() > MAX_SELECTED_CAPABILITY_ROOTS {return Err(CodexErr::InvalidRequest(format!(diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rsindex e776ae059e..f348ae6fb0 100644--- a/codex-rs/core/src/tools/network_approval.rs+++ b/codex-rs/core/src/tools/network_approval.rs@@ -1,7 +1,9 @@+use crate::config::NetworkProxySpec;use crate::guardian::GuardianNetworkAccessTrigger;use crate::guardian::GuardianReviewContext;use crate::network_policy_decision::denied_network_policy_message;use crate::session::session::Session;+use crate::session::turn_context::TurnContext;use crate::session::turn_context::TurnEnvironment;use crate::tools::approvals::ApprovalAction;use crate::tools::approvals::ApprovalContext;@@ -9,6 +11,7 @@ use crate::tools::events::truncate_rejection_message;use crate::tools::sandboxing::ToolError;use codex_network_proxy::BlockedRequest;use codex_network_proxy::BlockedRequestObserver;+use codex_network_proxy::EnvironmentNetworkPolicy;use codex_network_proxy::NetworkDecision;use codex_network_proxy::NetworkPolicyDecider;use codex_network_proxy::NetworkPolicyRequest;@@ -45,7 +48,7 @@ use uuid::Uuid;const ABANDONED_NETWORK_APPROVAL_MESSAGE: &str ="network approval was cancelled before a decision was returned";-#[derive(Clone, Debug)]+#[derive(Debug)]pub(crate) struct NetworkApprovalSpec {pub network: Option<NetworkProxy>,pub trigger: GuardianNetworkAccessTrigger,@@ -54,6 +57,7 @@ pub(crate) struct NetworkApprovalSpec {pub command: String,pub environment_id: String,pub permission_profile: PermissionProfile,+ pub network_policy: Option<EnvironmentNetworkPolicy>,}#[derive(Clone, Debug)]@@ -1021,8 +1025,8 @@ pub(crate) fn build_network_policy_decider(}pub(crate) async fn begin_network_approval(- session: &Session,- turn_id: &str,+ session: &Arc<Session>,+ turn: &TurnContext,managed_network_active: bool,spec: Option<NetworkApprovalSpec>,) -> Result<Option<ActiveNetworkApproval>, ToolError> {@@ -1033,21 +1037,93 @@ pub(crate) async fn begin_network_approval(command,environment_id,permission_profile,+ network_policy,} = match spec {Some(spec) => spec,None => return Ok(None),};- let Some(network) = network else {- return Ok(None);- };if !managed_network_active {return Ok(None);}+ let controller = turn.config.permissions.network.as_ref();+ let owner_spec = network_policy+ .as_ref()+ .map(|policy| {+ // Resolve owner policy once, where the command's actual enforcing proxy is built.+ NetworkProxySpec::for_environment(+ controller,+ policy,+ &permission_profile,+ session.services.exec_policy.current().as_ref(),+ )+ })+ .transpose()+ .map_err(|error| {+ ToolError::Rejected(format!(+ "failed to resolve environment network policy: {error}"+ ))+ })?;+ let network = if let Some(owner_spec) = owner_spec.as_ref() {+ if controller.is_some() {+ network+ .or_else(|| {+ session+ .services+ .network_proxy+ .load_full()+ .map(|controller| controller.proxy())+ })+ .ok_or_else(|| {+ ToolError::Rejected(+ "environment network policy requires its configured controller proxy"+ .to_string(),+ )+ })?+ } else {+ // This carrier never listens: the executor starts the real per-command proxy.+ let state = owner_spec+ .build_state_with_audit_metadata(+ session.services.network_proxy_audit_metadata.clone(),+ )+ .map_err(|error| {+ ToolError::Rejected(format!(+ "failed to build environment network policy: {error}"+ ))+ })?;+ NetworkProxy::builder()+ .state(Arc::new(state))+ .managed_by_codex(/*managed_by_codex*/ false)+ .build()+ .await+ .map_err(|error| {+ ToolError::Rejected(format!(+ "failed to build execution-scoped network proxy: {error}"+ ))+ })?+ }+ } else if let Some(network) = network {+ network+ } else {+ return Ok(None);+ };+ let environment_policy = owner_spec.map(|spec| spec.environment_policy());+ let fallback_policy_decider = environment_policy.as_ref().map(|_| {+ build_network_policy_decider(+ Arc::clone(&session.services.network_approval),+ Arc::new(RwLock::new(Arc::downgrade(session))),+ )+ });let registration_id = Uuid::new_v4().to_string();let attribution_token = Uuid::new_v4().to_string();let execution_proxy = network- .for_execution(&environment_id, ®istration_id, attribution_token)+ .for_execution(+ &environment_id,+ ®istration_id,+ attribution_token,+ environment_policy,+ fallback_policy_decider,+ ).map_err(|err| {ToolError::Codex(codex_protocol::error::CodexErr::Io(io::Error::other(format!("failed to create execution-scoped network proxy: {err}"),@@ -1059,7 +1135,7 @@ pub(crate) async fn begin_network_approval(.network_approval.register_call(ActiveNetworkApprovalCall {registration_id: registration_id.clone(),- turn_id: turn_id.to_string(),+ turn_id: turn.sub_id.clone(),trigger,tool_name,command,diff --git a/codex-rs/core/src/tools/orchestrator.rs b/codex-rs/core/src/tools/orchestrator.rsindex fe5272fe5d..709d5ba767 100644--- a/codex-rs/core/src/tools/orchestrator.rs+++ b/codex-rs/core/src/tools/orchestrator.rs@@ -6,12 +6,14 @@ simple sequence for any ToolRuntime: approval → select sandbox → attempt →retry with an escalated sandbox strategy on denial (no re‑approval thanks tocaching).*/+use crate::config::NetworkProxySpec;use crate::guardian::GuardianReviewContext;use crate::network_policy_decision::network_approval_context_from_payload;use crate::tools::approvals::ApprovalContext;use crate::tools::flat_tool_name;use crate::tools::network_approval::ActiveNetworkApproval;use crate::tools::network_approval::DeferredNetworkApproval;+use crate::tools::network_approval::NetworkApprovalSpec;use crate::tools::network_approval::begin_network_approval;use crate::tools::network_approval::finish_deferred_network_approval;use crate::tools::sandboxing::ExecApprovalRequirement;@@ -31,6 +33,7 @@ use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::ReviewDecision;use codex_sandboxing::SandboxManager;use codex_sandboxing::SandboxType;+use codex_sandboxing::policy_transforms::effective_network_sandbox_policy;use std::sync::Arc;use std::time::Instant;@@ -55,16 +58,16 @@ impl ToolOrchestrator {req: &Rq,tool_ctx: &ToolCtx,attempt: &SandboxAttempt<'_>,- managed_network_active: bool,+ network_approval_spec: Option<NetworkApprovalSpec>,) -> (Result<Out, ToolError>, Option<DeferredNetworkApproval>)whereT: ToolRuntime<Rq, Out>,{let network_approval = match begin_network_approval(&tool_ctx.session,- &tool_ctx.step_context.turn.sub_id,- managed_network_active,- tool.network_approval_spec(req, tool_ctx),+ &tool_ctx.step_context.turn,+ attempt.enforce_managed_network,+ network_approval_spec,).await{@@ -141,6 +144,17 @@ impl ToolOrchestrator {let mut already_approved = false;let environment = tool.turn_environment(req);+ let owner_network_policy = environment.config().network_policy.is_some();+ if owner_network_policy+ && tool+ .sandbox_permissions(req)+ .requires_escalated_permissions()+ {+ return Err(ToolError::Rejected(+ "attachment-owned network policy cannot be bypassed by sandbox escalation"+ .to_string(),+ ));+ }let workspace_roots = environment.workspace_roots();let executor_managed_process_sandbox = tool.uses_executor_managed_process_sandbox(req);let permission_profile = environment.permission_profile();@@ -212,12 +226,37 @@ impl ToolOrchestrator {}// 2) First attempt under the selected sandbox.- let sandbox_override = sandbox_override_for_first_attempt(- tool.sandbox_permissions(req),- &requirement,- &file_system_sandbox_policy,- );- let managed_network_active = turn_ctx.network.is_some();+ let unsandboxed_allowed =+ !owner_network_policy && unsandboxed_execution_allowed(&file_system_sandbox_policy);+ let sandbox_override = if unsandboxed_allowed {+ sandbox_override_for_first_attempt(+ tool.sandbox_permissions(req),+ &requirement,+ &file_system_sandbox_policy,+ )+ } else {+ SandboxOverride::NoOverride+ };+ let network_approval_spec = tool.network_approval_spec(req, tool_ctx);+ // Offline owner attachments stay offline unless approved command permissions grant+ // networking. Existing enabled controller proxies remain independently authoritative.+ let managed_network_active = if owner_network_policy {+ turn_ctx+ .config+ .permissions+ .network+ .as_ref()+ .is_some_and(NetworkProxySpec::enabled)+ || network_approval_spec.as_ref().is_some_and(|spec| {+ effective_network_sandbox_policy(+ permission_profile.network_sandbox_policy(),+ spec.trigger.additional_permissions.as_ref(),+ )+ .is_enabled()+ })+ } else {+ turn_ctx.network.is_some()+ };let sandbox_preference = tool.sandbox_preference();let sandbox_requested = match sandbox_override {SandboxOverride::BypassSandboxFirstAttempt => false,@@ -265,14 +304,8 @@ impl ToolOrchestrator {};let initial_attempt_start = Instant::now();- let (first_result, first_deferred_network_approval) = Self::run_attempt(- tool,- req,- tool_ctx,- &initial_attempt,- managed_network_active,- )- .await;+ let (first_result, first_deferred_network_approval) =+ Self::run_attempt(tool, req, tool_ctx, &initial_attempt, network_approval_spec).await;let initial_duration = initial_attempt_start.elapsed();match first_result {Ok(out) => {@@ -327,8 +360,6 @@ impl ToolOrchestrator {);return Err(ToolError::Codex(err));}- let unsandboxed_allowed =- unsandboxed_execution_allowed(&file_system_sandbox_policy);// Under `Never` or `OnRequest`, do not retry without sandbox;// surface a concise sandbox denial that preserves the// original output.@@ -449,9 +480,10 @@ impl ToolOrchestrator {};// Second attempt.+ let network_approval_spec = tool.network_approval_spec(req, tool_ctx);let escalated_attempt_start = Instant::now();let (retry_result, retry_deferred_network_approval) =- Self::run_attempt(tool, req, tool_ctx, &retry_attempt, managed_network_active)+ Self::run_attempt(tool, req, tool_ctx, &retry_attempt, network_approval_spec).await;let escalated_duration = escalated_attempt_start.elapsed();match retry_result {diff --git a/codex-rs/core/src/tools/runtimes/unified_exec.rs b/codex-rs/core/src/tools/runtimes/unified_exec.rsindex faed4864ef..84144f674d 100644--- a/codex-rs/core/src/tools/runtimes/unified_exec.rs+++ b/codex-rs/core/src/tools/runtimes/unified_exec.rs@@ -223,9 +223,14 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRunt&file_system_sandbox_policy,);let network =- managed_network_for_sandbox_permissions(req.network.as_ref(), sandbox_permissions)?;+ managed_network_for_sandbox_permissions(req.network.as_ref(), sandbox_permissions)+ .cloned();+ // No-proxy fast path; owners still need a spec for execution-only proxies.+ if network.is_none() && req.turn_environment.config().network_policy.is_none() {+ return None;+ }Some(NetworkApprovalSpec {- network: Some(network.clone()),+ network,tool_name: ctx.tool_name.clone(),trigger: GuardianNetworkAccessTrigger {call_id: ctx.call_id.clone(),@@ -240,6 +245,7 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRuntcommand: req.hook_command.clone(),environment_id: req.turn_environment.selection.environment_id.clone(),permission_profile: req.turn_environment.permission_profile().clone(),+ network_policy: req.turn_environment.config().network_policy.clone(),})}diff --git a/codex-rs/core/src/tools/sandboxing.rs b/codex-rs/core/src/tools/sandboxing.rsindex 6d5d89a6cc..481586b03a 100644--- a/codex-rs/core/src/tools/sandboxing.rs+++ b/codex-rs/core/src/tools/sandboxing.rs@@ -419,7 +419,12 @@ impl<'a> SandboxAttempt<'a> {&'b self,fallback: Option<&'b NetworkProxy>,) -> Option<&'b NetworkProxy> {- fallback.map(|fallback| self.network_proxy.unwrap_or(fallback))+ // Execution-only proxies need no fallback; offline attempts must not revive one.+ if self.enforce_managed_network {+ self.network_proxy.or(fallback)+ } else {+ None+ }}pub fn env_for(diff --git a/codex-rs/core/tests/suite/network_approval.rs b/codex-rs/core/tests/suite/network_approval.rsindex 5642216432..4de596b850 100644--- a/codex-rs/core/tests/suite/network_approval.rs+++ b/codex-rs/core/tests/suite/network_approval.rs@@ -1,8 +1,11 @@use anyhow::Context;use anyhow::Result;use codex_config::types::ApprovalsReviewer;+use codex_core::EnvironmentConfig;+use codex_core::EnvironmentNetworkPolicy;use codex_core::TurnInputRequest;use codex_core::config::Constrained;+use codex_core::config::NetworkProxySpec;use codex_core::shell::ShellType;use codex_core::shell::get_shell;use codex_exec_server::CreateDirectoryOptions;@@ -10,6 +13,7 @@ use codex_exec_server::LOCAL_ENVIRONMENT_ID;use codex_exec_server::REMOTE_ENVIRONMENT_ID;use codex_exec_server::RemoveOptions;use codex_features::Feature;+use codex_network_proxy::NetworkProxyConfig;use codex_protocol::approvals::NetworkApprovalContext;use codex_protocol::approvals::NetworkApprovalProtocol;use codex_protocol::approvals::NetworkPolicyAmendment;@@ -19,6 +23,7 @@ use codex_protocol::config_types::ModeKind;use codex_protocol::config_types::Settings;use codex_protocol::models::NetworkPermissions;use codex_protocol::models::PermissionProfile;+use codex_protocol::models::PermissionProfileSnapshot;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::EnvironmentConfigState;@@ -1936,6 +1941,198 @@ async fn remote_guardian_network_decisions_are_scoped_to_each_request_and_enviroOk(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn owner_network_policy_follows_the_selected_remote_command() -> Result<()> {+ skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");+ skip_if_host_windows!(Ok(()));+ skip_if_no_network!(Ok(()));+ skip_if_sandbox!(Ok(()));+ skip_if_no_remote_env!(Ok(()));++ let server = start_mock_server().await;+ let mut scenarios = vec![("ROOTED", managed_network_unified_exec_test(&server).await?)];+ for (scenario, configured_controller) in [("ROOTLESS", false), ("USER_ROOTED", true)] {+ let mut builder = test_codex().with_config(move |config| {+ for feature in [Feature::UnifiedExec, Feature::ExecPermissionApprovals] {+ config+ .features+ .enable(feature)+ .expect("test config should allow feature update");+ }+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config+ .permissions+ .set_permission_profile(PermissionProfile::workspace_write_with(+ &[],+ NetworkSandboxPolicy::Enabled,+ /*exclude_tmpdir_env_var*/ false,+ /*exclude_slash_tmp*/ false,+ ))+ .expect("set permission profile");+ config.permissions.network = configured_controller.then(|| {+ NetworkProxySpec::from_config_and_constraints(+ NetworkProxyConfig {+ enabled: true,+ allow_local_binding: true,+ ..NetworkProxyConfig::default()+ },+ /*requirements*/ None,+ config.permissions.permission_profile(),+ )+ .expect("build user-configured controller proxy")+ });+ });+ let test = builder.build_with_remote_and_local_env(&server).await?;+ assert!(!test.config.managed_network_requirements_enabled());+ assert_eq!(+ test.session_configured.network_proxy.is_some(),+ configured_controller+ );+ scenarios.push((scenario, test));+ }++ for (scenario, test) in scenarios {+ let mut remote = test.executor_environment().selection().clone();++ for (suffix, allowed_domain, expected) in [+ ("ALLOWED", NETWORK_TEST_HOST, "HTTP/1.1 502"),+ ("DENIED", "owner-only.invalid", "HTTP/1.1 403"),+ ("REVIEWED", "owner-only.invalid", "HTTP/1.1 502"),+ (+ "ESCALATED",+ NETWORK_TEST_HOST,+ "attachment-owned network policy cannot be bypassed",+ ),+ ("OFFLINE", "owner-only.invalid", "ROOTLESS_OWNER_OFFLINE"),+ ("GRANTED_DENIED", "owner-only.invalid", "HTTP/1.1 403"),+ ] {+ let restricted = matches!(suffix, "OFFLINE" | "GRANTED_DENIED");+ if scenario != "ROOTLESS" && (restricted || suffix == "ESCALATED") {+ continue;+ }+ let marker = format!("{scenario}_OWNER_{suffix}");+ let mut proxy_config = NetworkProxyConfig {+ allow_local_binding: true,+ ..NetworkProxyConfig::default()+ };+ proxy_config.set_allowed_domains(vec![allowed_domain.to_string()]);+ let owner_config = EnvironmentConfig {+ allow_login_shell: test.config.permissions.allow_login_shell,+ permission_profile: PermissionProfileSnapshot::legacy(if restricted {+ PermissionProfile::workspace_write()+ } else {+ test.config.permissions.permission_profile().clone()+ }),+ shell_environment_policy: test.config.permissions.shell_environment_policy.clone(),+ exec_policy: None,+ mcp_policy: None,+ network_policy: Some(EnvironmentNetworkPolicy::from_config(+ &proxy_config,+ /*managed_allowed_domains_only*/ suffix != "REVIEWED",+ )),+ selected_capability_roots: Vec::new(),+ };+ let mut primary = local(test.cwd.path().abs());+ primary.config = EnvironmentConfigState::Ready(EnvironmentConfig {+ permission_profile: PermissionProfileSnapshot::legacy(PermissionProfile::Disabled),+ network_policy: None,+ ..owner_config.clone()+ });+ remote.config = EnvironmentConfigState::Ready(owner_config);++ // Restricted owners run offline until an approved grant enables their filtered proxy.+ let command = if suffix == "OFFLINE" {+ format!(+ "python3 -c \"import socket; sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); sock.connect(('198.51.100.1', 9))\" 2>/dev/null || printf {marker}"+ )+ } else {+ remote_network_proxy_request_command(&marker)+ };+ let mut args = network_exec_args(&command);+ args["environment_id"] = json!(REMOTE_ENVIRONMENT_ID);+ if suffix == "ESCALATED" {+ args["sandbox_permissions"] = json!("require_escalated");+ args["justification"] = json!("attempt to bypass the owner network policy");+ } else if suffix == "GRANTED_DENIED" {+ args["sandbox_permissions"] = json!("with_additional_permissions");+ args["additional_permissions"] = json!({"network": {"enabled": true}});+ args["justification"] = json!("exercise attachment-scoped network access");+ }+ let guardian = if suffix == "REVIEWED" {+ Some(+ mount_sse_once_match(+ &server,+ is_guardian_request,+ sse(vec![+ ev_response_created("resp-owner-network-guardian"),+ ev_assistant_message(+ "msg-owner-network-guardian",+ r#"{"outcome":"allow"}"#,+ ),+ ev_completed("resp-owner-network-guardian"),+ ]),+ )+ .await,+ )+ } else {+ None+ };+ let responses = mount_exec_network_turn(&server, &marker, &marker, args).await?;+ submit_managed_network_turn(+ &test,+ "exercise the selected environment's network policy",+ vec![primary, remote.clone()],+ if suffix == "REVIEWED" {+ ApprovalsReviewer::AutoReview+ } else {+ ApprovalsReviewer::User+ },+ if matches!(suffix, "REVIEWED" | "ESCALATED" | "GRANTED_DENIED") {+ AskForApproval::OnRequest+ } else {+ AskForApproval::Never+ },+ )+ .await?;+ if suffix == "GRANTED_DENIED" {+ let event = wait_for_event(&test.codex, |event| {+ matches!(+ event,+ EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)+ )+ })+ .await;+ let EventMsg::ExecApprovalRequest(approval) = event else {+ anyhow::bail!("expected additional permissions approval before completion")+ };+ test.codex+ .submit(Op::ExecApproval {+ id: approval.effective_approval_id(),+ turn_id: Some(approval.turn_id),+ decision: ReviewDecision::Approved,+ })+ .await?;+ }+ wait_for_completion_without_network_prompt(&test).await;+ if let Some(guardian) = guardian {+ assert_eq!(+ guardian_network_triggers(&[&guardian])?,+ vec![(marker.clone(), command)]+ );+ }+ let output = responses+ .function_call_output_text(&marker)+ .context("expected remote network output")?;+ assert!(+ output.contains(expected),+ "unexpected network output for {marker}: {output}"+ );+ }+ }++ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn approved_network_host_for_one_environment_still_prompts_in_another() -> Result<()> {skip_if_target_windows!(Ok(()), "uses the POSIX/Python network fixture");diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex 1fad9556eb..6e0c3161e1 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -1425,7 +1425,7 @@ async fn shared_executor_keeps_ready_capability_roots_scoped_to_each_attachment(}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn owner_network_policy_is_rejected_until_runtime_enforcement_exists() -> Result<()> {+async fn owner_network_policy_rejects_unsupported_environment_authority() -> Result<()> {let server = start_mock_server().await;let test = test_codex().build_with_auto_env(&server).await?;let selections = test.codex.environment_selections().await;@@ -1434,9 +1434,7 @@ async fn owner_network_policy_is_rejected_until_runtime_enforcement_exists() ->.context("thread should select its executor environment")?;let owner_config = EnvironmentConfig {allow_login_shell: test.config.permissions.allow_login_shell,- permission_profile: PermissionProfileSnapshot::legacy(- test.config.permissions.permission_profile().clone(),- ),+ permission_profile: PermissionProfileSnapshot::legacy(PermissionProfile::Disabled),shell_environment_policy: test.config.permissions.shell_environment_policy.clone(),exec_policy: None,mcp_policy: None,@@ -1460,15 +1458,23 @@ async fn owner_network_policy_is_rejected_until_runtime_enforcement_exists() ->}).await.err()- .context("preview must not accept an unenforced policy")?;+ .context("preview must not accept an unsupported environment policy")?;let ready_error = test.codex.environment_ready(selection, owner_config).await- .expect_err("readiness must not accept an unenforced policy");+ .expect_err("readiness must not accept an unsupported environment policy");+ let expected = if selection.environment_id == LOCAL_ENVIRONMENT_ID {+ "attachment-owned network policy requires a remote executor"+ } else {+ "environment network policy requires managed network enforcement"+ };for error in [preview_error.to_string(), ready_error.to_string()] {- assert!(error.contains("attachment-owned network policy is not supported yet"));+ assert!(+ error.contains(expected),+ "unexpected validation error: {error}"+ );}assert_eq!(test.codex.environment_selections().await, selections);Ok(())diff --git a/codex-rs/network-proxy/src/environment_policy.rs b/codex-rs/network-proxy/src/environment_policy.rsindex 2cd5f264a3..365f7b2690 100644--- a/codex-rs/network-proxy/src/environment_policy.rs+++ b/codex-rs/network-proxy/src/environment_policy.rs@@ -1,13 +1,14 @@use crate::NetworkDomainPermissions;use crate::NetworkProxyConfig;+use crate::NetworkUnixSocketPermission;use crate::NetworkUnixSocketPermissions;use serde::Deserialize;use serde::Serialize;/// Traffic restrictions supplied by the owner of one execution environment.///-/// Proxy enablement, listeners, network mode, MITM, and credentials remain owned by the-/// controller's network-proxy runtime.+/// Proxy enablement, listeners, network mode, MITM, and credentials remain outside+/// attachment-owned traffic policy.#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]#[serde(rename_all = "camelCase")]pub struct EnvironmentNetworkPolicy {@@ -31,4 +32,53 @@ impl EnvironmentNetworkPolicy {managed_allowed_domains_only,}}++ /// Applies attachment-owned traffic settings while preserving inherited denials and proxy setup.+ pub fn apply_to(&self, config: &mut NetworkProxyConfig) {+ // Use the owner's domain rules without dropping controller denials.+ let inherited_denials = config.denied_domains().unwrap_or_default();+ config.domains.clone_from(&self.domains);+ for domain in inherited_denials {+ config.upsert_domain_permission(+ domain,+ crate::NetworkDomainPermission::Deny,+ crate::normalize_host,+ );+ }+ let inherited_sockets = config.unix_sockets.take().unwrap_or_default();+ let mut effective_sockets = self.unix_sockets.clone().unwrap_or_default();++ // "Allow all" cannot override a socket denied by either policy.+ let inherited_permits_all = config.dangerously_allow_all_unix_sockets+ && !inherited_sockets+ .entries+ .values()+ .any(|permission| matches!(permission, NetworkUnixSocketPermission::Deny));+ let owner_permits_all = self.dangerously_allow_all_unix_sockets+ && !effective_sockets+ .entries+ .values()+ .any(|permission| matches!(permission, NetworkUnixSocketPermission::Deny));++ // Keep shared socket grants; controller denials always take priority.+ effective_sockets.entries.retain(|path, permission| {+ matches!(permission, NetworkUnixSocketPermission::Deny)+ || inherited_permits_all+ || matches!(+ inherited_sockets.entries.get(path),+ Some(NetworkUnixSocketPermission::Allow)+ )+ });+ for (path, permission) in inherited_sockets.entries {+ if owner_permits_all || matches!(permission, NetworkUnixSocketPermission::Deny) {+ effective_sockets.entries.insert(path, permission);+ }+ }++ // Enable permissions only when both controller and owner allow them.+ config.unix_sockets = (!effective_sockets.entries.is_empty()).then_some(effective_sockets);+ config.dangerously_allow_all_unix_sockets = inherited_permits_all && owner_permits_all;+ config.allow_upstream_proxy &= self.allow_upstream_proxy;+ config.allow_local_binding &= self.allow_local_binding;+ }}diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rsindex 6577259405..c723686fed 100644--- a/codex-rs/network-proxy/src/proxy.rs+++ b/codex-rs/network-proxy/src/proxy.rs@@ -867,6 +867,7 @@ impl NetworkProxy {pub async fn remote_launch_config(&self) -> Result<crate::RemoteNetworkProxyLaunchConfig> {let (mut config, brokerage_created_default_allowlist) =self.state.current_cfg_with_brokerage_provenance().await?;+ // Proxy enablement and credential brokerage remain controller-owned.let mut broker_only_config = config::NetworkProxyConfig {enabled: config.enabled,credential_broker_openai_host: config.credential_broker_openai_host.clone(),@@ -877,6 +878,14 @@ impl NetworkProxy {broker_only_config.set_credential_broker_enabled(/*enabled*/ true);broker_only_config.set_allowed_domains(vec!["*".to_string()]);let broker_only = brokerage_created_default_allowlist && config == broker_only_config;++ let environment_policy = self+ .execution_scope+ .as_ref()+ .and_then(|scope| scope.environment_policy.as_ref());+ if let Some(policy) = environment_policy {+ policy.apply_to(&mut config);+ }if config.credential_broker {config.enabled &= !broker_only;config.credential_broker = false;@@ -885,6 +894,10 @@ impl NetworkProxy {config.mitm = false;}}+ anyhow::ensure!(+ environment_policy.is_none() || config.enabled,+ "environment network policy requires an enabled executor proxy"+ );let proxy = crate::RemoteNetworkProxyConfig::from_effective_config(&config)?;let (environment_id, execution_id) = self.execution_scope@@ -913,6 +926,7 @@ impl NetworkProxy {let state = Arc::clone(&self.state);let environment_id = scope.environment_id.clone();let execution_id = scope.execution_id.clone();+ let environment_policy_applies = scope.environment_policy.is_some();let execution_lifetime = scope.lifetime_tx.subscribe();Some(Arc::new(move |mut request: crate::NetworkPolicyRequest| {let decider = Arc::clone(&decider);@@ -928,8 +942,12 @@ impl NetworkProxy {}decision = async {match state.host_blocked(&request.host, request.port).await {- Ok(HostBlockDecision::Allowed) => NetworkDecision::Allow,- Ok(HostBlockDecision::Blocked(HostBlockReason::NotAllowed)) => {+ // Controller approval alone cannot bypass attachment policy.+ Ok(HostBlockDecision::Allowed) if !environment_policy_applies => {+ NetworkDecision::Allow+ }+ Ok(HostBlockDecision::Allowed)+ | Ok(HostBlockDecision::Blocked(HostBlockReason::NotAllowed)) => {decider.decide(request).await}Ok(HostBlockDecision::Blocked(reason)) => {@@ -1710,13 +1728,15 @@ mod tests {async fn remote_policy_decider_rechecks_live_policy_and_restores_attribution() -> Result<()> {let captured = Arc::new(Mutex::new(None));let captured_request = Arc::clone(&captured);- let config = NetworkProxyConfig {+ let mut config = NetworkProxyConfig {allow_local_binding: true,..NetworkProxyConfig::default()};- let proxy = NetworkProxy::builder()- .state(Arc::new(network_proxy_state_for_policy(config)))- .policy_decider(move |request: crate::NetworkPolicyRequest| {+ config.set_allowed_domains(vec!["controller.example".to_string()]);+ let mut owner_config = NetworkProxyConfig::default();+ owner_config.set_allowed_domains(vec!["owner.example".to_string()]);+ let fallback_policy_decider: Arc<dyn NetworkPolicyDecider> =+ Arc::new(move |request: crate::NetworkPolicyRequest| {let captured = Arc::clone(&captured_request);async move {*captured@@ -1725,15 +1745,26 @@ mod tests {Some((request.host, request.environment_id, request.execution_id));crate::NetworkDecision::Allow}- })+ });+ let proxy = NetworkProxy::builder()+ .state(Arc::new(network_proxy_state_for_policy(config))).managed_by_codex(/*managed_by_codex*/ false).build().await?;- let scoped = proxy.for_execution("remote", "execution-1", "token-1".to_string())?;+ let scoped = proxy.for_execution(+ "remote",+ "execution-1",+ "token-1".to_string(),+ Some(crate::EnvironmentNetworkPolicy::from_config(+ &owner_config,+ /*managed_allowed_domains_only*/ false,+ )),+ Some(Arc::clone(&fallback_policy_decider)),+ )?;let decider = scoped.remote_policy_decider().expect("execution-scoped proxy should expose its policy decider");- let mut request = https_request("allowed.example");+ let mut request = https_request("controller.example");request.environment_id = Some("forged-environment".to_string());request.execution_id = Some("forged-execution".to_string());@@ -1743,7 +1774,7 @@ mod tests {.lock().unwrap_or_else(std::sync::PoisonError::into_inner),Some((- "allowed.example".to_string(),+ "controller.example".to_string(),Some("remote".to_string()),Some("execution-1".to_string())))@@ -1762,11 +1793,28 @@ mod tests {.lock().unwrap_or_else(std::sync::PoisonError::into_inner),Some((- "allowed.example".to_string(),+ "controller.example".to_string(),Some("remote".to_string()),Some("execution-1".to_string()))));++ owner_config.set_denied_domains(vec!["denied.example".to_string()]);+ assert_eq!(+ scoped.remote_launch_config().await?.proxy.domains,+ owner_config.domains+ );+ let strict_scoped = proxy.for_execution(+ "owner-environment",+ "execution-3",+ "token-3".to_string(),+ Some(crate::EnvironmentNetworkPolicy::from_config(+ &owner_config,+ /*managed_allowed_domains_only*/ true,+ )),+ Some(fallback_policy_decider),+ )?;+ assert!(strict_scoped.remote_policy_decider().is_none());Ok(())}@@ -1790,7 +1838,13 @@ mod tests {.managed_by_codex(/*managed_by_codex*/ false).build().await?;- let scoped = proxy.for_execution("remote", "execution-1", "token-1".to_string())?;+ let scoped = proxy.for_execution(+ "remote",+ "execution-1",+ "token-1".to_string(),+ /*environment_policy*/ None,+ /*fallback_policy_decider*/ None,+ )?;let decider = scoped.remote_policy_decider().expect("execution-scoped proxy should expose its policy decider");@@ -2052,7 +2106,13 @@ mod tests {}};- let scoped = proxy.for_execution("remote-env", "execution-1", "token-1".to_string())?;+ let scoped = proxy.for_execution(+ "remote-env",+ "execution-1",+ "token-1".to_string(),+ /*environment_policy*/ None,+ /*fallback_policy_decider*/ None,+ )?;let launch = scoped.remote_launch_config().await?;let prepared = scoped.prepare_for_optional_environment(HashMap::from([(@@ -2065,6 +2125,20 @@ mod tests {assert_eq!(launch.environment_id.as_deref(), Some("remote-env"));assert_eq!(launch.execution_id.as_deref(), Some("execution-1"));assert!(!launch.proxy.enabled);++ let mut owner_config = NetworkProxyConfig::default();+ owner_config.set_allowed_domains(vec!["owner.example".to_string()]);+ let owner_scoped = proxy.for_execution(+ "remote-env",+ "execution-2",+ "token-2".to_string(),+ Some(crate::EnvironmentNetworkPolicy::from_config(+ &owner_config,+ /*managed_allowed_domains_only*/ false,+ )),+ /*fallback_policy_decider*/ None,+ )?;+ assert!(owner_scoped.remote_launch_config().await.is_err());for (enabled, mode, allowed_domain, proxy_url) in [(false, config::NetworkMode::Full, Some("*"), None),(false, config::NetworkMode::Full, Some("example.com"), None),diff --git a/codex-rs/network-proxy/src/proxy/execution_scope.rs b/codex-rs/network-proxy/src/proxy/execution_scope.rsindex ac5fecbaee..e01e115e78 100644--- a/codex-rs/network-proxy/src/proxy/execution_scope.rs+++ b/codex-rs/network-proxy/src/proxy/execution_scope.rs@@ -4,6 +4,7 @@ pub(super) struct ExecutionScope {pub(super) environment_id: String,pub(super) execution_id: String,pub(super) attribution_token: String,+ pub(super) environment_policy: Option<crate::EnvironmentNetworkPolicy>,// Dropping the execution scope closes this channel and cancels remote reviews.pub(super) lifetime_tx: tokio::sync::watch::Sender<()>,state: Arc<NetworkProxyState>,@@ -16,12 +17,14 @@ impl Drop for ExecutionScope {}impl NetworkProxy {- /// Returns a proxy that attributes trusted bridge connections to one execution.+ /// Returns a proxy with execution-specific attribution and attachment policy.pub fn for_execution(&self,environment_id: &str,execution_id: &str,attribution_token: String,+ environment_policy: Option<crate::EnvironmentNetworkPolicy>,+ fallback_policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,) -> Result<Self> {anyhow::ensure!(self.execution_scope.is_none(),@@ -32,10 +35,16 @@ impl NetworkProxy {let (lifetime_tx, _) = tokio::sync::watch::channel(());let mut proxy = self.clone();+ proxy.policy_decider = proxy.policy_decider.or(fallback_policy_decider);+ // Strict attachment allowlists cannot be expanded through approval callbacks.+ if matches!(&environment_policy, Some(policy) if policy.managed_allowed_domains_only) {+ proxy.policy_decider = None;+ }proxy.execution_scope = Some(Arc::new(ExecutionScope {environment_id: environment_id.to_string(),execution_id: execution_id.to_string(),attribution_token,+ environment_policy,lifetime_tx,state: Arc::clone(&self.state),}));diff --git a/codex-rs/protocol/src/environment.rs b/codex-rs/protocol/src/environment.rsindex c61dd94b1c..21e7275ee3 100644--- a/codex-rs/protocol/src/environment.rs+++ b/codex-rs/protocol/src/environment.rs@@ -33,7 +33,6 @@ pub struct EnvironmentConfig {/// Additional managed MCP restrictions for this environment attachment.pub mcp_policy: Option<EnvironmentMcpPolicy>,/// Owner-provided traffic restrictions. `None` keeps the existing controller policy.- /// Core rejects `Some` until attachment-owned network enforcement is implemented.pub network_policy: Option<EnvironmentNetworkPolicy>,/// Capability roots selected for this thread's environment attachment.pub selected_capability_roots: Vec<SelectedCapabilityRoot>,