Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add managed network review domains before allow rules (#56154)

olliem-oai94350a910143
diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json
index ba22b80fea..cf785c660d 100644
--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json
+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json
@@ -16282,6 +16282,16 @@
"null"
]
},
+ "reviewDomains": {
+ "description": "Host patterns routed to network approval before ordinary allow rules.",
+ "items": {
+ "type": "string"
+ },
+ "type": [
+ "array",
+ "null"
+ ]
+ },
"socksPort": {
"format": "uint16",
"minimum": 0.0,
diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json
index 5c590af8cd..bd88041df4 100644
--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json
+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json
@@ -12274,6 +12274,16 @@
"null"
]
},
+ "reviewDomains": {
+ "description": "Host patterns routed to network approval before ordinary allow rules.",
+ "items": {
+ "type": "string"
+ },
+ "type": [
+ "array",
+ "null"
+ ]
+ },
"socksPort": {
"format": "uint16",
"minimum": 0.0,
diff --git a/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json
index 895d3d6fa8..d549850ac1 100644
--- a/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json
+++ b/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json
@@ -1073,6 +1073,16 @@
"null"
]
},
+ "reviewDomains": {
+ "description": "Host patterns routed to network approval before ordinary allow rules.",
+ "items": {
+ "type": "string"
+ },
+ "type": [
+ "array",
+ "null"
+ ]
+ },
"socksPort": {
"format": "uint16",
"minimum": 0.0,
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst
index 3772c18975..a9e3c99cba 100644
Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differ
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst
index 145a95a10c..90c6e35e92 100644
Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differ
diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts b/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts
index 04e07ef1de..5a496b132a 100644
--- a/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts
+++ b/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts
@@ -9,6 +9,10 @@ export type NetworkRequirements = { enabled: boolean | null, httpPort: number |
* Canonical network permission map for `experimental_network`.
*/
domains: { [key in string]?: NetworkDomainPermission } | null,
+/**
+ * Host patterns routed to network approval before ordinary allow rules.
+ */
+reviewDomains: Array<string> | null,
/**
* When true, only managed allowlist entries are respected while managed
* network enforcement is active.
diff --git a/codex-rs/app-server-protocol/src/protocol/v2/config.rs b/codex-rs/app-server-protocol/src/protocol/v2/config.rs
index f9d7b14c6b..552520aff3 100644
--- a/codex-rs/app-server-protocol/src/protocol/v2/config.rs
+++ b/codex-rs/app-server-protocol/src/protocol/v2/config.rs
@@ -725,6 +725,8 @@ pub struct NetworkRequirements {
pub dangerously_allow_all_unix_sockets: Option<bool>,
/// Canonical network permission map for `experimental_network`.
pub domains: Option<BTreeMap<String, NetworkDomainPermission>>,
+ /// Host patterns routed to network approval before ordinary allow rules.
+ pub review_domains: Option<Vec<String>>,
/// When true, only managed allowlist entries are respected while managed
/// network enforcement is active.
pub managed_allowed_domains_only: Option<bool>,
diff --git a/codex-rs/app-server-protocol/src/protocol/v2/tests.rs b/codex-rs/app-server-protocol/src/protocol/v2/tests.rs
index 234636839d..d268de69fb 100644
--- a/codex-rs/app-server-protocol/src/protocol/v2/tests.rs
+++ b/codex-rs/app-server-protocol/src/protocol/v2/tests.rs
@@ -3054,6 +3054,7 @@ fn network_requirements_deserializes_legacy_fields() {
dangerously_allow_non_loopback_proxy: None,
dangerously_allow_all_unix_sockets: None,
domains: None,
+ review_domains: None,
managed_allowed_domains_only: None,
allowed_domains: Some(vec!["api.openai.com".to_string()]),
denied_domains: Some(vec!["blocked.example.com".to_string()]),
@@ -3080,6 +3081,7 @@ fn network_requirements_serializes_canonical_and_legacy_fields() {
NetworkDomainPermission::Deny,
),
])),
+ review_domains: Some(vec!["api.openai.com".to_string()]),
managed_allowed_domains_only: Some(true),
allowed_domains: Some(vec!["api.openai.com".to_string()]),
denied_domains: Some(vec!["blocked.example.com".to_string()]),
@@ -3110,6 +3112,7 @@ fn network_requirements_serializes_canonical_and_legacy_fields() {
"api.openai.com": "allow",
"blocked.example.com": "deny"
},
+ "reviewDomains": ["api.openai.com"],
"managedAllowedDomainsOnly": true,
"allowedDomains": ["api.openai.com"],
"deniedDomains": ["blocked.example.com"],
diff --git a/codex-rs/app-server/src/request_processors/config_processor.rs b/codex-rs/app-server/src/request_processors/config_processor.rs
index 1500cd82a2..bbfc952151 100644
--- a/codex-rs/app-server/src/request_processors/config_processor.rs
+++ b/codex-rs/app-server/src/request_processors/config_processor.rs
@@ -868,6 +868,7 @@ fn map_network_requirements_to_api(
})
.collect()
}),
+ review_domains: network.review_domains,
managed_allowed_domains_only: network.managed_allowed_domains_only,
allowed_domains,
denied_domains,
diff --git a/codex-rs/app-server/tests/suite/v2/config_rpc.rs b/codex-rs/app-server/tests/suite/v2/config_rpc.rs
index c4ba5937d1..20476284ec 100644
--- a/codex-rs/app-server/tests/suite/v2/config_rpc.rs
+++ b/codex-rs/app-server/tests/suite/v2/config_rpc.rs
@@ -37,6 +37,8 @@ use codex_app_server_protocol::ConfiguredHookHandler;
use codex_app_server_protocol::ForcedChatgptWorkspaceIds;
use codex_app_server_protocol::JSONRPCError;
use codex_app_server_protocol::MergeStrategy;
+use codex_app_server_protocol::NetworkDomainPermission;
+use codex_app_server_protocol::NetworkRequirements;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::SandboxMode;
use codex_app_server_protocol::ToolsV2;
@@ -106,6 +108,52 @@ async fn config_requirements_read_exposes_independent_speed_policy() -> Result<(
Ok(())
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn config_requirements_read_includes_network_review_domains() -> Result<()> {
+ let codex_home = TempDir::new()?;
+ std::fs::write(
+ codex_home.path().join("requirements.toml"),
+ r#"[experimental_network]
+enabled = true
+allowed_domains = ["**.example.com"]
+review_domains = ["review.example.com"]
+"#,
+ )?;
+ let mut app_server = TestAppServer::builder()
+ .with_codex_home(codex_home.path())
+ .build_initialized()
+ .await?;
+
+ let request_id = app_server.send_config_requirements_read_request().await?;
+ let response: ConfigRequirementsReadResponse = app_server.read_response(request_id).await?;
+ assert_eq!(
+ response
+ .requirements
+ .expect("managed requirements should be returned")
+ .network,
+ Some(NetworkRequirements {
+ enabled: Some(true),
+ http_port: None,
+ socks_port: None,
+ allow_upstream_proxy: None,
+ dangerously_allow_non_loopback_proxy: None,
+ dangerously_allow_all_unix_sockets: None,
+ domains: Some(BTreeMap::from([(
+ "**.example.com".to_string(),
+ NetworkDomainPermission::Allow,
+ )])),
+ review_domains: Some(vec!["review.example.com".to_string()]),
+ managed_allowed_domains_only: None,
+ allowed_domains: Some(vec!["**.example.com".to_string()]),
+ denied_domains: None,
+ unix_sockets: None,
+ allow_unix_sockets: None,
+ allow_local_binding: None,
+ }),
+ );
+ Ok(())
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn managed_auth_settings_are_exposed_enforced_and_read_only() -> Result<()> {
let codex_home = TempDir::new()?;
diff --git a/codex-rs/config/src/config_requirements.rs b/codex-rs/config/src/config_requirements.rs
index 5e1cc86751..961e3c3d78 100644
--- a/codex-rs/config/src/config_requirements.rs
+++ b/codex-rs/config/src/config_requirements.rs
@@ -432,6 +432,9 @@ pub struct NetworkRequirementsToml {
pub dangerously_allow_non_loopback_proxy: Option<bool>,
pub dangerously_allow_all_unix_sockets: Option<bool>,
pub domains: Option<NetworkDomainPermissionsToml>,
+ /// Host patterns routed to the existing network approval flow before ordinary allow rules.
+ /// Explicit denials take precedence; approval caching, hooks, and reviewer routing still apply.
+ pub review_domains: Option<Vec<String>>,
/// When true, only managed `allowed_domains` are respected while managed
/// network enforcement is active. User allowlist entries are ignored.
pub managed_allowed_domains_only: Option<bool>,
@@ -471,6 +474,7 @@ struct RawNetworkRequirementsToml {
dangerously_allow_non_loopback_proxy: Option<bool>,
dangerously_allow_all_unix_sockets: Option<bool>,
domains: Option<NetworkDomainPermissionsToml>,
+ review_domains: Option<Vec<String>>,
#[serde(default)]
allowed_domains: Option<Vec<String>>,
/// When true, only managed `allowed_domains` are respected while managed
@@ -499,6 +503,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
+ review_domains,
allowed_domains,
managed_allowed_domains_only,
denied_domains,
@@ -529,6 +534,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {
dangerously_allow_all_unix_sockets,
domains: domains
.or_else(|| legacy_domain_permissions_from_lists(allowed_domains, denied_domains)),
+ review_domains,
managed_allowed_domains_only,
unix_sockets: unix_sockets
.or_else(|| legacy_unix_socket_permissions_from_list(allow_unix_sockets)),
@@ -580,6 +586,7 @@ pub struct NetworkConstraints {
pub dangerously_allow_non_loopback_proxy: Option<bool>,
pub dangerously_allow_all_unix_sockets: Option<bool>,
pub domains: Option<NetworkDomainPermissionsToml>,
+ pub review_domains: Option<Vec<String>>,
/// When true, only managed `allowed_domains` are respected while managed
/// network enforcement is active. User allowlist entries are ignored.
pub managed_allowed_domains_only: Option<bool>,
@@ -608,6 +615,7 @@ impl From<NetworkRequirementsToml> for NetworkConstraints {
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
+ review_domains,
managed_allowed_domains_only,
unix_sockets,
allow_local_binding,
@@ -621,6 +629,7 @@ impl From<NetworkRequirementsToml> for NetworkConstraints {
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
+ review_domains,
managed_allowed_domains_only,
unix_sockets,
allow_local_binding,
@@ -4567,6 +4576,7 @@ command = "python3 /enterprise/hooks/pre.py"
allow_upstream_proxy = false
dangerously_allow_all_unix_sockets = true
allowed_domains = ["api.example.com", "*.openai.com"]
+ review_domains = ["review.example.com", "*.review.example.com"]
managed_allowed_domains_only = true
denied_domains = ["blocked.example.com"]
allow_unix_sockets = ["/tmp/example.sock"]
@@ -4623,6 +4633,14 @@ command = "python3 /enterprise/hooks/pre.py"
);
assert_eq!(sourced_network.value.allow_local_binding, Some(false));
+ assert_eq!(
+ sourced_network.value.review_domains,
+ Some(vec![
+ "review.example.com".to_string(),
+ "*.review.example.com".to_string()
+ ])
+ );
+
Ok(())
}
diff --git a/codex-rs/core/src/config/network_proxy_spec.rs b/codex-rs/core/src/config/network_proxy_spec.rs
index ace90ef9c2..44e6087a9b 100644
--- a/codex-rs/core/src/config/network_proxy_spec.rs
+++ b/codex-rs/core/src/config/network_proxy_spec.rs
@@ -474,6 +474,10 @@ impl NetworkProxySpec {
constraints.denied_domains = Some(managed_denied_domains);
constraints.denylist_expansion_enabled = Some(denylist_expansion_enabled);
}
+ if let Some(review_domains) = &requirements.review_domains {
+ config.review_domains =
+ Self::merge_domain_lists(review_domains.clone(), &config.review_domains);
+ }
if requirements.unix_sockets.is_some() {
let allow_unix_sockets = requirements
.unix_sockets
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 d44b39f75c..d015fb6c40 100644
--- a/codex-rs/core/src/config/network_proxy_spec_tests.rs
+++ b/codex-rs/core/src/config/network_proxy_spec_tests.rs
@@ -223,6 +223,7 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials()
("controller.example", NetworkDomainPermissionToml::Allow),
("blocked.example", NetworkDomainPermissionToml::Deny),
])),
+ review_domains: Some(vec!["controller-review.example".to_string()]),
..Default::default()
};
let profile = PermissionProfile::workspace_write();
@@ -249,7 +250,10 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials()
&profile,
)
.expect("controller policy should be valid");
- let mut owner = NetworkProxyConfig::default();
+ let mut owner = NetworkProxyConfig {
+ review_domains: vec!["owner-review.example".to_string()],
+ ..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![
@@ -312,6 +316,9 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials()
owner.dangerously_allow_all_unix_sockets = Some(false);
owner.allow_local_binding = Some(true);
owner.enabled = true;
+ owner
+ .review_domains
+ .insert(0, "controller-review.example".to_string());
assert_eq!(
restricted.environment_policy(),
EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false)
diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rs
index 7eb6860729..467d54e052 100644
--- a/codex-rs/core/src/tools/network_approval.rs
+++ b/codex-rs/core/src/tools/network_approval.rs
@@ -677,7 +677,7 @@ impl NetworkApprovalService {
let target = Self::format_network_target(key.protocol, request.host.as_str(), key.port);
let policy_denial_message =
format!("Network access to \"{target}\" was blocked by policy.");
- let prompt_reason = format!("{} is not in the allowed_domains", request.host);
+ let prompt_reason = format!("Network access to {} requires approval", request.host);
let Some((turn_context, settings, active_environments, strict_auto_review)) = active_turn
else {
diff --git a/codex-rs/core/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rs
index e60331cc94..9fce5b9c3d 100644
--- a/codex-rs/core/tests/suite/hooks.rs
+++ b/codex-rs/core/tests/suite/hooks.rs
@@ -48,7 +48,6 @@ use codex_thread_store::InMemoryThreadStore;
use core_test_support::TestTargetOs;
use core_test_support::fs_wait;
use core_test_support::hooks::trust_discovered_hooks;
-use core_test_support::managed_network_requirements_loader;
use core_test_support::responses;
use core_test_support::responses::ev_apply_patch_custom_tool_call;
use core_test_support::responses::ev_assistant_message;
@@ -3415,7 +3414,17 @@ allow_local_binding = true
)
.expect("failed to write permission request hook test fixture");
})
- .with_cloud_config_bundle(managed_network_requirements_loader())
+ .with_cloud_config_bundle(
+ CloudConfigBundleFixture::loader_with_enterprise_requirement(
+ r#"
+[experimental_network]
+enabled = true
+allow_local_binding = true
+allowed_domains = ["**.invalid"]
+review_domains = ["codex-network-test.invalid"]
+"#,
+ ),
+ )
.with_config(move |config| {
trust_discovered_hooks(config);
config.approvals_reviewer = codex_config::types::ApprovalsReviewer::AutoReview;
diff --git a/codex-rs/core/tests/suite/network_approval.rs b/codex-rs/core/tests/suite/network_approval.rs
index 64a97413c9..62b5b1bfb7 100644
--- a/codex-rs/core/tests/suite/network_approval.rs
+++ b/codex-rs/core/tests/suite/network_approval.rs
@@ -1166,7 +1166,7 @@ async fn user_network_approval_once_session_and_denial_semantics() -> Result<()>
assert_eq!(approval.cwd, test.config.cwd.clone().into());
assert_eq!(
approval.reason.as_deref(),
- Some("codex-network-test.invalid is not in the allowed_domains")
+ Some("Network access to codex-network-test.invalid requires approval")
);
test.codex
.submit(Op::ExecApproval {
diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rs
index fbb2496f26..dad1132447 100644
--- a/codex-rs/exec-server-protocol/src/protocol.rs
+++ b/codex-rs/exec-server-protocol/src/protocol.rs
@@ -153,6 +153,9 @@ pub struct EnvironmentCapabilities {
/// Whether `exec` accepts instructions for launching an executor-local network proxy.
#[serde(default)]
network_proxy_launch: bool,
+ /// Whether executor proxies enforce managed review domains before ordinary allows.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub network_proxy_review_domains: bool,
/// Whether the selected shell can mask executor environment credentials.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
credential_masking: bool,
@@ -314,6 +317,7 @@ impl EnvironmentInfo {
temp_dir,
capabilities: EnvironmentCapabilities {
network_proxy_launch: true,
+ network_proxy_review_domains: true,
credential_masking,
credential_masking_custom_providers: credential_masking,
capability_discovery_sandbox: true,
@@ -1539,6 +1543,7 @@ mod tests {
capabilities,
EnvironmentCapabilities {
network_proxy_launch: true,
+ network_proxy_review_domains: false,
credential_masking: false,
credential_masking_custom_providers: false,
capability_discovery_sandbox: true,
diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rs
index d243b99d99..e8140904f5 100644
--- a/codex-rs/exec-server/src/client.rs
+++ b/codex-rs/exec-server/src/client.rs
@@ -845,9 +845,31 @@ impl ExecServerClient {
}
pub async fn exec(&self, params: ExecParams) -> Result<ExecResponse, ExecServerError> {
+ self.ensure_network_review_capability(&params).await?;
self.call(EXEC_METHOD, &params).await
}
+ async fn ensure_network_review_capability(
+ &self,
+ params: &ExecParams,
+ ) -> Result<(), ExecServerError> {
+ if params
+ .network_proxy
+ .as_ref()
+ .is_some_and(|launch| !launch.proxy.review_domains.is_empty())
+ && !self
+ .environment_info()
+ .await?
+ .capabilities
+ .network_proxy_review_domains
+ {
+ return Err(ExecServerError::Protocol(
+ "selected exec-server does not support managed network review domains".to_string(),
+ ));
+ }
+ Ok(())
+ }
+
/// Returns shared cached executor metadata, fetching it lazily if initialization omitted it.
pub async fn environment_info(&self) -> Result<Arc<EnvironmentInfo>, ExecServerError> {
self.inner
@@ -1107,6 +1129,7 @@ impl ExecServerClient {
params: ExecParams,
network_policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,
) -> Result<Session, ExecServerError> {
+ self.ensure_network_review_capability(&params).await?;
let policy_decision_timeout_ms = params
.network_proxy
.as_ref()
diff --git a/codex-rs/network-proxy/src/config.rs b/codex-rs/network-proxy/src/config.rs
index 55841b78bc..91a201f3ef 100644
--- a/codex-rs/network-proxy/src/config.rs
+++ b/codex-rs/network-proxy/src/config.rs
@@ -146,6 +146,10 @@ pub struct NetworkProxyConfig {
pub mode: NetworkMode,
#[serde(default)]
pub domains: Option<NetworkDomainPermissions>,
+ /// Managed host selectors routed through the existing approval flow before ordinary allows.
+ /// Direct proxy configuration cannot change these requirements-only selectors.
+ #[serde(skip)]
+ pub review_domains: Vec<String>,
#[serde(default)]
pub unix_sockets: Option<NetworkUnixSocketPermissions>,
/// Omission is resolved for the selected sandbox; ordinary proxy execution defaults to false.
@@ -187,6 +191,7 @@ impl Default for NetworkProxyConfig {
dangerously_allow_all_unix_sockets: None,
mode: NetworkMode::default(),
domains: None,
+ review_domains: Vec::new(),
unix_sockets: None,
allow_local_binding: None,
mitm: false,
@@ -727,6 +732,7 @@ mod tests {
dangerously_allow_all_unix_sockets: None,
mode: NetworkMode::Full,
domains: None,
+ review_domains: Vec::new(),
unix_sockets: None,
allow_local_binding: None,
mitm: false,
diff --git a/codex-rs/network-proxy/src/connect_policy.rs b/codex-rs/network-proxy/src/connect_policy.rs
index eab3df9831..abb6a67d91 100644
--- a/codex-rs/network-proxy/src/connect_policy.rs
+++ b/codex-rs/network-proxy/src/connect_policy.rs
@@ -1,4 +1,5 @@
use crate::policy::is_non_public_ip;
+use crate::runtime::HostAuthorization;
use crate::runtime::HostBlockDecision;
use crate::state::NetworkProxyState;
#[cfg(target_os = "macos")]
@@ -20,6 +21,8 @@ use std::io;
use std::net::SocketAddr;
use std::sync::Arc;
+/// Connects traffic whose host policy has already allowed the request.
+/// Resolved non-public targets still undergo explicit-deny and local-address checks.
#[derive(Clone)]
pub(crate) struct TargetCheckedTcpConnector {
state: Arc<NetworkProxyState>,
@@ -105,7 +108,12 @@ impl TargetCheckedStreamConnector {
}
self.state
- .host_blocked(&self.target.host.to_string(), self.target.port)
+ .host_blocked_with_local_binding(
+ &self.target.host.to_string(),
+ self.target.port,
+ /*allow_local_binding*/ None,
+ HostAuthorization::Approved,
+ )
.await
.map(|decision| decision == HostBlockDecision::Allowed)
.map_err(|err| {
@@ -198,8 +206,9 @@ mod tests {
let target = listener.local_addr().expect("local addr");
let mut config = NetworkProxyConfig::default();
config.set_allowed_domains(vec![target.ip().to_string()]);
- let connector =
- TargetCheckedTcpConnector::new(Arc::new(network_proxy_state_for_policy(config)));
+ config.review_domains = vec![target.ip().to_string()];
+ let state = Arc::new(network_proxy_state_for_policy(config));
+ let connector = TargetCheckedTcpConnector::new(Arc::clone(&state));
let request: rama_tcp::client::Request =
rama_tcp::client::Request::new(HostWithPort::from(target));
@@ -209,6 +218,12 @@ mod tests {
result.is_ok(),
"explicitly allowlisted local target should be allowed: {result:?}"
);
+ state
+ .add_denied_domain(&target.ip().to_string())
+ .await
+ .unwrap();
+ let request = rama_tcp::client::Request::new(HostWithPort::from(target));
+ assert!(Service::serve(&connector, request).await.is_err());
}
#[tokio::test(flavor = "current_thread")]
@@ -219,6 +234,7 @@ mod tests {
let target = listener.local_addr().expect("local addr");
let mut config = NetworkProxyConfig::default();
config.set_allowed_domains(vec!["localhost".to_string()]);
+ config.review_domains = vec!["localhost".to_string()];
let connector =
TargetCheckedTcpConnector::new(Arc::new(network_proxy_state_for_policy(config)));
diff --git a/codex-rs/network-proxy/src/environment_policy.rs b/codex-rs/network-proxy/src/environment_policy.rs
index d877f79d02..aea0e9b966 100644
--- a/codex-rs/network-proxy/src/environment_policy.rs
+++ b/codex-rs/network-proxy/src/environment_policy.rs
@@ -17,6 +17,9 @@ pub struct EnvironmentNetworkPolicy {
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub requires_proxy: bool,
pub domains: Option<NetworkDomainPermissions>,
+ /// Managed host selectors inherited by every execution in this environment.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub review_domains: Vec<String>,
pub unix_sockets: Option<NetworkUnixSocketPermissions>,
pub allow_upstream_proxy: bool,
pub dangerously_allow_all_unix_sockets: bool,
@@ -31,6 +34,7 @@ impl EnvironmentNetworkPolicy {
Self {
requires_proxy: config.enabled,
domains: config.domains.clone(),
+ review_domains: config.review_domains.clone(),
unix_sockets: config.unix_sockets.clone(),
allow_upstream_proxy: config.allow_upstream_proxy,
dangerously_allow_all_unix_sockets: config
@@ -43,6 +47,16 @@ impl EnvironmentNetworkPolicy {
/// Applies attachment-owned traffic settings while preserving inherited denials and proxy setup.
pub fn apply_to(&self, config: &mut NetworkProxyConfig) {
+ // Neither owner nor controller may remove the other's review selectors.
+ for pattern in &self.review_domains {
+ if !config
+ .review_domains
+ .iter()
+ .any(|existing| existing.eq_ignore_ascii_case(pattern))
+ {
+ config.review_domains.push(pattern.clone());
+ }
+ }
// 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);
diff --git a/codex-rs/network-proxy/src/host_policy_tests.rs b/codex-rs/network-proxy/src/host_policy_tests.rs
index 7addfffce8..d6009ec3a7 100644
--- a/codex-rs/network-proxy/src/host_policy_tests.rs
+++ b/codex-rs/network-proxy/src/host_policy_tests.rs
@@ -51,7 +51,7 @@ async fn unapproved_hosts_do_not_trigger_dns() {
}
#[tokio::test]
-async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()> {
+async fn local_and_remote_approvals_preserve_review_precedence_and_recheck_dns() -> Result<()> {
use crate::NetworkDecision;
use crate::NetworkDecisionSource;
use crate::NetworkPolicyDecider;
@@ -61,21 +61,33 @@ async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()
use crate::NetworkProxy;
use crate::network_policy::evaluate_host_policy;
use std::sync::Arc;
- use std::sync::atomic::AtomicUsize;
- use std::sync::atomic::Ordering;
+ use std::sync::Mutex;
for remote in [false, true] {
- let calls = Arc::new(AtomicUsize::new(0));
+ let calls = Arc::new(Mutex::new(Vec::new()));
let decider_calls = Arc::clone(&calls);
- let decider: Arc<dyn NetworkPolicyDecider> = Arc::new(move |_request| {
- decider_calls.fetch_add(1, Ordering::SeqCst);
- async { NetworkDecision::Allow }
- });
+ let decider: Arc<dyn NetworkPolicyDecider> =
+ Arc::new(move |request: NetworkPolicyRequest| {
+ decider_calls.lock().unwrap().push(request.host);
+ async { NetworkDecision::Allow }
+ });
// Explicit controller false must survive an executor allowing local binding.
- let config = NetworkProxyConfig {
+ let mut config = NetworkProxyConfig {
allow_local_binding: Some(false),
+ review_domains: vec![
+ "8.8.8.8".to_string(),
+ "9.9.9.9".to_string(),
+ "host.review.invalid".to_string(),
+ ],
..NetworkProxyConfig::default()
};
+ config.set_allowed_domains(vec![
+ "8.8.8.8".to_string(),
+ "1.1.1.1".to_string(),
+ "9.9.9.9".to_string(),
+ "**.review.invalid".to_string(),
+ ]);
+ config.set_denied_domains(vec!["9.9.9.9".to_string()]);
let state = Arc::new(network_proxy_state_for_policy(config));
let proxy = NetworkProxy::builder()
.state(Arc::clone(&state))
@@ -93,7 +105,14 @@ async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()
let remote_decider = scoped
.remote_policy_decider(/*allow_local_binding*/ true)
.unwrap();
- for host in ["does-not-resolve.invalid", "8.8.8.8"] {
+ for host in [
+ "does-not-resolve.invalid",
+ "8.8.8.8",
+ "host.review.invalid",
+ "ordinary.review.invalid",
+ "1.1.1.1",
+ "9.9.9.9",
+ ] {
let request = NetworkPolicyRequest::new(NetworkPolicyRequestArgs {
protocol: NetworkProtocol::HttpsConnect,
host: host.to_string(),
@@ -114,15 +133,20 @@ async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()
HostBlockReason::NotAllowedLocal.as_str(),
NetworkDecisionSource::BaselinePolicy,
)
+ } else if host == "9.9.9.9" {
+ NetworkDecision::deny_with_source(
+ HostBlockReason::Denied.as_str(),
+ NetworkDecisionSource::BaselinePolicy,
+ )
} else {
NetworkDecision::Allow
};
assert_eq!(decision, expected);
}
assert_eq!(
- calls.load(Ordering::SeqCst),
- 2,
- "domain review precedes DNS"
+ *calls.lock().unwrap(),
+ vec!["does-not-resolve.invalid", "8.8.8.8", "host.review.invalid"],
+ "review selectors precede exact and wildcard allows; ordinary allows and denies skip the decider"
);
}
Ok(())
diff --git a/codex-rs/network-proxy/src/remote_config.rs b/codex-rs/network-proxy/src/remote_config.rs
index 4b00da931f..b5f203425c 100644
--- a/codex-rs/network-proxy/src/remote_config.rs
+++ b/codex-rs/network-proxy/src/remote_config.rs
@@ -184,6 +184,9 @@ pub struct RemoteNetworkProxyConfig {
pub dangerously_allow_all_unix_sockets: bool,
pub mode: NetworkMode,
pub domains: Option<NetworkDomainPermissions>,
+ /// Clients must require the `networkProxyReviewDomains` executor capability when nonempty.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub review_domains: Vec<String>,
pub unix_sockets: Option<NetworkUnixSocketPermissions>,
pub allow_local_binding: bool,
}
@@ -210,6 +213,7 @@ impl RemoteNetworkProxyConfig {
.unwrap_or(false),
mode: config.mode,
domains: config.domains.clone(),
+ review_domains: config.review_domains.clone(),
unix_sockets: config.unix_sockets.clone(),
allow_local_binding: config.allow_local_binding(),
})
@@ -240,6 +244,7 @@ impl RemoteNetworkProxyConfig {
dangerously_allow_all_unix_sockets: Some(self.dangerously_allow_all_unix_sockets),
mode: self.mode,
domains: self.domains,
+ review_domains: self.review_domains,
unix_sockets: self.unix_sockets,
allow_local_binding: Some(self.allow_local_binding),
..NetworkProxyConfig::default()
diff --git a/codex-rs/network-proxy/src/remote_config_tests.rs b/codex-rs/network-proxy/src/remote_config_tests.rs
index ec327bb902..332d8a99c0 100644
--- a/codex-rs/network-proxy/src/remote_config_tests.rs
+++ b/codex-rs/network-proxy/src/remote_config_tests.rs
@@ -65,6 +65,7 @@ async fn round_trip_preserves_supported_effective_settings() {
dangerously_allow_all_unix_sockets: Some(true),
mode: NetworkMode::Limited,
allow_local_binding: Some(true),
+ review_domains: vec!["review.example.com".to_string()],
..NetworkProxyConfig::default()
};
// Domain permissions serialize as a sorted map.
diff --git a/codex-rs/network-proxy/src/runtime.rs b/codex-rs/network-proxy/src/runtime.rs
index c70c4dc39c..cd09549cb4 100644
--- a/codex-rs/network-proxy/src/runtime.rs
+++ b/codex-rs/network-proxy/src/runtime.rs
@@ -181,6 +181,7 @@ pub struct ConfigState {
pub(crate) brokerage_created_default_allowlist: bool,
pub allow_set: DomainPatternSet,
pub deny_set: DomainPatternSet,
+ pub review_set: DomainPatternSet,
pub mitm: Option<Arc<MitmState>>,
pub mitm_hooks: MitmHooksByHost,
pub constraints: NetworkProxyConstraints,
@@ -816,11 +817,12 @@ impl NetworkProxyState {
Ok(host) => host,
Err(_) => return Ok(HostBlockDecision::Blocked(HostBlockReason::NotAllowed)),
};
- let (deny_set, allow_set, allow_local_binding, allowed_domains) = {
+ let (deny_set, review_set, allow_set, allow_local_binding, allowed_domains) = {
let guard = self.state.read().await;
let allowed_domains = guard.config.allowed_domains();
(
guard.deny_set.clone(),
+ guard.review_set.clone(),
guard.allow_set.clone(),
// Keep explicit controller restrictions even if the executor launched with true.
allow_local_binding
@@ -836,13 +838,15 @@ impl NetworkProxyState {
// Decision order matters:
// 1) explicit deny always wins
// 2) local/private networking is opt-in (defense-in-depth)
- // 3) DNS requires an allowlist match or an approval
+ // 3) managed review selectors precede every ordinary allow rule
+ // 4) DNS requires an allowlist match or an approval
if domains_match_host_or_unscoped(&deny_set, host_str) {
return Ok(HostBlockDecision::Blocked(HostBlockReason::Denied));
}
let is_authorized = authorization == HostAuthorization::Approved
- || domains_match_host_or_unscoped(&allow_set, host_str);
+ || (!domains_match_host_or_unscoped(&review_set, host_str)
+ && domains_match_host_or_unscoped(&allow_set, host_str));
if !allow_local_binding {
// If the intent is "prevent access to local/internal networks", we must not rely solely
// on string checks like `localhost` / `127.0.0.1`. Attackers can use DNS rebinding or
@@ -1381,6 +1385,7 @@ pub(crate) fn network_proxy_state_for_policy(
constraints: NetworkProxyConstraints::default(),
deny_set: crate::policy::compile_denylist(&config.denied_domains().unwrap_or_default())
.unwrap(),
+ review_set: crate::policy::compile_allowlist(&config.review_domains).unwrap(),
mitm: None,
mitm_hooks: crate::mitm_hook::compile_mitm_hooks(&config).unwrap(),
config,
diff --git a/codex-rs/network-proxy/src/state.rs b/codex-rs/network-proxy/src/state.rs
index b31367170e..262b7270c2 100644
--- a/codex-rs/network-proxy/src/state.rs
+++ b/codex-rs/network-proxy/src/state.rs
@@ -92,6 +92,7 @@ pub fn build_config_state(
.map_err(NetworkProxyConstraintError::into_anyhow)?;
let deny_set = compile_denylist(&denied_domains)?;
let allow_set = compile_allowlist(&allowed_domains)?;
+ let review_set = compile_allowlist(&config.review_domains)?;
let mitm_hooks = compile_mitm_hooks(&config)?;
let mitm = if config.mitm {
Some(Arc::new(MitmState::new(MitmUpstreamConfig {
@@ -107,6 +108,7 @@ pub fn build_config_state(
brokerage_created_default_allowlist,
allow_set,
deny_set,
+ review_set,
mitm,
mitm_hooks,
constraints,
diff --git a/codex-rs/tui/src/debug_config.rs b/codex-rs/tui/src/debug_config.rs
index 70eb6042b0..01a7802d06 100644
--- a/codex-rs/tui/src/debug_config.rs
+++ b/codex-rs/tui/src/debug_config.rs
@@ -557,6 +557,7 @@ fn format_network_constraints(network: &NetworkConstraints) -> String {
dangerously_allow_non_loopback_proxy,
dangerously_allow_all_unix_sockets,
domains,
+ review_domains,
managed_allowed_domains_only,
unix_sockets,
allow_local_binding,
@@ -591,6 +592,9 @@ fn format_network_constraints(network: &NetworkConstraints) -> String {
format_network_permission_entries(&domains.entries, format_network_domain_permission)
));
}
+ if let Some(review_domains) = review_domains {
+ parts.push(format!("review_domains={{{}}}", review_domains.join(", ")));
+ }
if let Some(managed_allowed_domains_only) = managed_allowed_domains_only {
parts.push(format!(
"managed_allowed_domains_only={managed_allowed_domains_only}"
@@ -917,6 +921,7 @@ interrupt_message = false
NetworkDomainPermissionToml::Allow,
)]),
}),
+ review_domains: Some(vec!["api.example.com".to_string()]),
header_injections: Some(vec![NetworkHeaderInjectionToml {
host: "api.example.com".to_string(),
methods: vec!["POST".to_string()],
@@ -1065,7 +1070,7 @@ interrupt_message = false
"enforce_residency: us (source: {requirements_source})"
)));
assert!(rendered.contains(&format!(
- "experimental_network: enabled=true, domains={{example.com=allow}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})"
+ "experimental_network: enabled=true, domains={{example.com=allow}}, review_domains={{api.example.com}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})"
)));
assert!(!rendered.contains("secret-looking-value"));
assert!(
diff --git a/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap b/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap
index 7d4455cb1c..64120d4aed 100644
--- a/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap
+++ b/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap
@@ -25,5 +25,5 @@ Requirements:
- features: guardian_approval=true (source: MDM managed_config.toml (legacy))
- mcp_servers: docs (source: MDM managed_config.toml (legacy))
- enforce_residency: us (source: MDM managed_config.toml (legacy))
- - experimental_network: enabled=true, domains={example.com=allow}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy))
+ - experimental_network: enabled=true, domains={example.com=allow}, review_domains={api.example.com}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy))
- permissions.filesystem.deny_read: /home/alice/.gitconfig (source: /etc/codex/requirements.toml)
diff --git a/sdk/python/src/openai_codex/generated/v2_all.py b/sdk/python/src/openai_codex/generated/v2_all.py
index 1c9d500670..4ea7e766aa 100644
--- a/sdk/python/src/openai_codex/generated/v2_all.py
+++ b/sdk/python/src/openai_codex/generated/v2_all.py
@@ -3001,6 +3001,13 @@ class NetworkRequirements(BaseModel):
description="When true, only managed allowlist entries are respected while managed network enforcement is active.",
),
] = None
+ review_domains: Annotated[
+ list[str] | None,
+ Field(
+ alias="reviewDomains",
+ description="Host patterns routed to network approval before ordinary allow rules.",
+ ),
+ ] = None
socks_port: Annotated[int | None, Field(alias="socksPort", ge=0)] = None
unix_sockets: Annotated[
dict[str, Any] | None,