25fa974166
## Summary - treat `requirements.toml` `allowed_domains` and `denied_domains` as managed network baselines for the proxy - in restricted modes by default, build the effective runtime policy from the managed baseline plus user-configured allowlist and denylist entries, so common hosts can be pre-approved without blocking later user expansion - add `experimental_network.managed_allowed_domains_only = true` to pin the effective allowlist to managed entries, ignore user allowlist additions, and hard-deny non-managed domains without prompting - apply `managed_allowed_domains_only` anywhere managed network enforcement is active, including full access, while continuing to respect denied domains from all sources - add regression coverage for merged-baseline behavior, managed-only behavior, and full-access managed-only enforcement ## Behavior Assuming `requirements.toml` defines both `experimental_network.allowed_domains` and `experimental_network.denied_domains`. ### Default mode - By default, the effective allowlist is `experimental_network.allowed_domains` plus user or persisted allowlist additions. - By default, the effective denylist is `experimental_network.denied_domains` plus user or persisted denylist additions. - Allowlist misses can go through the network approval flow. - Explicit denylist hits and local or private-network blocks are still hard-denied. - When `experimental_network.managed_allowed_domains_only = true`, only managed `allowed_domains` are respected, user allowlist additions are ignored, and non-managed domains are hard-denied without prompting. - Denied domains continue to be respected from all sources. ### Full access - With managed requirements present, the effective allowlist is pinned to `experimental_network.allowed_domains`. - With managed requirements present, the effective denylist is pinned to `experimental_network.denied_domains`. - There is no allowlist-miss approval path in full access. - Explicit denylist hits are hard-denied. - `experimental_network.managed_allowed_domains_only = true` now also applies in full access, so managed-only behavior remains in effect anywhere managed network enforcement is active.
406 lines
14 KiB
Rust
406 lines
14 KiB
Rust
use crate::config::NetworkMode;
|
|
use crate::config::NetworkProxyConfig;
|
|
use crate::mitm::MitmState;
|
|
use crate::policy::DomainPattern;
|
|
use crate::policy::compile_globset;
|
|
use crate::policy::is_global_wildcard_domain_pattern;
|
|
use crate::runtime::ConfigState;
|
|
use serde::Deserialize;
|
|
use std::collections::HashSet;
|
|
use std::sync::Arc;
|
|
|
|
pub use crate::runtime::BlockedRequest;
|
|
pub use crate::runtime::BlockedRequestArgs;
|
|
pub use crate::runtime::NetworkProxyAuditMetadata;
|
|
pub use crate::runtime::NetworkProxyState;
|
|
#[cfg(test)]
|
|
pub(crate) use crate::runtime::network_proxy_state_for_policy;
|
|
|
|
#[derive(Debug, Default, Clone, PartialEq, Eq)]
|
|
pub struct NetworkProxyConstraints {
|
|
pub enabled: Option<bool>,
|
|
pub mode: Option<NetworkMode>,
|
|
pub allow_upstream_proxy: Option<bool>,
|
|
pub dangerously_allow_non_loopback_proxy: Option<bool>,
|
|
pub dangerously_allow_all_unix_sockets: Option<bool>,
|
|
pub allowed_domains: Option<Vec<String>>,
|
|
pub allowlist_expansion_enabled: Option<bool>,
|
|
pub denied_domains: Option<Vec<String>>,
|
|
pub denylist_expansion_enabled: Option<bool>,
|
|
pub allow_unix_sockets: Option<Vec<String>>,
|
|
pub allow_local_binding: Option<bool>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize)]
|
|
pub struct PartialNetworkProxyConfig {
|
|
#[serde(default)]
|
|
pub network: PartialNetworkConfig,
|
|
}
|
|
|
|
#[derive(Debug, Default, Clone, Deserialize)]
|
|
pub struct PartialNetworkConfig {
|
|
pub enabled: Option<bool>,
|
|
pub mode: Option<NetworkMode>,
|
|
pub allow_upstream_proxy: Option<bool>,
|
|
pub dangerously_allow_non_loopback_proxy: Option<bool>,
|
|
pub dangerously_allow_all_unix_sockets: Option<bool>,
|
|
#[serde(default)]
|
|
pub allowed_domains: Option<Vec<String>>,
|
|
#[serde(default)]
|
|
pub denied_domains: Option<Vec<String>>,
|
|
#[serde(default)]
|
|
pub allow_unix_sockets: Option<Vec<String>>,
|
|
#[serde(default)]
|
|
pub allow_local_binding: Option<bool>,
|
|
}
|
|
|
|
pub fn build_config_state(
|
|
config: NetworkProxyConfig,
|
|
constraints: NetworkProxyConstraints,
|
|
) -> anyhow::Result<ConfigState> {
|
|
crate::config::validate_unix_socket_allowlist_paths(&config)?;
|
|
validate_domain_patterns("network.allowed_domains", &config.network.allowed_domains)
|
|
.map_err(NetworkProxyConstraintError::into_anyhow)?;
|
|
validate_domain_patterns("network.denied_domains", &config.network.denied_domains)
|
|
.map_err(NetworkProxyConstraintError::into_anyhow)?;
|
|
let deny_set = compile_globset(&config.network.denied_domains)?;
|
|
let allow_set = compile_globset(&config.network.allowed_domains)?;
|
|
let mitm = if config.network.mitm {
|
|
Some(Arc::new(MitmState::new(
|
|
config.network.allow_upstream_proxy,
|
|
)?))
|
|
} else {
|
|
None
|
|
};
|
|
Ok(ConfigState {
|
|
config,
|
|
allow_set,
|
|
deny_set,
|
|
mitm,
|
|
constraints,
|
|
blocked: std::collections::VecDeque::new(),
|
|
blocked_total: 0,
|
|
})
|
|
}
|
|
|
|
pub fn validate_policy_against_constraints(
|
|
config: &NetworkProxyConfig,
|
|
constraints: &NetworkProxyConstraints,
|
|
) -> Result<(), NetworkProxyConstraintError> {
|
|
fn invalid_value(
|
|
field_name: &'static str,
|
|
candidate: impl Into<String>,
|
|
allowed: impl Into<String>,
|
|
) -> NetworkProxyConstraintError {
|
|
NetworkProxyConstraintError::InvalidValue {
|
|
field_name,
|
|
candidate: candidate.into(),
|
|
allowed: allowed.into(),
|
|
}
|
|
}
|
|
|
|
fn validate<T>(
|
|
candidate: T,
|
|
validator: impl FnOnce(&T) -> Result<(), NetworkProxyConstraintError>,
|
|
) -> Result<(), NetworkProxyConstraintError> {
|
|
validator(&candidate)
|
|
}
|
|
|
|
let enabled = config.network.enabled;
|
|
validate_domain_patterns("network.allowed_domains", &config.network.allowed_domains)?;
|
|
validate_domain_patterns("network.denied_domains", &config.network.denied_domains)?;
|
|
if let Some(max_enabled) = constraints.enabled {
|
|
validate(enabled, move |candidate| {
|
|
if *candidate && !max_enabled {
|
|
Err(invalid_value(
|
|
"network.enabled",
|
|
"true",
|
|
"false (disabled by managed config)",
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
})?;
|
|
}
|
|
|
|
if let Some(max_mode) = constraints.mode {
|
|
validate(config.network.mode, move |candidate| {
|
|
if network_mode_rank(*candidate) > network_mode_rank(max_mode) {
|
|
Err(invalid_value(
|
|
"network.mode",
|
|
format!("{candidate:?}"),
|
|
format!("{max_mode:?} or more restrictive"),
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
})?;
|
|
}
|
|
|
|
let allow_upstream_proxy = constraints.allow_upstream_proxy;
|
|
validate(
|
|
config.network.allow_upstream_proxy,
|
|
move |candidate| match allow_upstream_proxy {
|
|
Some(true) | None => Ok(()),
|
|
Some(false) => {
|
|
if *candidate {
|
|
Err(invalid_value(
|
|
"network.allow_upstream_proxy",
|
|
"true",
|
|
"false (disabled by managed config)",
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
},
|
|
)?;
|
|
|
|
let allow_non_loopback_proxy = constraints.dangerously_allow_non_loopback_proxy;
|
|
validate(
|
|
config.network.dangerously_allow_non_loopback_proxy,
|
|
move |candidate| match allow_non_loopback_proxy {
|
|
Some(true) | None => Ok(()),
|
|
Some(false) => {
|
|
if *candidate {
|
|
Err(invalid_value(
|
|
"network.dangerously_allow_non_loopback_proxy",
|
|
"true",
|
|
"false (disabled by managed config)",
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
},
|
|
)?;
|
|
|
|
let allow_all_unix_sockets = constraints
|
|
.dangerously_allow_all_unix_sockets
|
|
.unwrap_or(constraints.allow_unix_sockets.is_none());
|
|
validate(
|
|
config.network.dangerously_allow_all_unix_sockets,
|
|
move |candidate| {
|
|
if *candidate && !allow_all_unix_sockets {
|
|
Err(invalid_value(
|
|
"network.dangerously_allow_all_unix_sockets",
|
|
"true",
|
|
"false (disabled by managed config)",
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
},
|
|
)?;
|
|
|
|
if let Some(allow_local_binding) = constraints.allow_local_binding {
|
|
validate(config.network.allow_local_binding, move |candidate| {
|
|
if *candidate && !allow_local_binding {
|
|
Err(invalid_value(
|
|
"network.allow_local_binding",
|
|
"true",
|
|
"false (disabled by managed config)",
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
})?;
|
|
}
|
|
|
|
if let Some(allowed_domains) = &constraints.allowed_domains {
|
|
validate_domain_patterns("network.allowed_domains", allowed_domains)?;
|
|
match constraints.allowlist_expansion_enabled {
|
|
Some(true) => {
|
|
let required_set: HashSet<String> = allowed_domains
|
|
.iter()
|
|
.map(|entry| entry.to_ascii_lowercase())
|
|
.collect();
|
|
validate(config.network.allowed_domains.clone(), move |candidate| {
|
|
let candidate_set: HashSet<String> = candidate
|
|
.iter()
|
|
.map(|entry| entry.to_ascii_lowercase())
|
|
.collect();
|
|
let missing: Vec<String> = required_set
|
|
.iter()
|
|
.filter(|entry| !candidate_set.contains(*entry))
|
|
.cloned()
|
|
.collect();
|
|
if missing.is_empty() {
|
|
Ok(())
|
|
} else {
|
|
Err(invalid_value(
|
|
"network.allowed_domains",
|
|
"missing managed allowed_domains entries",
|
|
format!("{missing:?}"),
|
|
))
|
|
}
|
|
})?;
|
|
}
|
|
Some(false) => {
|
|
let required_set: HashSet<String> = allowed_domains
|
|
.iter()
|
|
.map(|entry| entry.to_ascii_lowercase())
|
|
.collect();
|
|
validate(config.network.allowed_domains.clone(), move |candidate| {
|
|
let candidate_set: HashSet<String> = candidate
|
|
.iter()
|
|
.map(|entry| entry.to_ascii_lowercase())
|
|
.collect();
|
|
if candidate_set == required_set {
|
|
Ok(())
|
|
} else {
|
|
Err(invalid_value(
|
|
"network.allowed_domains",
|
|
format!("{candidate:?}"),
|
|
"must match managed allowed_domains",
|
|
))
|
|
}
|
|
})?;
|
|
}
|
|
None => {
|
|
let managed_patterns: Vec<DomainPattern> = allowed_domains
|
|
.iter()
|
|
.map(|entry| DomainPattern::parse_for_constraints(entry))
|
|
.collect();
|
|
validate(config.network.allowed_domains.clone(), move |candidate| {
|
|
let mut invalid = Vec::new();
|
|
for entry in candidate {
|
|
let candidate_pattern = DomainPattern::parse_for_constraints(entry);
|
|
if !managed_patterns
|
|
.iter()
|
|
.any(|managed| managed.allows(&candidate_pattern))
|
|
{
|
|
invalid.push(entry.clone());
|
|
}
|
|
}
|
|
if invalid.is_empty() {
|
|
Ok(())
|
|
} else {
|
|
Err(invalid_value(
|
|
"network.allowed_domains",
|
|
format!("{invalid:?}"),
|
|
"subset of managed allowed_domains",
|
|
))
|
|
}
|
|
})?;
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(denied_domains) = &constraints.denied_domains {
|
|
validate_domain_patterns("network.denied_domains", denied_domains)?;
|
|
let required_set: HashSet<String> = denied_domains
|
|
.iter()
|
|
.map(|s| s.to_ascii_lowercase())
|
|
.collect();
|
|
match constraints.denylist_expansion_enabled {
|
|
Some(false) => {
|
|
validate(config.network.denied_domains.clone(), move |candidate| {
|
|
let candidate_set: HashSet<String> = candidate
|
|
.iter()
|
|
.map(|entry| entry.to_ascii_lowercase())
|
|
.collect();
|
|
if candidate_set == required_set {
|
|
Ok(())
|
|
} else {
|
|
Err(invalid_value(
|
|
"network.denied_domains",
|
|
format!("{candidate:?}"),
|
|
"must match managed denied_domains",
|
|
))
|
|
}
|
|
})?;
|
|
}
|
|
Some(true) | None => {
|
|
validate(config.network.denied_domains.clone(), move |candidate| {
|
|
let candidate_set: HashSet<String> =
|
|
candidate.iter().map(|s| s.to_ascii_lowercase()).collect();
|
|
let missing: Vec<String> = required_set
|
|
.iter()
|
|
.filter(|entry| !candidate_set.contains(*entry))
|
|
.cloned()
|
|
.collect();
|
|
if missing.is_empty() {
|
|
Ok(())
|
|
} else {
|
|
Err(invalid_value(
|
|
"network.denied_domains",
|
|
"missing managed denied_domains entries",
|
|
format!("{missing:?}"),
|
|
))
|
|
}
|
|
})?;
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(allow_unix_sockets) = &constraints.allow_unix_sockets {
|
|
let allowed_set: HashSet<String> = allow_unix_sockets
|
|
.iter()
|
|
.map(|s| s.to_ascii_lowercase())
|
|
.collect();
|
|
validate(
|
|
config.network.allow_unix_sockets.clone(),
|
|
move |candidate| {
|
|
let mut invalid = Vec::new();
|
|
for entry in candidate {
|
|
if !allowed_set.contains(&entry.to_ascii_lowercase()) {
|
|
invalid.push(entry.clone());
|
|
}
|
|
}
|
|
if invalid.is_empty() {
|
|
Ok(())
|
|
} else {
|
|
Err(invalid_value(
|
|
"network.allow_unix_sockets",
|
|
format!("{invalid:?}"),
|
|
"subset of managed allow_unix_sockets",
|
|
))
|
|
}
|
|
},
|
|
)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn validate_domain_patterns(
|
|
field_name: &'static str,
|
|
patterns: &[String],
|
|
) -> Result<(), NetworkProxyConstraintError> {
|
|
if let Some(pattern) = patterns
|
|
.iter()
|
|
.find(|pattern| is_global_wildcard_domain_pattern(pattern))
|
|
{
|
|
return Err(NetworkProxyConstraintError::InvalidValue {
|
|
field_name,
|
|
candidate: pattern.trim().to_string(),
|
|
allowed: "exact hosts or scoped wildcards like *.example.com or **.example.com"
|
|
.to_string(),
|
|
});
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
|
|
pub enum NetworkProxyConstraintError {
|
|
#[error("invalid value for {field_name}: {candidate} (allowed {allowed})")]
|
|
InvalidValue {
|
|
field_name: &'static str,
|
|
candidate: String,
|
|
allowed: String,
|
|
},
|
|
}
|
|
|
|
impl NetworkProxyConstraintError {
|
|
pub fn into_anyhow(self) -> anyhow::Error {
|
|
anyhow::anyhow!(self)
|
|
}
|
|
}
|
|
|
|
fn network_mode_rank(mode: NetworkMode) -> u8 {
|
|
match mode {
|
|
NetworkMode::Limited => 0,
|
|
NetworkMode::Full => 1,
|
|
}
|
|
}
|