mirror of
https://github.com/openai/codex.git
synced 2026-11-21 22:50:37 +00:00
Compose managed domain rules across network config layers (#62882)
## Why Managed requirements from different sources could not be combined when one used `[permissions.network]` and another used `[network_proxy]` or `[experimental_network]`. ## What changed Allow these tables to compose across sources. The highest-priority list of each kind replaces lower lists of that kind, while keyed `domains` entries update individual selectors by source priority. A deny wins when a selector appears in both surviving lists. A surviving `allowed_domains = []` clears lower-priority grants, while an empty `domains` map contributes no updates. Require mirrored domain declarations to agree on how they compose with other domain sources. Unix socket path rules still require a single network table spelling across sources. Carry equivalent denied selector spellings into the effective proxy policy. When local binding is disabled, an attached executor's explicit local grant must also satisfy the controller's allowlist constraints. The standalone proxy can still narrow a wildcard to an explicit local grant. ## Testing Cover mixed table spellings, list replacement and clearing, conflicting mirrors, equivalent IPv6 spellings, and local grants in standalone and attached proxy modes. GitOrigin-RevId: b3d550d9f462564c89663ea4b15e723f0ea76881
This commit is contained in:
@@ -417,7 +417,16 @@ enabled = true
|
||||
|
||||
Codex reads `[network_proxy]` and its alias `[experimental_network]` as
|
||||
`[permissions.network]` within each source before merging managed requirements.
|
||||
Across sources, use the same surface (legacy or nested). Use at most one top-level spelling per layer.
|
||||
Choose the merge operation with the domain syntax under either table name:
|
||||
`allowed_domains` and `denied_domains` each replace the previous list of that kind.
|
||||
A host in both surviving lists is denied, including when a keyed grant appears between the lists. Use `[permissions.network.domains]` (or
|
||||
the legacy table's `domains` map) for per-host updates. Source priority decides
|
||||
a shared selector; unrelated keyed rules survive a nonempty list replacement.
|
||||
A surviving `allowed_domains = []` clears lower managed grants. An empty domain
|
||||
map contributes no updates. Neither operation changes `managed_allowed_domains_only`.
|
||||
When layering mirrored declarations, use the same domain operation in both copies.
|
||||
Use the same network table spelling across sources when specifying Unix socket paths.
|
||||
Use at most one top-level spelling per layer.
|
||||
If a layer also sets `[permissions.network]`, both tables must describe the same policy.
|
||||
`configRequirements/read` returns the result in `requirements.network`.
|
||||
|
||||
|
||||
@@ -14,20 +14,14 @@ fn cloud_validation_checks_network_spellings_per_fragment() {
|
||||
let conflicting = format!("[{alias}]\nenabled = true");
|
||||
for (contents, expected) in [
|
||||
(vec![format!("{nested}\n{top_level}")], Ok(())),
|
||||
(
|
||||
vec![nested.to_owned(), conflicting.clone()],
|
||||
Err(CloudConfigBundleLoadErrorCode::InvalidBundle),
|
||||
),
|
||||
(
|
||||
vec![conflicting.clone(), nested.to_owned()],
|
||||
Err(CloudConfigBundleLoadErrorCode::InvalidBundle),
|
||||
),
|
||||
(vec![nested.to_owned(), conflicting.clone()], Ok(())),
|
||||
(vec![conflicting.clone(), nested.to_owned()], Ok(())),
|
||||
(
|
||||
vec![
|
||||
"[permissions.network]\ndenied_domains = ['shared.test']".to_string(),
|
||||
format!("[{alias}]\nallowed_domains = ['shared.test']"),
|
||||
],
|
||||
Err(CloudConfigBundleLoadErrorCode::InvalidBundle),
|
||||
Ok(()),
|
||||
),
|
||||
(
|
||||
vec![format!(
|
||||
|
||||
@@ -393,14 +393,17 @@ pub enum NetworkDomainPermissionToml {
|
||||
}
|
||||
|
||||
impl NetworkDomainPermissionToml {
|
||||
/// Unsupported patterns retain their exact spelling. They can never compare equal
|
||||
/// to a valid selector and disappear when two published declarations are combined.
|
||||
pub(crate) fn pattern_identity(self, pattern: &str) -> Result<String, String> {
|
||||
pub(crate) fn canonical_pattern(self, pattern: &str) -> anyhow::Result<String> {
|
||||
match self {
|
||||
Self::Allow => codex_network_proxy::canonical_allow_pattern(pattern),
|
||||
Self::Deny => codex_network_proxy::canonical_deny_pattern(pattern),
|
||||
}
|
||||
.map_err(|_| pattern.to_owned())
|
||||
}
|
||||
|
||||
/// Unsupported patterns compare only by their exact spelling.
|
||||
pub(crate) fn pattern_identity(self, pattern: &str) -> Result<String, String> {
|
||||
self.canonical_pattern(pattern)
|
||||
.map_err(|_| pattern.to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -473,6 +476,16 @@ pub struct NetworkRequirementsToml {
|
||||
}
|
||||
|
||||
impl NetworkRequirementsToml {
|
||||
pub(crate) fn validate_domain_patterns(&self) -> anyhow::Result<()> {
|
||||
for (pattern, rule) in self.domains.iter().flat_map(|domains| &domains.entries) {
|
||||
rule.canonical_pattern(pattern)?;
|
||||
}
|
||||
for pattern in self.review_domains.iter().flatten() {
|
||||
codex_network_proxy::canonical_review_pattern(pattern)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Compare the selector identities used by the proxy without modifying the published
|
||||
/// representation. Keep allow and deny contributions distinct, including shadowed grants.
|
||||
pub(crate) fn describes_same_policy(&self, other: &Self) -> bool {
|
||||
@@ -612,9 +625,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {
|
||||
}
|
||||
}
|
||||
|
||||
/// Legacy list normalization is intentionally lossy: explicit empty legacy
|
||||
/// lists are treated as unset when converted to the canonical network
|
||||
/// permission shape.
|
||||
/// Empty legacy domain lists contribute no keyed rules.
|
||||
fn legacy_domain_permissions_from_lists(
|
||||
allowed_domains: Option<Vec<String>>,
|
||||
denied_domains: Option<Vec<String>>,
|
||||
|
||||
@@ -1,9 +1,16 @@
|
||||
//! Read compatible spellings of the shared network policy and preserve source attribution.
|
||||
//! Compose managed network policy in source order. Lists replace like-named
|
||||
//! lists; keyed domain rules update individual selectors under either spelling.
|
||||
|
||||
use crate::NetworkDomainPermissionToml::Allow;
|
||||
use crate::NetworkDomainPermissionToml::Deny;
|
||||
use crate::NetworkDomainPermissionsToml;
|
||||
use crate::NetworkRequirementsToml;
|
||||
use crate::RequirementSource;
|
||||
use crate::Sourced;
|
||||
use crate::merge::merge_toml_values;
|
||||
use std::collections::BTreeMap;
|
||||
use std::collections::BTreeSet;
|
||||
use std::net::Ipv6Addr;
|
||||
use toml::Value;
|
||||
|
||||
use super::layer::ComposableRequirementsLayer;
|
||||
@@ -11,68 +18,306 @@ use super::layer::remove_nested_field_and_prune_empty;
|
||||
use super::layer::remove_top_level_field;
|
||||
use super::stack::RequirementsCompositionError;
|
||||
|
||||
/// Fold each validated source's network table before the regular merge. The
|
||||
/// submitted TOML distinguishes empty replacement lists from omitted lists.
|
||||
const ALLOWS: &str = "allowed_domains";
|
||||
const DENIES: &str = "denied_domains";
|
||||
|
||||
fn take_domains(table: &mut toml::Table) -> toml::Table {
|
||||
[ALLOWS, DENIES, "domains"]
|
||||
.into_iter()
|
||||
.filter_map(|field| Some((field.to_owned(), table.remove(field)?)))
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn parse(
|
||||
value: Value,
|
||||
source: &RequirementSource,
|
||||
) -> Result<NetworkRequirementsToml, RequirementsCompositionError> {
|
||||
value
|
||||
.try_into()
|
||||
.map_err(|err: toml::de::Error| RequirementsCompositionError::Parse {
|
||||
layer_source: source.clone(),
|
||||
message: err.to_string(),
|
||||
})
|
||||
}
|
||||
|
||||
fn empty_list(fields: &toml::Table, key: &str) -> bool {
|
||||
fields
|
||||
.get(key)
|
||||
.and_then(Value::as_array)
|
||||
.is_some_and(Vec::is_empty)
|
||||
}
|
||||
|
||||
/// Same-file mirrors already agree as standalone policies. When layered, an
|
||||
/// omitted list, an empty replacement, and a per-host update are distinct.
|
||||
fn same_domain_operation(left: &toml::Table, right: &toml::Table) -> bool {
|
||||
if left == right || (left.contains_key("domains") && right.contains_key("domains")) {
|
||||
return true;
|
||||
}
|
||||
if left.contains_key("domains") || right.contains_key("domains") {
|
||||
return false;
|
||||
}
|
||||
[(ALLOWS, Allow), (DENIES, Deny)]
|
||||
.into_iter()
|
||||
.all(|(key, rule)| {
|
||||
let identities = |fields: &toml::Table| {
|
||||
fields.get(key).and_then(Value::as_array).map(|list| {
|
||||
list.iter()
|
||||
.filter_map(Value::as_str)
|
||||
.map(|pattern| rule.pattern_identity(pattern))
|
||||
.collect::<BTreeSet<_>>()
|
||||
})
|
||||
};
|
||||
identities(left) == identities(right)
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn compose(
|
||||
layers: &mut [ComposableRequirementsLayer],
|
||||
) -> Result<Option<Box<Sourced<NetworkRequirementsToml>>>, RequirementsCompositionError> {
|
||||
let mut merged = Value::Table(toml::Table::new());
|
||||
let mut sources = Vec::new();
|
||||
let mut inputs = Vec::new();
|
||||
let mut nested_inputs = None;
|
||||
let mut ambiguous_mirror = None;
|
||||
let mut has_empty_map = false;
|
||||
let mut has_legacy = false;
|
||||
let mut has_nested = false;
|
||||
let mut has_socket_paths = false;
|
||||
for layer in layers {
|
||||
let regular_toml = &mut layer.regular_toml;
|
||||
let legacy = remove_top_level_field(regular_toml, "network_proxy")
|
||||
.or_else(|| remove_top_level_field(regular_toml, "experimental_network"));
|
||||
let nested = remove_nested_field_and_prune_empty(regular_toml, &["permissions", "network"]);
|
||||
let raw = &mut layer.regular_toml;
|
||||
let legacy = remove_top_level_field(raw, "network_proxy")
|
||||
.or_else(|| remove_top_level_field(raw, "experimental_network"));
|
||||
let nested = remove_nested_field_and_prune_empty(raw, &["permissions", "network"]);
|
||||
has_legacy |= legacy.is_some();
|
||||
has_nested |= nested.is_some();
|
||||
let value = match (legacy, nested) {
|
||||
(Some(Value::Table(legacy)), Some(Value::Table(nested))) => {
|
||||
// The effective rules already agree. A deny can shadow an allow,
|
||||
// but an explicit empty allowlist clears inherited allows.
|
||||
if let (Some(left), Some(right)) = (
|
||||
legacy.get("allowed_domains").and_then(Value::as_array),
|
||||
nested.get("allowed_domains").and_then(Value::as_array),
|
||||
) && left.is_empty() != right.is_empty()
|
||||
{
|
||||
return Err(RequirementsCompositionError::Parse {
|
||||
layer_source: layer.source.clone(),
|
||||
message: "legacy and permissions.network requirements specify different allowed_domains replacements".into(),
|
||||
});
|
||||
}
|
||||
// Keep the legacy spelling for the executor.
|
||||
Value::Table(legacy)
|
||||
}
|
||||
(Some(value), None) | (None, Some(value)) => value,
|
||||
let (mut table, mirror) = match (legacy, nested) {
|
||||
(Some(Value::Table(table)), Some(Value::Table(mirror))) => (table, Some(mirror)),
|
||||
(Some(Value::Table(table)), None) | (None, Some(Value::Table(table))) => (table, None),
|
||||
(None, None) => continue,
|
||||
(Some(_), Some(_)) => {
|
||||
_ => {
|
||||
return Err(RequirementsCompositionError::Parse {
|
||||
layer_source: layer.source.clone(),
|
||||
message: "shared network requirements must be tables".into(),
|
||||
message: "network requirements must be tables".into(),
|
||||
});
|
||||
}
|
||||
};
|
||||
has_socket_paths |= std::iter::once(&table)
|
||||
.chain(mirror.as_ref())
|
||||
.any(|network| {
|
||||
network.contains_key("unix_sockets") || network.contains_key("allow_unix_sockets")
|
||||
});
|
||||
let mut fields = take_domains(&mut table);
|
||||
let mut alternative = None;
|
||||
if let Some(mut mirror) = mirror {
|
||||
let other = take_domains(&mut mirror);
|
||||
if fields.contains_key(ALLOWS)
|
||||
&& other.contains_key(ALLOWS)
|
||||
&& empty_list(&fields, ALLOWS) != empty_list(&other, ALLOWS)
|
||||
{
|
||||
return Err(RequirementsCompositionError::Parse {
|
||||
layer_source: layer.source.clone(),
|
||||
message: "legacy and permissions.network requirements specify different allowed_domains replacements".into(),
|
||||
});
|
||||
}
|
||||
if empty_list(&fields, ALLOWS) != empty_list(&other, ALLOWS)
|
||||
|| empty_list(&fields, DENIES) != empty_list(&other, DENIES)
|
||||
|| (!fields.is_empty()
|
||||
&& !other.is_empty()
|
||||
&& !same_domain_operation(&fields, &other))
|
||||
{
|
||||
ambiguous_mirror = Some(layer.source.clone());
|
||||
}
|
||||
if fields.is_empty() {
|
||||
fields = other;
|
||||
} else if !other.is_empty() && fields != other {
|
||||
nested_inputs.get_or_insert_with(|| inputs.clone());
|
||||
alternative = Some(other);
|
||||
}
|
||||
}
|
||||
if fields
|
||||
.get("domains")
|
||||
.and_then(Value::as_table)
|
||||
.is_some_and(toml::Table::is_empty)
|
||||
{
|
||||
has_empty_map = true;
|
||||
} else if !fields.is_empty() {
|
||||
if let Some(nested) = &mut nested_inputs {
|
||||
nested.push((
|
||||
layer.source.clone(),
|
||||
alternative.unwrap_or_else(|| fields.clone()),
|
||||
));
|
||||
}
|
||||
inputs.push((layer.source.clone(), fields));
|
||||
}
|
||||
sources.push(layer.source.clone());
|
||||
merge_toml_values(&mut merged, &value);
|
||||
merge_toml_values(&mut merged, &Value::Table(table));
|
||||
}
|
||||
if sources.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
// Until list composition can preserve competing replacements, require
|
||||
// multiple contributing sources to use the same surface.
|
||||
let mixed_sources = sources.len() > 1 && has_legacy && has_nested;
|
||||
let mixed = sources.len() > 1 && has_legacy && has_nested;
|
||||
let source = RequirementSource::composite(sources.into_iter().rev());
|
||||
if mixed_sources {
|
||||
if mixed && has_socket_paths {
|
||||
return Err(RequirementsCompositionError::Parse {
|
||||
layer_source: source,
|
||||
message: "mixed legacy and permissions.network requirements".to_string(),
|
||||
message:
|
||||
"Unix socket path rules across sources require a single network table spelling"
|
||||
.into(),
|
||||
});
|
||||
}
|
||||
let value = merged.try_into().map_err(|err: toml::de::Error| {
|
||||
RequirementsCompositionError::ComposedParse {
|
||||
message: err.to_string(),
|
||||
if inputs.len() > 1
|
||||
&& let Some(layer_source) = ambiguous_mirror
|
||||
{
|
||||
return Err(RequirementsCompositionError::Parse {
|
||||
layer_source,
|
||||
message: "mirrored network domain rules must use the same list replacements or per-host updates when composed with another domain source".into(),
|
||||
});
|
||||
}
|
||||
let mut value = parse(merged, &source)?;
|
||||
value.domains = compose_domains(inputs, has_empty_map, &source)?;
|
||||
if let Some(nested) = nested_inputs.filter(|inputs| inputs.len() > 1) {
|
||||
// Different raw keys in a mirror can change which rules survive replacement.
|
||||
let restrictions = |domains: &Option<NetworkDomainPermissionsToml>| {
|
||||
let entries = domains.iter().flat_map(|domains| &domains.entries);
|
||||
let has_allowlist = entries.clone().any(|(_, &rule)| rule == Allow);
|
||||
let denials = entries
|
||||
.filter(|(_, rule)| **rule == Deny)
|
||||
.map(|(pattern, rule)| rule.pattern_identity(pattern))
|
||||
.collect::<BTreeSet<_>>();
|
||||
(has_allowlist, denials)
|
||||
};
|
||||
if restrictions(&compose_domains(nested, has_empty_map, &source)?)
|
||||
!= restrictions(&value.domains)
|
||||
{
|
||||
return Err(RequirementsCompositionError::Parse {
|
||||
layer_source: source,
|
||||
message: "mirrored network domain rules disagree after layer composition".into(),
|
||||
});
|
||||
}
|
||||
})?;
|
||||
}
|
||||
if mixed {
|
||||
value
|
||||
.validate_domain_patterns()
|
||||
.map_err(|err| RequirementsCompositionError::Parse {
|
||||
layer_source: source.clone(),
|
||||
message: err.to_string(),
|
||||
})?;
|
||||
}
|
||||
Ok(Some(Box::new(Sourced::new(value, source))))
|
||||
}
|
||||
|
||||
/// Only the last list of each kind participates. Keyed sources retain their
|
||||
/// position relative to those two replacements, including a surviving clear.
|
||||
fn compose_domains(
|
||||
inputs: Vec<(RequirementSource, toml::Table)>,
|
||||
has_empty_map: bool,
|
||||
source: &RequirementSource,
|
||||
) -> Result<Option<NetworkDomainPermissionsToml>, RequirementsCompositionError> {
|
||||
let last_allow = inputs
|
||||
.iter()
|
||||
.rposition(|(_, fields)| fields.contains_key(ALLOWS));
|
||||
let last_deny = inputs
|
||||
.iter()
|
||||
.rposition(|(_, fields)| fields.contains_key(DENIES));
|
||||
let clear = last_allow.filter(|&i| empty_list(&inputs[i].1, ALLOWS));
|
||||
let effective = if inputs.len() < 2
|
||||
|| !inputs
|
||||
.iter()
|
||||
.any(|(_, fields)| fields.contains_key("domains"))
|
||||
{
|
||||
// The normal parser handles list replacement and overlapping allow/deny
|
||||
// lists, including policies from clients predating keyed domains.
|
||||
let mut fields = toml::Table::new();
|
||||
for (_, input) in inputs {
|
||||
fields.extend(input);
|
||||
}
|
||||
parse(Value::Table(fields), source)?.domains
|
||||
} else {
|
||||
let mut domains: BTreeMap<String, BTreeMap<String, _>> = BTreeMap::new();
|
||||
let mut list_denials: BTreeMap<String, Vec<String>> = BTreeMap::new();
|
||||
let mut keyed_denials: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
|
||||
let mut published: BTreeMap<String, BTreeMap<String, _>> = BTreeMap::new();
|
||||
for (i, (source, mut fields)) in inputs.into_iter().enumerate() {
|
||||
if Some(i) != last_allow {
|
||||
fields.remove(ALLOWS);
|
||||
}
|
||||
if Some(i) != last_deny {
|
||||
fields.remove(DENIES);
|
||||
}
|
||||
let lists = !fields.contains_key("domains");
|
||||
let rules = parse(Value::Table(fields), &source)?
|
||||
.domains
|
||||
.unwrap_or_default();
|
||||
let mut updates: BTreeMap<String, BTreeMap<String, _>> = BTreeMap::new();
|
||||
for (pattern, rule) in rules.entries {
|
||||
let selector = match rule {
|
||||
Allow => codex_network_proxy::canonical_review_pattern(&pattern),
|
||||
Deny => codex_network_proxy::canonical_deny_pattern(&pattern),
|
||||
}
|
||||
.map_err(|err| RequirementsCompositionError::Parse {
|
||||
layer_source: source.clone(),
|
||||
message: err.to_string(),
|
||||
})?;
|
||||
if rule == Allow && clear.is_some_and(|clear| i < clear) {
|
||||
continue;
|
||||
}
|
||||
// A map replaces a denial only by its exact TOML key. A list
|
||||
// updating this selector supersedes the previous map entries.
|
||||
if lists {
|
||||
keyed_denials.remove(&selector);
|
||||
if rule == Deny {
|
||||
list_denials
|
||||
.entry(selector.clone())
|
||||
.or_default()
|
||||
.push(pattern.clone());
|
||||
}
|
||||
} else if rule == Deny {
|
||||
keyed_denials
|
||||
.entry(selector.clone())
|
||||
.or_default()
|
||||
.insert(pattern.clone());
|
||||
} else if let Some(denials) = keyed_denials.get_mut(&selector) {
|
||||
denials.remove(&pattern);
|
||||
}
|
||||
updates.entry(selector).or_default().insert(pattern, rule);
|
||||
}
|
||||
for (selector, mut entries) in updates {
|
||||
// A surviving deny list still wins when a later allow list names
|
||||
// the host, even if a keyed grant was published between the lists.
|
||||
if lists && let Some(denials) = list_denials.get(&selector) {
|
||||
entries.extend(denials.iter().cloned().map(|pattern| (pattern, Deny)));
|
||||
}
|
||||
let spellings = published.entry(selector.clone()).or_default();
|
||||
spellings.extend(entries.clone());
|
||||
if entries.values().any(|&rule| rule == Deny) {
|
||||
// A shadowed grant still pins the managed allowlist for a profile
|
||||
// that forbids user additions. Preserve the raw keys the parser kept.
|
||||
entries.clone_from(spellings);
|
||||
} else if let Ok(ip) = selector.parse::<Ipv6Addr>()
|
||||
&& let Some(inherited) = domains.remove(&selector)
|
||||
&& inherited.values().all(|&rule| rule == Allow)
|
||||
{
|
||||
// The proxy matches IPv6 grants as text. Apply a higher wildcard
|
||||
// port to inherited spellings to revoke their local-binding exception.
|
||||
let wildcard_port = codex_network_proxy::is_non_public_ip(ip.into())
|
||||
&& entries.keys().any(|pattern| pattern.contains(['*', '?']));
|
||||
for mut pattern in inherited.into_keys() {
|
||||
if wildcard_port {
|
||||
let host = codex_network_proxy::normalize_host(&pattern);
|
||||
pattern = format!("[{host}]:*");
|
||||
}
|
||||
entries.insert(pattern, Allow);
|
||||
}
|
||||
}
|
||||
domains.insert(selector, entries);
|
||||
}
|
||||
}
|
||||
let mut entries: BTreeMap<_, _> = domains.into_values().flatten().collect();
|
||||
for pattern in keyed_denials.into_values().flatten() {
|
||||
entries.insert(pattern, Deny);
|
||||
}
|
||||
Some(NetworkDomainPermissionsToml { entries })
|
||||
};
|
||||
Ok(effective
|
||||
.or_else(|| (clear.is_some() || has_empty_map).then(NetworkDomainPermissionsToml::default)))
|
||||
}
|
||||
|
||||
@@ -891,6 +891,7 @@ fn network_maps_use_regular_toml_merge() {
|
||||
"example.com" = "deny"
|
||||
"low.example.com" = "deny"
|
||||
"internal.example.com" = "allow"
|
||||
"PROTECTED.TEST." = "deny"
|
||||
|
||||
[experimental_network.unix_sockets]
|
||||
"/tmp/shared.sock" = "deny"
|
||||
@@ -906,6 +907,7 @@ fn network_maps_use_regular_toml_merge() {
|
||||
"example.com" = "allow"
|
||||
"high.example.com" = "allow"
|
||||
"internal.example.com" = "deny"
|
||||
"protected.test" = "allow"
|
||||
|
||||
[experimental_network.unix_sockets]
|
||||
"/tmp/shared.sock" = "allow"
|
||||
@@ -926,6 +928,8 @@ fn network_maps_use_regular_toml_merge() {
|
||||
"high.example.com" = "allow"
|
||||
"internal.example.com" = "deny"
|
||||
"low.example.com" = "deny"
|
||||
"PROTECTED.TEST." = "deny"
|
||||
"protected.test" = "allow"
|
||||
|
||||
[permissions.network.unix_sockets]
|
||||
"/tmp/admin.sock" = "deny"
|
||||
@@ -989,28 +993,124 @@ fn network_aliases_merge_with_layer_precedence_and_sources() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn permissions_network_conflicts_with_top_level_network_across_layers() {
|
||||
for table in ["network_proxy", "experimental_network"] {
|
||||
for (root_first, root_values) in [(true, "enabled = true"), (false, "")] {
|
||||
let root = layer("root", "Root", &format!("[{table}]\n{root_values}"));
|
||||
let permissions = layer(
|
||||
"permissions",
|
||||
"Permissions",
|
||||
"[permissions.network]\nenabled = true",
|
||||
);
|
||||
let root_source = root.source.clone();
|
||||
let permissions_source = permissions.source.clone();
|
||||
let layers = if root_first {
|
||||
vec![root, permissions]
|
||||
} else {
|
||||
vec![permissions, root]
|
||||
};
|
||||
let err = compose_requirements_for_hostname(layers, /*hostname*/ None)
|
||||
.expect_err("network requirement surfaces must not coexist")
|
||||
.to_string();
|
||||
assert!(err.contains(&root_source.to_string()), "{err}");
|
||||
assert!(err.contains(&permissions_source.to_string()), "{err}");
|
||||
}
|
||||
fn list_replacements_preserve_unrelated_keyed_hosts() {
|
||||
let old = "allowed_domains = ['old.test']\ndenied_domains = ['retired.test']";
|
||||
let mirror = format!("[network_proxy]\n{old}\n[permissions.network]\n{old}");
|
||||
let cloud = "[permissions.network]\ndangerously_allow_all_unix_sockets = true";
|
||||
let device =
|
||||
"[experimental_network]\nallowed_domains = ['new.test']\ndenied_domains = ['shared.test']";
|
||||
for (domains, allowed) in [
|
||||
("{}", "['new.test']"),
|
||||
(
|
||||
"{ 'cloud.test' = 'allow', 'shared.test' = 'allow', 'NEW.TEST.' = 'deny' }",
|
||||
"['cloud.test', 'new.test']",
|
||||
),
|
||||
] {
|
||||
let update = format!("{cloud}\ndomains = {domains}");
|
||||
let merged = compose(vec![
|
||||
layer("old", "Old", &mirror),
|
||||
layer("cloud", "Cloud", &update),
|
||||
layer("device", "Device", device),
|
||||
]);
|
||||
let expected = expected_requirements(format!(
|
||||
"{cloud}\nallowed_domains = {allowed}\ndenied_domains = ['shared.test']"
|
||||
));
|
||||
assert_eq!(merged.unwrap(), Some(expected), "{domains}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_a_surviving_empty_allowlist_clears_keyed_grants() {
|
||||
let deny = "[network_proxy.domains]\n'a.test' = 'deny'";
|
||||
let grant =
|
||||
"[permissions.network.domains]\n'a.test' = 'allow'\n'B.TEST.' = 'allow'\n'b.test' = 'deny'";
|
||||
let clear =
|
||||
"[network_proxy]\nallowed_domains = []\n[permissions.network]\nallowed_domains = []";
|
||||
let mut layers = vec![
|
||||
layer("deny", "Deny", deny),
|
||||
layer("grant", "Grant", grant),
|
||||
layer("clear", "Clear", clear),
|
||||
];
|
||||
let cleared =
|
||||
expected_requirements("[permissions.network]\ndenied_domains = ['a.test', 'b.test']");
|
||||
assert_eq!(compose(layers.clone()).unwrap(), Some(cleared));
|
||||
|
||||
let replacement = "[network_proxy]\nallowed_domains = ['new.test']\ndenied_domains = []";
|
||||
layers.push(layer("replacement", "Replacement", replacement));
|
||||
let replaced = expected_requirements(
|
||||
"[permissions.network]\nallowed_domains = ['a.test', 'B.TEST.', 'new.test']\ndenied_domains = ['b.test']",
|
||||
);
|
||||
assert_eq!(compose(layers).unwrap(), Some(replaced));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wildcard_ports_revoke_local_exceptions_and_respect_the_surviving_deny_list() {
|
||||
let deny = "[network_proxy]\ndenied_domains = ['127.0.0.1']";
|
||||
let grants = "[permissions.network.domains]\n'127.0.0.1' = 'allow'\n'localhost' = 'allow'\n'::1' = 'allow'";
|
||||
let wildcards = "[network_proxy]\nallowed_domains = ['127.0.0.1:*', 'localhost:*', '[::01]:*']";
|
||||
let merged = compose(vec![
|
||||
layer("deny", "Deny", deny),
|
||||
layer("grants", "Grants", grants),
|
||||
layer("wildcards", "Wildcards", wildcards),
|
||||
]);
|
||||
let expected = expected_requirements(
|
||||
"[permissions.network]\nallowed_domains = ['127.0.0.1:*', 'localhost:*', '[::1]:*', '[::01]:*']\ndenied_domains = ['127.0.0.1']",
|
||||
);
|
||||
assert_eq!(merged.unwrap(), Some(expected));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ipv6_grants_and_denials_preserve_published_spellings() {
|
||||
let low = "[network_proxy.domains]\n'2001:db8::1' = 'allow'\n'2001:db8::2' = 'deny'";
|
||||
let grant = "[network_proxy.domains]\n'[2001:db8::2]' = 'allow'";
|
||||
let high = "[permissions.network.domains]\n'2001:0db8::1' = 'allow'\n'2001:0db8::2' = 'deny'";
|
||||
let merged = compose(vec![
|
||||
layer("low", "Low", low),
|
||||
layer("grant", "Grant", grant),
|
||||
layer("high", "High", high),
|
||||
]);
|
||||
let expected = expected_requirements(
|
||||
"[permissions.network]\nallowed_domains = ['2001:db8::1', '2001:0db8::1', '[2001:db8::2]']\ndenied_domains = ['2001:db8::2', '2001:0db8::2']",
|
||||
);
|
||||
assert_eq!(merged.unwrap(), Some(expected));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn layered_mirrors_must_agree_on_replacements_and_the_effective_allowlist() {
|
||||
let policy = "[permissions.network]\nallowed_domains = ['a.test']\ndenied_domains = ['b.test']";
|
||||
let cloud = layer("cloud", "Cloud", policy);
|
||||
for (legacy, nested) in [
|
||||
("", "allowed_domains = []"),
|
||||
("", "denied_domains = []"),
|
||||
("allowed_domains = ['c.test']", "domains.'c.test' = 'allow'"),
|
||||
(
|
||||
"denied_domains = ['a.test']",
|
||||
"denied_domains = ['A.TEST.']",
|
||||
),
|
||||
] {
|
||||
let device = format!("[network_proxy]\n{legacy}\n[permissions.network]\n{nested}");
|
||||
let error =
|
||||
compose(vec![cloud.clone(), layer("device", "Device", &device)]).expect_err(&device);
|
||||
assert!(error.to_string().contains("Device"), "{error}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mixed_network_tables_reject_socket_path_rules() {
|
||||
let cloud = layer("cloud", "Cloud", "[network_proxy]");
|
||||
for device in [
|
||||
"[permissions.network.unix_sockets]\n'/tmp/managed.sock' = 'deny'",
|
||||
"[experimental_network]\n[permissions.network]\nallow_unix_sockets = []",
|
||||
] {
|
||||
let error =
|
||||
compose(vec![cloud.clone(), layer("device", "Device", device)]).expect_err(device);
|
||||
let message = error.to_string();
|
||||
assert!(
|
||||
message.contains("Unix socket path rules")
|
||||
&& message.contains("Device")
|
||||
&& message.contains("Cloud"),
|
||||
"{error}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1058,7 +1158,11 @@ fn network_surfaces_in_one_layer_must_agree() {
|
||||
for fields in ["", "allowed_domains = []", "description = 'device policy'"] {
|
||||
let entry = layer("device", "Device", &format!("[{table}]\n{fields}"));
|
||||
let expected = Sourced::new(
|
||||
crate::NetworkRequirementsToml::default(),
|
||||
crate::NetworkRequirementsToml {
|
||||
domains: (fields == "allowed_domains = []")
|
||||
.then(crate::NetworkDomainPermissionsToml::default),
|
||||
..Default::default()
|
||||
},
|
||||
entry.source.clone(),
|
||||
);
|
||||
assert_eq!(
|
||||
|
||||
@@ -26,6 +26,7 @@ use codex_network_proxy::validate_policy_against_constraints;
|
||||
use codex_protocol::models::PermissionProfile;
|
||||
use codex_protocol::protocol::AskForApproval;
|
||||
use codex_utils_path_uri::Platform;
|
||||
use std::collections::HashSet;
|
||||
use std::net::IpAddr;
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -605,7 +606,20 @@ impl NetworkProxySpec {
|
||||
.domains
|
||||
.as_ref()
|
||||
.and_then(codex_config::NetworkDomainPermissionsToml::denied_domains);
|
||||
if let Some(managed_denied_domains) = managed_denied_domains {
|
||||
if let Some(mut managed_denied_domains) = managed_denied_domains {
|
||||
// The managed allowlist can contain a shadowed spelling of a denied
|
||||
// selector. Explicitly deny that spelling for text-based executors.
|
||||
let denied: HashSet<_> = managed_denied_domains
|
||||
.iter()
|
||||
.filter_map(|pattern| codex_network_proxy::canonical_deny_pattern(pattern).ok())
|
||||
.collect();
|
||||
for pattern in constraints.allowed_domains.iter().flatten() {
|
||||
if codex_network_proxy::canonical_review_pattern(pattern)
|
||||
.is_ok_and(|selector| denied.contains(&selector))
|
||||
{
|
||||
managed_denied_domains.push(pattern.clone());
|
||||
}
|
||||
}
|
||||
let effective_denied_domains = if denylist_expansion_enabled {
|
||||
Self::merge_domain_lists(
|
||||
managed_denied_domains.clone(),
|
||||
|
||||
@@ -767,10 +767,10 @@ fn requirements_denied_domains_are_a_baseline_for_default_mode() {
|
||||
let mut config = NetworkProxyConfig::default();
|
||||
config.set_denied_domains(vec!["blocked.example.com".to_string()]);
|
||||
let requirements = NetworkConstraints {
|
||||
domains: Some(domain_permissions([(
|
||||
"managed-blocked.example.com",
|
||||
NetworkDomainPermissionToml::Deny,
|
||||
)])),
|
||||
domains: Some(domain_permissions([
|
||||
("2001:DB8::1", NetworkDomainPermissionToml::Allow),
|
||||
("2001:0db8::1", NetworkDomainPermissionToml::Deny),
|
||||
])),
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
@@ -784,13 +784,14 @@ fn requirements_denied_domains_are_a_baseline_for_default_mode() {
|
||||
assert_eq!(
|
||||
spec.config.denied_domains(),
|
||||
Some(vec![
|
||||
"managed-blocked.example.com".to_string(),
|
||||
"2001:DB8::1".to_string(),
|
||||
"2001:0db8::1".to_string(),
|
||||
"blocked.example.com".to_string()
|
||||
])
|
||||
);
|
||||
assert_eq!(
|
||||
spec.constraints.denied_domains,
|
||||
Some(vec!["managed-blocked.example.com".to_string()])
|
||||
Some(vec!["2001:0db8::1".to_string(), "2001:DB8::1".to_string()])
|
||||
);
|
||||
assert_eq!(spec.constraints.denylist_expansion_enabled, Some(true));
|
||||
}
|
||||
|
||||
@@ -86,7 +86,10 @@ async fn main() -> Result<()> {
|
||||
let reloader = Arc::new(StaticConfigReloader {
|
||||
state: config_state.clone(),
|
||||
});
|
||||
let state = Arc::new(NetworkProxyState::with_reloader(config_state, reloader));
|
||||
let state = Arc::new(NetworkProxyState::from_standalone_config(
|
||||
config_state,
|
||||
reloader,
|
||||
));
|
||||
NetworkProxy::builder()
|
||||
.state(state)
|
||||
.managed_by_codex(/*managed_by_codex*/ false)
|
||||
|
||||
@@ -285,6 +285,7 @@ pub struct NetworkProxyState {
|
||||
state: Arc<RwLock<ConfigState>>,
|
||||
/// Belongs to this proxy; config retains omission for launches on other executors.
|
||||
pub(crate) local_binding_policy: LocalBindingPolicy,
|
||||
standalone: bool,
|
||||
pub(crate) proxy_private_ips_via_upstream: bool,
|
||||
pub(crate) tcp_upstream_proxy: Option<crate::TcpUpstreamProxy>,
|
||||
reloader: Arc<dyn ConfigReloader>,
|
||||
@@ -327,6 +328,7 @@ impl Clone for NetworkProxyState {
|
||||
Self {
|
||||
state: self.state.clone(),
|
||||
local_binding_policy: self.local_binding_policy,
|
||||
standalone: self.standalone,
|
||||
proxy_private_ips_via_upstream: self.proxy_private_ips_via_upstream,
|
||||
tcp_upstream_proxy: self.tcp_upstream_proxy.clone(),
|
||||
reloader: self.reloader.clone(),
|
||||
@@ -408,6 +410,14 @@ impl NetworkProxyState {
|
||||
Ok(proxy_state)
|
||||
}
|
||||
|
||||
/// A standalone policy may narrow a wildcard ceiling to an explicit local grant.
|
||||
pub fn from_standalone_config(state: ConfigState, reloader: Arc<dyn ConfigReloader>) -> Self {
|
||||
Self {
|
||||
standalone: true,
|
||||
..Self::with_reloader(state, reloader)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_reloader(state: ConfigState, reloader: Arc<dyn ConfigReloader>) -> Self {
|
||||
Self::with_reloader_and_audit_metadata(
|
||||
state,
|
||||
@@ -460,6 +470,7 @@ impl NetworkProxyState {
|
||||
local_aws_signers: Arc::new(std::sync::RwLock::new(state.local_aws_signers())),
|
||||
state: Arc::new(RwLock::new(state)),
|
||||
local_binding_policy,
|
||||
standalone: false,
|
||||
proxy_private_ips_via_upstream: false,
|
||||
tcp_upstream_proxy: None,
|
||||
reloader,
|
||||
@@ -878,9 +889,30 @@ impl NetworkProxyState {
|
||||
Ok(host) => host,
|
||||
Err(_) => return Ok(HostBlockDecision::Blocked(HostBlockReason::NotAllowed)),
|
||||
};
|
||||
let (deny_set, review_set, allow_set, allow_local_binding, allowed_domains) = {
|
||||
let host_str = host.as_str();
|
||||
let local_literal = crate::policy::is_local_literal(host_str);
|
||||
let (deny_set, review_set, allow_set, allow_local_binding, explicit_local_allow) = {
|
||||
let guard = self.state.read().await;
|
||||
let allowed_domains = guard.config.allowed_domains();
|
||||
let explicitly_allows_host =
|
||||
|rules: &[String]| is_explicit_local_allowlisted(rules, &host);
|
||||
// An attached executor can tighten local binding. An explicit local grant
|
||||
// must still be permitted by the controller's fixed allowlist.
|
||||
let standalone_subset = self.standalone
|
||||
&& allow_local_binding.is_none()
|
||||
&& guard.constraints.allowlist_expansion_enabled.is_none();
|
||||
let explicit_local_allow = local_literal
|
||||
&& guard
|
||||
.config
|
||||
.allowed_domains()
|
||||
.as_deref()
|
||||
.is_some_and(explicitly_allows_host)
|
||||
&& (standalone_subset
|
||||
|| guard.constraints.allowlist_expansion_enabled == Some(true)
|
||||
|| guard
|
||||
.constraints
|
||||
.allowed_domains
|
||||
.as_deref()
|
||||
.is_none_or(explicitly_allows_host));
|
||||
(
|
||||
guard.deny_set.clone(),
|
||||
guard.review_set.clone(),
|
||||
@@ -889,12 +921,9 @@ impl NetworkProxyState {
|
||||
allow_local_binding
|
||||
.unwrap_or_else(|| self.local_binding_policy.resolve(&guard.config))
|
||||
&& guard.config.allow_local_binding != Some(false),
|
||||
allowed_domains,
|
||||
explicit_local_allow,
|
||||
)
|
||||
};
|
||||
let allowed_domains = allowed_domains.unwrap_or_default();
|
||||
|
||||
let host_str = host.as_str();
|
||||
|
||||
// Decision order matters:
|
||||
// 1) explicit deny always wins
|
||||
@@ -921,8 +950,8 @@ impl NetworkProxyState {
|
||||
// request. Explicit local/loopback literals are allowed only when explicitly
|
||||
// allowlisted; hostnames that resolve to local/private IPs are blocked even if
|
||||
// allowlisted.
|
||||
if crate::policy::is_local_literal(host_str) {
|
||||
if !is_explicit_local_allowlisted(&allowed_domains, &host) {
|
||||
if local_literal {
|
||||
if !explicit_local_allow {
|
||||
return Ok(HostBlockDecision::Blocked(HostBlockReason::NotAllowedLocal));
|
||||
}
|
||||
} else if is_authorized
|
||||
@@ -1975,6 +2004,51 @@ mod tests {
|
||||
state.host_blocked("localhost", /*port*/ 80).await.unwrap(),
|
||||
HostBlockDecision::Allowed
|
||||
);
|
||||
|
||||
// An attached executor can disable local binding after narrowing a managed wildcard.
|
||||
let config = NetworkProxyConfig {
|
||||
enabled: true,
|
||||
allow_local_binding: Some(true),
|
||||
..network_settings(&["localhost"], &[])
|
||||
};
|
||||
let constraints = NetworkProxyConstraints {
|
||||
allowed_domains: Some(strings(&["**.localhost"])),
|
||||
..Default::default()
|
||||
};
|
||||
let standalone = crate::StaticNetworkProxyConfig {
|
||||
network: NetworkProxyConfig {
|
||||
allow_local_binding: Some(false),
|
||||
..config.clone()
|
||||
},
|
||||
constraints: constraints.clone(),
|
||||
};
|
||||
let standalone = NetworkProxyState::from_standalone_config(
|
||||
standalone.build_state(crate::Platform::native()).unwrap(),
|
||||
Arc::new(NoopReloader),
|
||||
);
|
||||
assert_eq!(
|
||||
standalone
|
||||
.host_blocked("localhost", /*port*/ 80)
|
||||
.await
|
||||
.unwrap(),
|
||||
HostBlockDecision::Allowed
|
||||
);
|
||||
let state = NetworkProxyState::with_reloader(
|
||||
build_config_state(config, constraints, crate::Platform::native()).unwrap(),
|
||||
Arc::new(NoopReloader),
|
||||
);
|
||||
assert_eq!(
|
||||
state
|
||||
.host_blocked_with_local_binding(
|
||||
"localhost",
|
||||
/*port*/ 80,
|
||||
/*allow_local_binding*/ Some(false),
|
||||
HostAuthorization::RequireAllowlist,
|
||||
)
|
||||
.await
|
||||
.unwrap(),
|
||||
HostBlockDecision::Blocked(HostBlockReason::NotAllowedLocal),
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
Reference in New Issue
Block a user