diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index aced91515d..bb6d5e4066 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -4132,6 +4132,7 @@ dependencies = [ "clap", "codex-utils-absolute-path", "codex-utils-home-dir", + "codex-utils-path-uri", "codex-utils-rustls-provider", "codex-windows-sandbox", "globset", diff --git a/codex-rs/config/src/config_toml.rs b/codex-rs/config/src/config_toml.rs index d5572f3ccd..d0808fd9bd 100644 --- a/codex-rs/config/src/config_toml.rs +++ b/codex-rs/config/src/config_toml.rs @@ -56,6 +56,7 @@ use codex_protocol::permissions::NetworkSandboxPolicy; use codex_protocol::protocol::AskForApproval; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_path::normalize_for_path_comparison; +use codex_utils_path_uri::Platform; use schemars::JsonSchema; use serde::Deserialize; use serde::Deserializer; @@ -749,8 +750,28 @@ pub struct GhostSnapshotToml { pub disable_warnings: Option, } +/// Apply the executor's sandbox availability to an already selected sandbox mode. +/// +/// Call this before resolving workspace-write settings so unused writable roots +/// do not affect the read-only fallback. Named permission profiles are resolved +/// separately and must not be downgraded through this helper. +pub fn effective_sandbox_mode( + mode: SandboxMode, + platform: Platform, + windows_sandbox_level: WindowsSandboxLevel, +) -> SandboxMode { + if platform == Platform::Windows + && windows_sandbox_level == WindowsSandboxLevel::Disabled + && mode == SandboxMode::WorkspaceWrite + { + SandboxMode::ReadOnly + } else { + mode + } +} + impl ConfigToml { - /// Derive the effective permission profile from legacy sandbox config. + /// Derive the effective permission profile from sandbox config. /// /// Call this only after ruling out `default_permissions`: named /// `[permissions]` profiles must be compiled through the permissions @@ -766,30 +787,17 @@ impl ConfigToml { let resolved_sandbox_mode = configured_sandbox_mode .or_else(|| { // If no sandbox_mode is set but this directory has a trust decision, - // default to workspace-write except on unsandboxed Windows where we - // default to read-only. + // default to workspace-write before applying the platform fallback. active_project .filter(|project| project.is_trusted() || project.is_untrusted()) - .map(|_| { - if cfg!(target_os = "windows") - && windows_sandbox_level == WindowsSandboxLevel::Disabled - { - SandboxMode::ReadOnly - } else { - SandboxMode::WorkspaceWrite - } - }) + .map(|_| SandboxMode::WorkspaceWrite) }) .unwrap_or_default(); - let effective_sandbox_mode = if cfg!(target_os = "windows") - // If the experimental Windows sandbox is enabled, do not force a downgrade. - && windows_sandbox_level == WindowsSandboxLevel::Disabled - && matches!(resolved_sandbox_mode, SandboxMode::WorkspaceWrite) - { - SandboxMode::ReadOnly - } else { - resolved_sandbox_mode - }; + let effective_sandbox_mode = effective_sandbox_mode( + resolved_sandbox_mode, + Platform::native(), + windows_sandbox_level, + ); let permission_profile = match effective_sandbox_mode { SandboxMode::ReadOnly => PermissionProfile::read_only(), @@ -1000,6 +1008,37 @@ mod tests { const WORKSPACE_ID_A: &str = "123e4567-e89b-42d3-a456-426614174000"; const WORKSPACE_ID_B: &str = "123e4567-e89b-42d3-a456-426614174001"; + #[test] + fn sandbox_mode_uses_executor_platform_and_sandbox_level() { + use Platform::Linux; + use Platform::Macos; + use Platform::Unknown; + use Platform::Windows; + use SandboxMode::DangerFullAccess; + use SandboxMode::ReadOnly; + use SandboxMode::WorkspaceWrite; + use WindowsSandboxLevel::Disabled; + use WindowsSandboxLevel::Elevated; + use WindowsSandboxLevel::RestrictedToken; + + for (mode, platform, level, expected) in [ + (WorkspaceWrite, Windows, Disabled, ReadOnly), + (WorkspaceWrite, Windows, RestrictedToken, WorkspaceWrite), + (WorkspaceWrite, Windows, Elevated, WorkspaceWrite), + (WorkspaceWrite, Linux, Disabled, WorkspaceWrite), + (WorkspaceWrite, Macos, Disabled, WorkspaceWrite), + (WorkspaceWrite, Unknown, Disabled, WorkspaceWrite), + (ReadOnly, Windows, Disabled, ReadOnly), + (DangerFullAccess, Windows, Disabled, DangerFullAccess), + ] { + assert_eq!( + effective_sandbox_mode(mode, platform, level), + expected, + "{mode:?}, {platform:?}, {level:?}" + ); + } + } + #[test] fn thread_unload_delay_requires_nonnegative_seconds() { for value in ["-1", "1.5", "\"60\""] { diff --git a/codex-rs/config/src/lib.rs b/codex-rs/config/src/lib.rs index 273a136c35..1b2c220f0a 100644 --- a/codex-rs/config/src/lib.rs +++ b/codex-rs/config/src/lib.rs @@ -128,6 +128,7 @@ pub use config_requirements::WebSearchModeRequirement; pub use config_requirements::WindowsRequirementsToml; pub use config_requirements::WindowsSandboxImplementationToml; pub use config_requirements::sandbox_mode_requirement_for_permission_profile; +pub use config_toml::effective_sandbox_mode; pub use constraint::Constrained; pub use constraint::ConstraintError; pub use constraint::ConstraintResult; diff --git a/codex-rs/core/src/config/network_config.rs b/codex-rs/core/src/config/network_config.rs index fbc5989347..653717e5d3 100644 --- a/codex-rs/core/src/config/network_config.rs +++ b/codex-rs/core/src/config/network_config.rs @@ -15,8 +15,8 @@ use codex_features::FeatureToml; use codex_features::FeaturesToml; use codex_network_proxy::EnvironmentNetworkPolicy; use codex_network_proxy::NetworkProxyConfig; -use codex_network_proxy::NetworkProxyExecutorOs; use codex_protocol::models::PermissionProfile; +use codex_utils_path_uri::Platform; use super::NetworkProxySpec; use super::permissions::apply_network_proxy_feature_config; @@ -60,7 +60,7 @@ pub fn project_environment_profile_network( pub fn validate_environment_network_policy( policy: &EnvironmentNetworkPolicy, permission_profile: &PermissionProfile, - executor_os: NetworkProxyExecutorOs, + executor_os: Platform, ) -> Result<(), EnvironmentNetworkConfigError> { NetworkProxySpec::for_environment( /*controller*/ None, diff --git a/codex-rs/core/src/config/network_config_tests.rs b/codex-rs/core/src/config/network_config_tests.rs index 6b3616fac2..bef4bb5872 100644 --- a/codex-rs/core/src/config/network_config_tests.rs +++ b/codex-rs/core/src/config/network_config_tests.rs @@ -42,10 +42,10 @@ fn environment_policy_presence_keeps_selected_and_managed_denials() { #[test] fn attachment_projection_preserves_policy_and_drops_listener_addresses() { for executor_os in [ - NetworkProxyExecutorOs::Linux, - NetworkProxyExecutorOs::Macos, - NetworkProxyExecutorOs::Windows, - NetworkProxyExecutorOs::Unknown, + Platform::Linux, + Platform::Macos, + Platform::Windows, + Platform::Unknown, ] { for (raw, windows_only) in [ ("", false), @@ -76,11 +76,8 @@ allow_local_binding = false ), ] { let expected: NetworkToml = toml::from_str(raw).unwrap(); - let accepted = !windows_only - || matches!( - executor_os, - NetworkProxyExecutorOs::Windows | NetworkProxyExecutorOs::Unknown - ); + let accepted = + !windows_only || matches!(executor_os, Platform::Windows | Platform::Unknown); assert_eq!( build_config_state( expected.to_network_proxy_config(), @@ -165,7 +162,7 @@ action = ['redact'] validate_environment_network_policy( &policy, &PermissionProfile::read_only(), - NetworkProxyExecutorOs::Unknown, + Platform::Unknown, ), Err(EnvironmentNetworkConfigError), "{raw}" @@ -202,7 +199,7 @@ action = ['redact'] validate_environment_network_policy( &policy, &PermissionProfile::read_only(), - NetworkProxyExecutorOs::Unknown, + Platform::Unknown, ), Ok(()), "{raw}" diff --git a/codex-rs/core/src/config/network_proxy_spec.rs b/codex-rs/core/src/config/network_proxy_spec.rs index 8b84b1f9cf..d324226d4d 100644 --- a/codex-rs/core/src/config/network_proxy_spec.rs +++ b/codex-rs/core/src/config/network_proxy_spec.rs @@ -12,7 +12,6 @@ use codex_network_proxy::NetworkProxy; use codex_network_proxy::NetworkProxyAuditMetadata; use codex_network_proxy::NetworkProxyConfig; use codex_network_proxy::NetworkProxyConstraints; -use codex_network_proxy::NetworkProxyExecutorOs; use codex_network_proxy::NetworkProxyHandle; use codex_network_proxy::NetworkProxyState; use codex_network_proxy::build_config_state; @@ -22,6 +21,7 @@ use codex_network_proxy::managed_proxy_ports; use codex_network_proxy::normalize_host; use codex_network_proxy::validate_policy_against_constraints; use codex_protocol::models::PermissionProfile; +use codex_utils_path_uri::Platform; use std::collections::HashSet; use std::sync::Arc; @@ -197,10 +197,7 @@ impl NetworkProxySpec { enable_network_approval_flow: bool, audit_metadata: NetworkProxyAuditMetadata, ) -> std::io::Result { - let state = self.build_state_with_audit_metadata( - audit_metadata, - NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), - )?; + let state = self.build_state_with_audit_metadata(audit_metadata, Platform::native())?; let mut builder = NetworkProxy::builder() .state(Arc::new(state)) .managed_proxy_routing(managed_proxy_routing); @@ -341,9 +338,8 @@ impl NetworkProxySpec { &self, started_proxy: &StartedNetworkProxy, ) -> std::io::Result<()> { - let state = self.build_config_state_for_spec(NetworkProxyExecutorOs::from_platform_os( - Some(std::env::consts::OS), - ))?; + let state = self + .build_config_state_for_spec(Platform::from_platform_os(Some(std::env::consts::OS)))?; started_proxy .proxy() .replace_config_state(state) @@ -356,7 +352,7 @@ impl NetworkProxySpec { pub(crate) fn build_state_with_audit_metadata( &self, audit_metadata: NetworkProxyAuditMetadata, - executor_os: NetworkProxyExecutorOs, + executor_os: Platform, ) -> std::io::Result { let state = self.build_config_state_for_spec(executor_os)?; let reloader = Arc::new(StaticNetworkProxyReloader::new(state.clone())); @@ -369,7 +365,7 @@ impl NetworkProxySpec { pub(super) fn build_config_state_for_spec( &self, - executor_os: NetworkProxyExecutorOs, + executor_os: Platform, ) -> std::io::Result { build_config_state(self.config.clone(), self.constraints.clone(), executor_os).map_err( |err| std::io::Error::other(format!("failed to build network proxy state: {err}")), diff --git a/codex-rs/core/src/config/network_proxy_spec_tests.rs b/codex-rs/core/src/config/network_proxy_spec_tests.rs index 158711f8ea..996c86743d 100644 --- a/codex-rs/core/src/config/network_proxy_spec_tests.rs +++ b/codex-rs/core/src/config/network_proxy_spec_tests.rs @@ -84,11 +84,9 @@ async fn attachment_socket_grants_respect_configured_restrictions_at_remote_laun Some(expected), "{name}" ); - let state = - Arc::new(controller.build_state_with_audit_metadata( - Default::default(), - NetworkProxyExecutorOs::Linux, - )?); + let state = Arc::new( + controller.build_state_with_audit_metadata(Default::default(), Platform::Linux)?, + ); let proxy = NetworkProxy::builder() .state(Arc::clone(&state)) .managed_by_codex(false) @@ -142,9 +140,7 @@ async fn attachment_socket_grants_respect_configured_restrictions_at_remote_laun &profile, )?; proxy - .replace_config_state( - restricted.build_config_state_for_spec(NetworkProxyExecutorOs::Linux)?, - ) + .replace_config_state(restricted.build_config_state_for_spec(Platform::Linux)?) .await?; assert!( !scoped @@ -175,7 +171,7 @@ fn build_state_with_audit_metadata_threads_metadata_to_state() { }; let state = spec - .build_state_with_audit_metadata(metadata.clone(), NetworkProxyExecutorOs::Linux) + .build_state_with_audit_metadata(metadata.clone(), Platform::Linux) .expect("state should build"); assert_eq!(state.audit_metadata(), &metadata); } @@ -258,14 +254,14 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials() let owner_policy = EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false); assert_eq!( - validate_environment_network_policy(&owner_policy, &profile, NetworkProxyExecutorOs::Linux), + validate_environment_network_policy(&owner_policy, &profile, Platform::Linux), Ok(()) ); assert_eq!( validate_environment_network_policy( &owner_policy, &PermissionProfile::Disabled, - NetworkProxyExecutorOs::Linux + Platform::Linux ), Err(EnvironmentNetworkConfigError) ); @@ -334,22 +330,14 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials() EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false); assert!(compose(Some(&spec), &wildcard_policy, &profile, &empty).is_err()); assert_eq!( - validate_environment_network_policy( - &wildcard_policy, - &profile, - NetworkProxyExecutorOs::Linux - ), + validate_environment_network_policy(&wildcard_policy, &profile, Platform::Linux), Err(EnvironmentNetworkConfigError) ); owner.set_allowed_domains(vec!["[".to_string()]); let malformed_policy = EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false); assert_eq!( - validate_environment_network_policy( - &malformed_policy, - &profile, - NetworkProxyExecutorOs::Linux - ), + validate_environment_network_policy(&malformed_policy, &profile, Platform::Linux), Err(EnvironmentNetworkConfigError) ); } diff --git a/codex-rs/core/src/shell_snapshot_tests.rs b/codex-rs/core/src/shell_snapshot_tests.rs index 0b519a545f..8c5681e022 100644 --- a/codex-rs/core/src/shell_snapshot_tests.rs +++ b/codex-rs/core/src/shell_snapshot_tests.rs @@ -521,9 +521,7 @@ async fn inactive_profiles_keep_snapshots_but_active_brokers_require_sandbox() - .replace_config_state(codex_network_proxy::build_config_state( config, codex_network_proxy::NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some( - std::env::consts::OS, - )), + codex_utils_path_uri::Platform::native(), )?) .await?; assert_eq!( @@ -572,9 +570,7 @@ async fn inactive_profiles_keep_snapshots_but_active_brokers_require_sandbox() - .replace_config_state(codex_network_proxy::build_config_state( config, codex_network_proxy::NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some( - std::env::consts::OS, - )), + codex_utils_path_uri::Platform::native(), )?) .await?; fs::write(dir.path().join("finish-startup"), "").await?; diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rs index 5cc87a77d1..3b03c31831 100644 --- a/codex-rs/core/src/tools/network_approval.rs +++ b/codex-rs/core/src/tools/network_approval.rs @@ -18,7 +18,6 @@ use codex_network_proxy::NetworkPolicyDecider; use codex_network_proxy::NetworkPolicyRequest; use codex_network_proxy::NetworkProtocol; use codex_network_proxy::NetworkProxy; -use codex_network_proxy::NetworkProxyExecutorOs; use codex_network_proxy::NetworkRequestCancellation; use codex_network_proxy::NetworkRequestCancellationReason; use codex_network_proxy::NetworkRequestDisconnect; @@ -33,6 +32,7 @@ use codex_protocol::protocol::ReviewDecision; use codex_protocol::protocol::WarningEvent; use codex_sandboxing::record_network_sandbox_violation; use codex_tools::ToolName; +use codex_utils_path_uri::Platform; use indexmap::IndexMap; use std::collections::HashMap; use std::collections::HashSet; @@ -1152,7 +1152,7 @@ pub(crate) async fn begin_network_approval( })? } else { // This carrier never listens: the executor starts the real per-command proxy. - let executor_os = NetworkProxyExecutorOs::from_platform_os( + let executor_os = Platform::from_platform_os( environments .turn_environments() .find(|environment| environment.selection.environment_id == environment_id) diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rs index 46bfff2f00..7f7c2eaf61 100644 --- a/codex-rs/core/src/tools/runtimes/mod_tests.rs +++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs @@ -79,7 +79,7 @@ async fn test_network_proxy_with_config( let state = codex_network_proxy::build_config_state( config, NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + codex_utils_path_uri::Platform::native(), )?; NetworkProxy::builder() .state(Arc::new(NetworkProxyState::with_reloader( diff --git a/codex-rs/exec-server/src/local_process.rs b/codex-rs/exec-server/src/local_process.rs index 82689ea3cc..9c4bc06996 100644 --- a/codex-rs/exec-server/src/local_process.rs +++ b/codex-rs/exec-server/src/local_process.rs @@ -1819,9 +1819,7 @@ mod tests { .expect("build remote network proxy config"); let state = NetworkProxyState::from_remote_launch_config( RemoteNetworkProxyLaunchConfig::new(proxy_config), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some( - std::env::consts::OS, - )), + codex_utils_path_uri::Platform::native(), ) .expect("build network proxy state"); let proxy = NetworkProxy::builder() diff --git a/codex-rs/exec-server/src/process_sandbox.rs b/codex-rs/exec-server/src/process_sandbox.rs index 268fc6e2ca..67a7210a85 100644 --- a/codex-rs/exec-server/src/process_sandbox.rs +++ b/codex-rs/exec-server/src/process_sandbox.rs @@ -350,7 +350,7 @@ async fn prepare_managed_network( }; let mut state = NetworkProxyState::from_remote_launch_config( network_proxy, - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + codex_utils_path_uri::Platform::native(), ) .map_err(|err| invalid_params(format!("invalid network proxy config: {err}")))?; if let Some(observer) = network_policy_audit_observer { diff --git a/codex-rs/linux-sandbox/tests/suite/managed_proxy_unix_sockets_tests.rs b/codex-rs/linux-sandbox/tests/suite/managed_proxy_unix_sockets_tests.rs index 479bb9ef71..312bfa5e9c 100644 --- a/codex-rs/linux-sandbox/tests/suite/managed_proxy_unix_sockets_tests.rs +++ b/codex-rs/linux-sandbox/tests/suite/managed_proxy_unix_sockets_tests.rs @@ -143,9 +143,7 @@ for family in (socket.AF_NETLINK, getattr(socket, 'AF_VSOCK', 40)): let state = build_config_state( config, NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some( - std::env::consts::OS, - )), + codex_network_proxy::Platform::native(), ) .expect("valid managed network configuration"); let network = NetworkProxy::builder() diff --git a/codex-rs/network-proxy/Cargo.toml b/codex-rs/network-proxy/Cargo.toml index d5280e4eef..6e81390231 100644 --- a/codex-rs/network-proxy/Cargo.toml +++ b/codex-rs/network-proxy/Cargo.toml @@ -19,6 +19,7 @@ clap = { workspace = true, features = ["derive"] } chrono = { workspace = true } codex-utils-absolute-path = { workspace = true } codex-utils-home-dir = { workspace = true } +codex-utils-path-uri = { workspace = true } codex-utils-rustls-provider = { workspace = true } globset = { workspace = true } opentelemetry = { workspace = true } diff --git a/codex-rs/network-proxy/src/brokered_tunnel_tests.rs b/codex-rs/network-proxy/src/brokered_tunnel_tests.rs index c65a0335e5..b416e59ed2 100644 --- a/codex-rs/network-proxy/src/brokered_tunnel_tests.rs +++ b/codex-rs/network-proxy/src/brokered_tunnel_tests.rs @@ -175,7 +175,7 @@ impl TestProxy { let config_state = build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .unwrap(); let state = Arc::new(NetworkProxyState::with_reloader( diff --git a/codex-rs/network-proxy/src/config.rs b/codex-rs/network-proxy/src/config.rs index 8bdd53ecf5..5e479cd0d0 100644 --- a/codex-rs/network-proxy/src/config.rs +++ b/codex-rs/network-proxy/src/config.rs @@ -14,7 +14,7 @@ use std::path::Path; use tracing::warn; use url::Url; -use crate::NetworkProxyExecutorOs; +use crate::Platform; use crate::mitm_hook::MitmHookConfig; use crate::policy::normalize_host; @@ -497,21 +497,19 @@ impl ValidatedUnixSocketPath { pub(crate) fn validate_unix_socket_allowlist_paths( cfg: &NetworkProxyConfig, - executor_os: NetworkProxyExecutorOs, + executor_os: Platform, ) -> Result<()> { for (index, socket_path) in cfg.allow_unix_sockets().iter().enumerate() { anyhow::ensure!( - executor_os.socket_path_is_absolute(socket_path) && !socket_path.contains('\0'), + crate::socket_path::socket_path_is_absolute(executor_os, socket_path) + && !socket_path.contains('\0'), "invalid network.allow_unix_sockets[{index}]: expected a NUL-free absolute path for {executor_os:?}, got {socket_path:?}" ); } Ok(()) } -pub fn resolve_runtime( - cfg: &NetworkProxyConfig, - executor_os: NetworkProxyExecutorOs, -) -> Result { +pub fn resolve_runtime(cfg: &NetworkProxyConfig, executor_os: Platform) -> Result { validate_unix_socket_allowlist_paths(cfg, executor_os)?; let http_addr = resolve_addr(&cfg.proxy_url, /*default_port*/ 3128) @@ -528,10 +526,7 @@ pub fn resolve_runtime( /// Returns the sorted loopback ports used by the configured managed proxy listeners. pub fn managed_proxy_ports(cfg: &NetworkProxyConfig) -> Result> { - let runtime = resolve_runtime( - cfg, - NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), - )?; + let runtime = resolve_runtime(cfg, Platform::native())?; if runtime.http_addr.port() == 0 { bail!("network.proxy_url must use a fixed non-zero port for managed proxy provisioning"); } @@ -1117,13 +1112,10 @@ mod tests { ] { let cfg = settings_with_unix_sockets(&[path]); for (executor_os, accepted) in [ - (NetworkProxyExecutorOs::Linux, unix_absolute), - (NetworkProxyExecutorOs::Macos, unix_absolute), - (NetworkProxyExecutorOs::Windows, windows_absolute), - ( - NetworkProxyExecutorOs::Unknown, - unix_absolute || windows_absolute, - ), + (Platform::Linux, unix_absolute), + (Platform::Macos, unix_absolute), + (Platform::Windows, windows_absolute), + (Platform::Unknown, unix_absolute || windows_absolute), ] { assert_eq!( resolve_runtime(&cfg, executor_os).is_ok(), @@ -1134,11 +1126,7 @@ mod tests { // Each platform's CI compares the portable implementation to native // Core acceptance, with the deliberate shared NUL rejection. assert_eq!( - resolve_runtime( - &cfg, - NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)) - ) - .is_ok(), + resolve_runtime(&cfg, Platform::native()).is_ok(), (Path::new(path).is_absolute() || path.starts_with('/')) && !path.contains('\0'), "native parity: {path:?}" ); @@ -1161,10 +1149,10 @@ mod tests { } for executor_os in [ - NetworkProxyExecutorOs::Linux, - NetworkProxyExecutorOs::Macos, - NetworkProxyExecutorOs::Windows, - NetworkProxyExecutorOs::Unknown, + Platform::Linux, + Platform::Macos, + Platform::Windows, + Platform::Unknown, ] { assert!( resolve_runtime(&cfg, executor_os).is_ok(), diff --git a/codex-rs/network-proxy/src/executor_os.rs b/codex-rs/network-proxy/src/executor_os.rs deleted file mode 100644 index 14ab49a3ef..0000000000 --- a/codex-rs/network-proxy/src/executor_os.rs +++ /dev/null @@ -1,54 +0,0 @@ -//! Executor path semantics for policy validation, independent of the controller OS. -//! Socket support and native path normalization remain executor runtime concerns. - -/// OS of the executor whose network policy is being validated. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum NetworkProxyExecutorOs { - Linux, - Macos, - Windows, - /// Legacy executors may omit their OS. Accept absolute syntax supported by - /// either platform here; the executor validates against its own OS at launch. - Unknown, -} - -impl NetworkProxyExecutorOs { - /// Uses executor metadata, never the OS of the process doing the validation. - pub fn from_platform_os(platform_os: Option<&str>) -> Self { - match platform_os { - Some("linux") => Self::Linux, - Some("macos") => Self::Macos, - Some("windows") => Self::Windows, - Some(_) | None => Self::Unknown, - } - } - - pub(crate) fn socket_path_is_absolute(self, path: &str) -> bool { - // Core also accepts Unix-style absolute paths on Windows, for portability. - path.starts_with('/') - || match self { - Self::Linux | Self::Macos => false, - Self::Windows | Self::Unknown => windows_path_is_absolute(path), - } - } -} - -// Match std::path's Windows absolute-path syntax without consulting the host. -// Non-drive prefixes have an implicit root, including device and verbatim paths. -fn windows_path_is_absolute(path: &str) -> bool { - let bytes = path.as_bytes(); - if matches!(bytes, [drive, b':', b'\\' | b'/', ..] if drive.is_ascii_alphabetic()) { - return true; - } - let [b'\\' | b'/', b'\\' | b'/', rest @ ..] = bytes else { - return false; - }; - if path.starts_with(r"\\?\") || matches!(rest, [b'.', b'\\' | b'/', ..]) { - return true; - } - let mut components = rest.split(|byte| matches!(byte, b'\\' | b'/')); - matches!( - (components.next(), components.next()), - (Some(server), Some(share)) if !server.is_empty() && !share.is_empty() - ) -} diff --git a/codex-rs/network-proxy/src/lib.rs b/codex-rs/network-proxy/src/lib.rs index 2e37047062..3e7a9d6c4d 100644 --- a/codex-rs/network-proxy/src/lib.rs +++ b/codex-rs/network-proxy/src/lib.rs @@ -9,7 +9,6 @@ mod connect_policy; mod connection_lifecycle; mod credential_broker; mod environment_policy; -mod executor_os; mod http_proxy; mod mitm; mod mitm_hook; @@ -24,6 +23,7 @@ mod request_cancellation; mod request_disconnect; mod responses; mod runtime; +mod socket_path; mod socks5; mod state; #[cfg(target_os = "macos")] @@ -38,6 +38,7 @@ pub use attribution::PROXY_ATTRIBUTION_TOKEN_ENV_KEY; pub use attribution::write_attribution_frame; pub use certs::CUSTOM_CA_ENV_KEYS; pub use certs::is_managed_mitm_ca_trust_bundle_path; +pub use codex_utils_path_uri::Platform; pub use config::NetworkDomainPermission; pub use config::NetworkDomainPermissionEntry; pub use config::NetworkDomainPermissions; @@ -61,7 +62,6 @@ pub use credential_broker::credential_broker_provider_context_env_keys; pub use credential_broker::credential_broker_provider_sources_allowed; pub use credential_broker::is_credential_broker_provider_env_key; pub use environment_policy::EnvironmentNetworkPolicy; -pub use executor_os::NetworkProxyExecutorOs; pub use mitm_hook::InjectedHeaderConfig; pub use mitm_hook::MitmHookActionsConfig; pub use mitm_hook::MitmHookBodyConfig; diff --git a/codex-rs/network-proxy/src/network_policy.rs b/codex-rs/network-proxy/src/network_policy.rs index cb009b6e77..49ba623123 100644 --- a/codex-rs/network-proxy/src/network_policy.rs +++ b/codex-rs/network-proxy/src/network_policy.rs @@ -677,7 +677,7 @@ mod tests { let state = build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .unwrap(); let reloader = Arc::new(StaticReloader { diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rs index 631af671e8..db5da744c8 100644 --- a/codex-rs/network-proxy/src/proxy.rs +++ b/codex-rs/network-proxy/src/proxy.rs @@ -1820,7 +1820,7 @@ mod tests { let replacement = crate::state::build_config_state( config.clone(), Default::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), )?; proxy.replace_config_state(replacement).await?; let expected_unix_sockets = if cfg!(target_os = "windows") { @@ -2091,7 +2091,7 @@ mod tests { ..NetworkProxyConfig::default() }, Default::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .expect("replacement config state"); proxy @@ -2177,7 +2177,7 @@ mod tests { let replacement = crate::state::build_config_state( config.clone(), Default::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), )?; proxy.replace_config_state(replacement).await?; let prepared = proxy diff --git a/codex-rs/network-proxy/src/remote_config_tests.rs b/codex-rs/network-proxy/src/remote_config_tests.rs index abcfafd425..a21163478f 100644 --- a/codex-rs/network-proxy/src/remote_config_tests.rs +++ b/codex-rs/network-proxy/src/remote_config_tests.rs @@ -7,8 +7,8 @@ use crate::NetworkMode; use crate::NetworkProxy; use crate::NetworkProxyAuditMetadata; use crate::NetworkProxyConfig; -use crate::NetworkProxyExecutorOs; use crate::NetworkProxyState; +use crate::Platform; use std::sync::Arc; #[test] @@ -44,10 +44,10 @@ fn optional_socket_policy_preserves_input_and_resolves_at_remote_boundary() { #[tokio::test] async fn round_trip_preserves_supported_effective_settings() { for (executor_os, socket) in [ - (NetworkProxyExecutorOs::Linux, "/var/run/example.sock"), - (NetworkProxyExecutorOs::Macos, "/var/run/example.sock"), - (NetworkProxyExecutorOs::Windows, r"C:\example.sock"), - (NetworkProxyExecutorOs::Unknown, r"C:\example.sock"), + (Platform::Linux, "/var/run/example.sock"), + (Platform::Macos, "/var/run/example.sock"), + (Platform::Windows, r"C:\example.sock"), + (Platform::Unknown, r"C:\example.sock"), ] { let mut config = NetworkProxyConfig { enabled: true, @@ -185,7 +185,7 @@ fn launch_config_materializes_audit_and_execution_attribution() { execution_id: Some("execution-1".to_string()), policy_decision_timeout_ms: None, }, - NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + Platform::native(), ) .expect("remote launch state"); diff --git a/codex-rs/network-proxy/src/runtime.rs b/codex-rs/network-proxy/src/runtime.rs index e331f59f6c..04da5a3612 100644 --- a/codex-rs/network-proxy/src/runtime.rs +++ b/codex-rs/network-proxy/src/runtime.rs @@ -169,7 +169,7 @@ fn blocked_request_violation_log_line(entry: &BlockedRequest) -> String { #[derive(Clone)] pub struct ConfigState { /// Preserve the target when policy edits rebuild state on a controller. - pub(crate) executor_os: crate::NetworkProxyExecutorOs, + pub(crate) executor_os: crate::Platform, pub config: NetworkProxyConfig, pub(crate) brokerage_created_default_allowlist: bool, pub allow_set: GlobSet, @@ -290,7 +290,7 @@ impl NetworkProxyState { /// The launching executor supplies its own OS; the wire policy cannot override it. pub fn from_remote_launch_config( launch: crate::RemoteNetworkProxyLaunchConfig, - executor_os: crate::NetworkProxyExecutorOs, + executor_os: crate::Platform, ) -> Result { let crate::RemoteNetworkProxyLaunchConfig { proxy, @@ -584,7 +584,7 @@ impl NetworkProxyState { pub(crate) async fn current_cfg_with_brokerage_provenance( &self, - ) -> Result<(NetworkProxyConfig, bool, crate::NetworkProxyExecutorOs)> { + ) -> Result<(NetworkProxyConfig, bool, crate::Platform)> { // Callers treat `NetworkProxyState` as a live view of policy. We reload-on-demand so edits to // `config.toml` (including Codex-managed writes) take effect without a restart. self.reload_if_needed().await?; @@ -1188,7 +1188,7 @@ pub(crate) fn network_proxy_state_for_policy( config.set_allowed_domains(vec!["*".to_string()]); } let state = ConfigState { - executor_os: crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + executor_os: crate::Platform::native(), allow_set: crate::policy::compile_allowlist_globset( &config.allowed_domains().unwrap_or_default(), ) @@ -1296,7 +1296,7 @@ mod tests { let initial_state = build_config_state( config.clone(), NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .unwrap(); let mut reloaded_config = config; @@ -1304,7 +1304,7 @@ mod tests { let reloaded_state = build_config_state( reloaded_config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .unwrap(); let state = NetworkProxyState::with_reloader( @@ -1333,7 +1333,7 @@ mod tests { enabled: Some(false), ..NetworkProxyConstraints::default() }, - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .expect("managed-disabled credential broker should fail open"); let state = NetworkProxyState::with_reloader(config_state, Arc::new(NoopReloader)); @@ -1384,7 +1384,7 @@ mod tests { let config_state = build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .expect("valid credential-broker configuration"); assert_eq!(config_state.brokerage_created_default_allowlist, !enabled); @@ -1472,12 +1472,7 @@ mod tests { ..NetworkProxyConstraints::default() }; let state = NetworkProxyState::with_reloader( - build_config_state( - config, - constraints, - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), - ) - .unwrap(), + build_config_state(config, constraints, crate::Platform::native()).unwrap(), Arc::new(NoopReloader), ); @@ -1504,12 +1499,7 @@ mod tests { ..NetworkProxyConstraints::default() }; let state = NetworkProxyState::with_reloader( - build_config_state( - config, - constraints, - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), - ) - .unwrap(), + build_config_state(config, constraints, crate::Platform::native()).unwrap(), Arc::new(NoopReloader), ); @@ -1534,12 +1524,7 @@ mod tests { ..NetworkProxyConstraints::default() }; let state = NetworkProxyState::with_reloader( - build_config_state( - config, - constraints, - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), - ) - .unwrap(), + build_config_state(config, constraints, crate::Platform::native()).unwrap(), Arc::new(NoopReloader), ); @@ -2211,7 +2196,7 @@ mod tests { build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)) + crate::Platform::native() ) .is_ok() ); @@ -2226,7 +2211,7 @@ mod tests { build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)) + crate::Platform::native() ) .is_ok() ); @@ -2241,7 +2226,7 @@ mod tests { build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)) + crate::Platform::native() ) .is_err() ); @@ -2256,7 +2241,7 @@ mod tests { build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)) + crate::Platform::native() ) .is_err() ); diff --git a/codex-rs/network-proxy/src/socket_path.rs b/codex-rs/network-proxy/src/socket_path.rs new file mode 100644 index 0000000000..ce72bcdcc8 --- /dev/null +++ b/codex-rs/network-proxy/src/socket_path.rs @@ -0,0 +1,36 @@ +//! Executor-specific absolute socket path validation, independent of the controller OS. +//! Socket support and native path normalization remain executor runtime concerns. + +use codex_utils_path_uri::PathConvention; +use codex_utils_path_uri::Platform; + +pub(crate) fn socket_path_is_absolute(platform: Platform, path: &str) -> bool { + // Core also accepts Unix-style absolute paths on Windows, for portability. + path.starts_with('/') + || match platform.path_convention() { + Some(PathConvention::Posix) => false, + // Legacy executors without OS metadata validate against their own + // platform at launch; accept either absolute syntax here. + Some(PathConvention::Windows) | None => windows_path_is_absolute(path), + } +} + +// Match std::path's Windows absolute-path syntax without consulting the host. +// Non-drive prefixes have an implicit root, including device and verbatim paths. +fn windows_path_is_absolute(path: &str) -> bool { + let bytes = path.as_bytes(); + if matches!(bytes, [drive, b':', b'\\' | b'/', ..] if drive.is_ascii_alphabetic()) { + return true; + } + let [b'\\' | b'/', b'\\' | b'/', rest @ ..] = bytes else { + return false; + }; + if path.starts_with(r"\\?\") || matches!(rest, [b'.', b'\\' | b'/', ..]) { + return true; + } + let mut components = rest.split(|byte| matches!(byte, b'\\' | b'/')); + matches!( + (components.next(), components.next()), + (Some(server), Some(share)) if !server.is_empty() && !share.is_empty() + ) +} diff --git a/codex-rs/network-proxy/src/socks5.rs b/codex-rs/network-proxy/src/socks5.rs index ec8c0a1116..c8e7120c8d 100644 --- a/codex-rs/network-proxy/src/socks5.rs +++ b/codex-rs/network-proxy/src/socks5.rs @@ -905,7 +905,7 @@ mod tests { let state = build_config_state( config, NetworkProxyConstraints::default(), - crate::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + crate::Platform::native(), ) .unwrap(); let reloader = Arc::new(StaticReloader { diff --git a/codex-rs/network-proxy/src/state.rs b/codex-rs/network-proxy/src/state.rs index 26684e4b39..918b5ade2a 100644 --- a/codex-rs/network-proxy/src/state.rs +++ b/codex-rs/network-proxy/src/state.rs @@ -62,7 +62,7 @@ pub struct PartialNetworkProxyConfig { pub fn build_config_state( mut config: NetworkProxyConfig, constraints: NetworkProxyConstraints, - executor_os: crate::NetworkProxyExecutorOs, + executor_os: crate::Platform, ) -> anyhow::Result { if constraints.enabled == Some(false) { config.credential_broker = false; diff --git a/codex-rs/network-proxy/tests/windows_stable_ingress.rs b/codex-rs/network-proxy/tests/windows_stable_ingress.rs index 938b6342b7..b3bd79b7ee 100644 --- a/codex-rs/network-proxy/tests/windows_stable_ingress.rs +++ b/codex-rs/network-proxy/tests/windows_stable_ingress.rs @@ -305,7 +305,7 @@ async fn build_proxy( let config_state = build_config_state( config, Default::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + codex_network_proxy::Platform::native(), )?; let reloader = Arc::new(StaticReloader(config_state.clone())); let state = Arc::new(NetworkProxyState::with_reloader(config_state, reloader)); diff --git a/codex-rs/sandboxing/src/manager_tests.rs b/codex-rs/sandboxing/src/manager_tests.rs index 5ef53c24f1..26cc072c75 100644 --- a/codex-rs/sandboxing/src/manager_tests.rs +++ b/codex-rs/sandboxing/src/manager_tests.rs @@ -541,7 +541,7 @@ async fn linux_unix_socket_grant_uses_effective_managed_policy() -> anyhow::Resu ..Default::default() }, NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + codex_utils_path_uri::Platform::native(), )?; let network = NetworkProxy::builder() .state(Arc::new(NetworkProxyState::with_reloader( diff --git a/codex-rs/sandboxing/src/seatbelt_tests.rs b/codex-rs/sandboxing/src/seatbelt_tests.rs index 217535c63f..eef7919213 100644 --- a/codex-rs/sandboxing/src/seatbelt_tests.rs +++ b/codex-rs/sandboxing/src/seatbelt_tests.rs @@ -819,7 +819,7 @@ async fn prepared_managed_network_context_takes_precedence_over_live_proxy_socke let state = build_config_state( network_config, NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + codex_utils_path_uri::Platform::native(), )?; let network_proxy = NetworkProxy::builder() .state(Arc::new(NetworkProxyState::with_reloader( @@ -1531,7 +1531,7 @@ async fn create_seatbelt_args_merges_proxy_and_explicit_unix_socket_paths() -> a let state = build_config_state( network_config, NetworkProxyConstraints::default(), - codex_network_proxy::NetworkProxyExecutorOs::from_platform_os(Some(std::env::consts::OS)), + codex_utils_path_uri::Platform::native(), )?; let network_proxy = NetworkProxy::builder() .state(Arc::new(NetworkProxyState::with_reloader( diff --git a/codex-rs/utils/path-uri/src/lib.rs b/codex-rs/utils/path-uri/src/lib.rs index 18158ffd4d..c35142fd9a 100644 --- a/codex-rs/utils/path-uri/src/lib.rs +++ b/codex-rs/utils/path-uri/src/lib.rs @@ -26,11 +26,13 @@ mod absolute_path_normalization; mod api_path_string; mod config_path; mod native_path_bytes; +mod platform; use absolute_path_normalization::path_uri_from_segments; pub use api_path_string::LegacyAppPathString; pub use api_path_string::LegacyAppPathStringError; +pub use platform::Platform; pub const FILE_SCHEME: &str = "file"; const BAD_PATH_URI_PREFIX: &str = "file:///%00/bad/path/"; diff --git a/codex-rs/utils/path-uri/src/platform.rs b/codex-rs/utils/path-uri/src/platform.rs new file mode 100644 index 0000000000..90cb64efc8 --- /dev/null +++ b/codex-rs/utils/path-uri/src/platform.rs @@ -0,0 +1,51 @@ +//! Platform identity and its path convention, independent of the resolving host. + +use crate::PathConvention; + +/// Operating system whose paths and execution configuration are being resolved. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Platform { + Linux, + Macos, + Windows, + /// Missing or unrecognized platform metadata carries no path convention. + Unknown, +} + +impl Platform { + /// Read platform metadata without substituting the current host's platform. + pub fn from_platform_os(platform_os: Option<&str>) -> Self { + match platform_os { + Some("linux") => Self::Linux, + Some("macos") => Self::Macos, + Some("windows") => Self::Windows, + Some(_) | None => Self::Unknown, + } + } + + /// Return the platform of the current process. + pub const fn native() -> Self { + if cfg!(target_os = "linux") { + Self::Linux + } else if cfg!(target_os = "macos") { + Self::Macos + } else if cfg!(target_os = "windows") { + Self::Windows + } else { + Self::Unknown + } + } + + /// Derive path grammar from platform identity while preserving unknown metadata. + pub const fn path_convention(self) -> Option { + match self { + Self::Linux | Self::Macos => Some(PathConvention::Posix), + Self::Windows => Some(PathConvention::Windows), + Self::Unknown => None, + } + } +} + +#[cfg(test)] +#[path = "platform_tests.rs"] +mod tests; diff --git a/codex-rs/utils/path-uri/src/platform_tests.rs b/codex-rs/utils/path-uri/src/platform_tests.rs new file mode 100644 index 0000000000..07328d4d18 --- /dev/null +++ b/codex-rs/utils/path-uri/src/platform_tests.rs @@ -0,0 +1,43 @@ +//! Coverage for platform metadata and platform-derived path conventions. + +use super::*; +use pretty_assertions::assert_eq; + +#[test] +fn platform_metadata_preserves_missing_and_unrecognized_values() { + for (metadata, expected) in [ + (Some("linux"), Platform::Linux), + (Some("macos"), Platform::Macos), + (Some("windows"), Platform::Windows), + (None, Platform::Unknown), + (Some("freebsd"), Platform::Unknown), + (Some("Windows"), Platform::Unknown), + (Some(""), Platform::Unknown), + ] { + assert_eq!( + Platform::from_platform_os(metadata), + expected, + "{metadata:?}" + ); + } +} + +#[test] +fn path_convention_is_derived_from_platform() { + for (platform, expected) in [ + (Platform::Linux, Some(PathConvention::Posix)), + (Platform::Macos, Some(PathConvention::Posix)), + (Platform::Windows, Some(PathConvention::Windows)), + (Platform::Unknown, None), + ] { + assert_eq!(platform.path_convention(), expected, "{platform:?}"); + } +} + +#[test] +fn native_platform_matches_current_process_metadata() { + assert_eq!( + Platform::native(), + Platform::from_platform_os(Some(std::env::consts::OS)), + ); +}