mirror of
https://github.com/openai/codex.git
synced 2026-11-20 22:40:37 +00:00
Add managed network review domains before allow rules (#56154)
## Why Managed network policies need to require approval for selected hosts even when an exact or wildcard allow rule matches them. ## What changed - Add `experimental_network.review_domains` to managed requirements and route matching hosts through the existing network approval flow. Explicit denials retain precedence, and approved connections still undergo DNS and local-address checks. - Preserve review patterns across environment policy attachments and remote proxy configuration. Reject execution on an exec-server that lacks the `networkProxyReviewDomains` capability when review patterns are present. - Expose `reviewDomains` through the app-server requirements API and generated schemas, and show `review_domains` in debug configuration output. - Update approval reasons to say that network access requires approval rather than assuming the host is absent from the allowlist. ## Testing Extend coverage for review precedence over exact and wildcard allows, explicit denials, DNS checks after local and remote approvals, approval hooks, policy merging, remote configuration round trips, and requirements API serialization. GitOrigin-RevId: 4a861061a0ed80b3537d3b72f2caecb0db2a4f0b
This commit is contained in:
+10
@@ -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,
|
||||
|
||||
+10
@@ -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,
|
||||
|
||||
+10
@@ -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,
|
||||
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -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.
|
||||
|
||||
@@ -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>,
|
||||
|
||||
@@ -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"],
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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()?;
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -845,9 +845,31 @@ impl ExecServerClient {
|
||||
}
|
||||
|
||||
pub async fn exec(&self, params: ExecParams) -> Result<ExecResponse, ExecServerError> {
|
||||
self.ensure_network_review_capability(¶ms).await?;
|
||||
self.call(EXEC_METHOD, ¶ms).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(¶ms).await?;
|
||||
let policy_decision_timeout_ms = params
|
||||
.network_proxy
|
||||
.as_ref()
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)));
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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(())
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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!(
|
||||
|
||||
+1
-1
@@ -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)
|
||||
|
||||
@@ -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,
|
||||
|
||||
Reference in New Issue
Block a user