Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Harden network proxy credential brokerage (#38049)

Winston Howeseea28321ad67
diff --git a/codex-rs/network-proxy/src/config.rs b/codex-rs/network-proxy/src/config.rs
index 8fe5c520e7..3e96704341 100644
--- a/codex-rs/network-proxy/src/config.rs
+++ b/codex-rs/network-proxy/src/config.rs
@@ -14,6 +14,7 @@ use tracing::warn;
use url::Url;
use crate::mitm_hook::MitmHookConfig;
+use crate::policy::normalize_host;
/// Variant order encodes effective precedence for duplicate patterns:
/// `None < Allow < Deny`, so deny wins over allow when entries conflict.
@@ -137,6 +138,9 @@ pub struct NetworkProxyConfig {
pub mitm: bool,
#[serde(default)]
pub credential_broker: bool,
+ /// Trusted OpenAI endpoint derived from local configuration, never sent to remote executors.
+ #[serde(skip)]
+ pub credential_broker_openai_host: Option<String>,
#[serde(default)]
pub dangerously_allow_plaintext_credential_injection: bool,
#[serde(default)]
@@ -160,6 +164,7 @@ impl Default for NetworkProxyConfig {
allow_local_binding: false,
mitm: false,
credential_broker: false,
+ credential_broker_openai_host: None,
dangerously_allow_plaintext_credential_injection: false,
mitm_hooks: Vec::new(),
}
@@ -172,6 +177,10 @@ impl NetworkProxyConfig {
self.mitm |= enabled;
}
+ pub fn set_credential_broker_openai_base_url(&mut self, base_url: Option<&str>) {
+ self.credential_broker_openai_host = base_url.and_then(trusted_credential_broker_host);
+ }
+
pub fn allowed_domains(&self) -> Option<Vec<String>> {
self.domain_entries(NetworkDomainPermission::Allow)
}
@@ -276,6 +285,15 @@ impl NetworkProxyConfig {
}
}
+pub(crate) fn trusted_credential_broker_host(base_url: &str) -> Option<String> {
+ Url::parse(base_url)
+ .ok()
+ .filter(|url| {
+ url.scheme() == "https" && url.username().is_empty() && url.password().is_none()
+ })
+ .and_then(|url| url.host_str().map(normalize_host))
+}
+
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "lowercase")]
pub enum NetworkMode {
@@ -619,12 +637,40 @@ mod tests {
allow_local_binding: false,
mitm: false,
credential_broker: false,
+ credential_broker_openai_host: None,
dangerously_allow_plaintext_credential_injection: false,
mitm_hooks: Vec::new(),
}
);
}
+ #[test]
+ fn credential_broker_only_accepts_trusted_https_openai_endpoints() {
+ let mut config = NetworkProxyConfig::default();
+
+ for (base_url, expected_host) in [
+ (
+ Some("https://gateway.example.com/v1"),
+ Some("gateway.example.com"),
+ ),
+ (
+ Some("https://gateway.example.com./v1"),
+ Some("gateway.example.com"),
+ ),
+ (Some("https://[2001:db8::1]/v1"), Some("2001:db8::1")),
+ (Some("http://gateway.example.com/v1"), None),
+ (Some("https://[email protected]/v1"), None),
+ (Some("not-a-url"), None),
+ (None, None),
+ ] {
+ config.set_credential_broker_openai_base_url(base_url);
+ assert_eq!(
+ config.credential_broker_openai_host.as_deref(),
+ expected_host
+ );
+ }
+ }
+
#[test]
fn managed_proxy_ports_reject_ephemeral_ports() {
let mut config = NetworkProxyConfig {
diff --git a/codex-rs/network-proxy/src/credential_broker.rs b/codex-rs/network-proxy/src/credential_broker.rs
index 379c45e4cd..0d5c4d3ae3 100644
--- a/codex-rs/network-proxy/src/credential_broker.rs
+++ b/codex-rs/network-proxy/src/credential_broker.rs
@@ -1,5 +1,6 @@
mod providers;
+use crate::config::NetworkProxyConfig;
use crate::policy::normalize_host;
use rama_http::HeaderMap;
use std::collections::HashMap;
@@ -17,6 +18,7 @@ pub(crate) struct CredentialBroker {
#[derive(Default)]
struct CredentialBrokerState {
enabled: bool,
+ openai_api_host: Option<String>,
credentials: Vec<CredentialRecord>,
}
@@ -28,6 +30,39 @@ struct CredentialRecord {
dummy_value: String,
}
+fn env_key_matches(candidate: &str, expected: &str) -> bool {
+ if cfg!(windows) {
+ candidate.eq_ignore_ascii_case(expected)
+ } else {
+ candidate == expected
+ }
+}
+
+fn env_entry<'a>(env: &'a HashMap<String, String>, key: &str) -> Option<(&'a str, &'a str)> {
+ env.iter()
+ .find(|(candidate, _)| env_key_matches(candidate, key))
+ .map(|(key, value)| (key.as_str(), value.as_str()))
+}
+
+pub(super) fn env_value<'a>(env: &'a HashMap<String, String>, key: &str) -> Option<&'a str> {
+ env_entry(env, key).map(|(_, value)| value)
+}
+
+fn set_env_value(env: &mut HashMap<String, String>, key: &str, value: String) {
+ if cfg!(windows) {
+ env.retain(|candidate, _| !env_key_matches(candidate, key));
+ }
+ env.insert(key.to_string(), value);
+}
+
+fn remove_env_value(env: &mut HashMap<String, String>, key: &str) {
+ if cfg!(windows) {
+ env.retain(|candidate, _| !env_key_matches(candidate, key));
+ } else {
+ env.remove(key);
+ }
+}
+
impl CredentialBroker {
pub(crate) fn new(enabled: bool) -> Self {
Self {
@@ -38,25 +73,36 @@ impl CredentialBroker {
}
}
- pub(crate) fn enabled(&self) -> bool {
- self.read_state().enabled
+ pub(crate) fn configure(&self, config: &NetworkProxyConfig) {
+ let mut state = self.write_state();
+ if state.enabled != config.credential_broker {
+ state.enabled = config.credential_broker;
+ state.credentials.clear();
+ }
+ if state.openai_api_host != config.credential_broker_openai_host {
+ state
+ .openai_api_host
+ .clone_from(&config.credential_broker_openai_host);
+ state
+ .credentials
+ .retain(|credential| !credential.provider.reset_on_configuration_change);
+ }
}
pub(crate) fn virtualize_child_env(&self, env: &mut HashMap<String, String>) {
let mut state = self.write_state();
if !state.enabled {
- env.remove(CREDENTIAL_BROKER_ACTIVE_ENV_KEY);
- env.remove(BROKERED_CREDENTIALS_ENV_KEY);
+ remove_env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY);
+ remove_env_value(env, BROKERED_CREDENTIALS_ENV_KEY);
return;
}
- env.insert(
- CREDENTIAL_BROKER_ACTIVE_ENV_KEY.to_string(),
- "1".to_string(),
- );
+ set_env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY, "1".to_string());
for provider in providers::credential_providers() {
for source in provider.sources() {
- if let Some(host_binding) = (source.host_binding)(env) {
+ if let Some(host_binding) =
+ (source.host_binding)(env, state.openai_api_host.as_deref())
+ {
for env_var in source.env_vars {
virtualize_env_var(
env,
@@ -72,6 +118,31 @@ impl CredentialBroker {
update_brokered_credentials_marker(&state, env);
}
+ pub(crate) fn restore_child_env(
+ &self,
+ env: &mut HashMap<String, String>,
+ command: &mut [String],
+ ) {
+ let state = self.read_state();
+ if !state.enabled || env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY) != Some("1") {
+ return;
+ }
+
+ for (key, value) in env {
+ if let Some(credential) = state.credentials.iter().find(|credential| {
+ env_key_matches(key, &credential.env_var) && value == &credential.dummy_value
+ }) {
+ for argument in command.iter_mut() {
+ if argument.contains(&credential.dummy_value) {
+ *argument =
+ argument.replace(&credential.dummy_value, &credential.real_value);
+ }
+ }
+ *value = credential.real_value.clone();
+ }
+ }
+ }
+
pub(crate) fn host_requires_mitm(&self, host: &str) -> bool {
let normalized_host = normalize_host(host);
let state = self.read_state();
@@ -94,12 +165,7 @@ impl CredentialBroker {
.iter()
.filter(|credential| credential.matches_host(&normalized_host))
.collect::<Vec<_>>();
- let Some(credential) = select_credential(headers, &matching_credentials) else {
- return;
- };
- let Some(header_value) = credential
- .provider
- .request_header_value(&credential.real_value)
+ let Some((credential, header_value)) = select_credential(headers, &matching_credentials)
else {
return;
};
@@ -133,7 +199,7 @@ fn virtualize_env_var(
};
let dummy_value = state.register(env_var, provider, host_binding, real_value);
- env.insert(env_var.to_string(), dummy_value);
+ set_env_value(env, env_var, dummy_value);
}
fn brokerable_credential_value<'a>(
@@ -142,7 +208,7 @@ fn brokerable_credential_value<'a>(
env_var: &str,
provider: &providers::CredentialProvider,
) -> Option<&'a str> {
- let real_value = env.get(env_var)?.trim();
+ let real_value = env_value(env, env_var)?.trim();
(!real_value.is_empty()
&& !state.is_dummy_value(real_value)
&& provider.request_header_value(real_value).is_some())
@@ -198,40 +264,36 @@ impl CredentialRecord {
fn select_credential<'a>(
headers: &HeaderMap,
matching_credentials: &[&'a CredentialRecord],
-) -> Option<&'a CredentialRecord> {
- let dummy_matches = matching_credentials
+) -> Option<(&'a CredentialRecord, rama_http::HeaderValue)> {
+ let mut translated_matches = matching_credentials
.iter()
.copied()
- .filter(|credential| {
+ .filter_map(|credential| {
credential
.provider
- .request_header(headers)
- .and_then(|value| value.to_str().ok())
- .is_some_and(|value| value.contains(&credential.dummy_value))
- })
- .collect::<Vec<_>>();
- match dummy_matches.as_slice() {
- [credential] => Some(*credential),
- [] | [_, _, ..] => None,
- }
+ .translate_request_header(headers, &credential.dummy_value, &credential.real_value)
+ .map(|header_value| (credential, header_value))
+ });
+ let matched = translated_matches.next()?;
+ translated_matches.next().is_none().then_some(matched)
}
fn update_brokered_credentials_marker(
state: &CredentialBrokerState,
env: &mut HashMap<String, String>,
) {
- let brokered = providers::credential_broker_env_keys()
+ let brokered = providers::credential_env_keys()
.filter_map(|key| {
- let value = env.get(key)?;
- state.is_dummy_value(value).then_some((key, value.as_str()))
+ let (actual_key, value) = env_entry(env, key)?;
+ state.is_dummy_value(value).then_some((actual_key, value))
})
.collect::<Vec<_>>();
match serde_json::to_string(&brokered) {
Ok(marker) => {
- env.insert(BROKERED_CREDENTIALS_ENV_KEY.to_string(), marker);
+ set_env_value(env, BROKERED_CREDENTIALS_ENV_KEY, marker);
}
Err(_) => {
- env.remove(BROKERED_CREDENTIALS_ENV_KEY);
+ remove_env_value(env, BROKERED_CREDENTIALS_ENV_KEY);
}
}
}
@@ -243,26 +305,42 @@ fn update_brokered_credentials_marker(
/// replaced by the user are ignored. The environment is not mutated; callers own the decision to
/// remove the returned keys.
pub fn brokered_credential_dummy_env_keys(env: &HashMap<String, String>) -> Vec<String> {
- env.get(BROKERED_CREDENTIALS_ENV_KEY)
+ let mut keys = env_value(env, BROKERED_CREDENTIALS_ENV_KEY)
.and_then(|marker| serde_json::from_str::<Vec<(String, String)>>(marker).ok())
.unwrap_or_default()
.into_iter()
.filter_map(|(key, dummy_value)| {
- (providers::credential_broker_env_keys().any(|candidate| candidate == key.as_str())
- && env.get(&key) == Some(&dummy_value))
- .then_some(key)
+ providers::credential_env_keys()
+ .any(|candidate| env_key_matches(&key, candidate))
+ .then_some(())?;
+ let (actual_key, actual_value) = env_entry(env, &key)?;
+ (actual_value == dummy_value.as_str()).then(|| actual_key.to_string())
})
- .collect()
+ .collect::<Vec<_>>();
+ keys.sort_unstable();
+ keys
}
-/// Returns supported credential keys only for an environment with an active broker.
+/// Returns credential keys plus provider context keys already present in an environment with an
+/// active broker.
pub fn brokered_credential_env_keys(
env: &HashMap<String, String>,
) -> impl Iterator<Item = &'static str> {
- let active = env
- .get(CREDENTIAL_BROKER_ACTIVE_ENV_KEY)
- .is_some_and(|value| value == "1");
- providers::credential_broker_env_keys().filter(move |_| active)
+ let active = env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY).is_some_and(|value| value == "1");
+ let mut keys = Vec::new();
+ if active {
+ let brokered_keys = brokered_credential_dummy_env_keys(env);
+ keys.extend(providers::credential_env_keys().filter(|key| {
+ brokered_keys
+ .iter()
+ .any(|brokered_key| env_key_matches(brokered_key, key))
+ }));
+ keys.extend(
+ providers::credential_context_env_keys(&brokered_keys)
+ .filter(|key| env_value(env, key).is_some()),
+ );
+ }
+ keys.into_iter()
}
#[cfg(test)]
diff --git a/codex-rs/network-proxy/src/credential_broker/providers.rs b/codex-rs/network-proxy/src/credential_broker/providers.rs
index 94c4b6e37d..760a9aa5ad 100644
--- a/codex-rs/network-proxy/src/credential_broker/providers.rs
+++ b/codex-rs/network-proxy/src/credential_broker/providers.rs
@@ -8,7 +8,7 @@ use std::collections::HashMap;
const DUMMY_ALPHANUMERIC: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-type RequestHeader = for<'a> fn(&'a HeaderMap) -> Option<&'a HeaderValue>;
+type TranslateRequestHeader = fn(&HeaderMap, &str, &str) -> Option<HeaderValue>;
/// Describes how one credential family is recognized and injected.
///
@@ -17,8 +17,9 @@ type RequestHeader = for<'a> fn(&'a HeaderMap) -> Option<&'a HeaderValue>;
pub(super) struct CredentialProvider {
context_env_vars: &'static [&'static str],
sources: &'static [CredentialSource],
+ pub(super) reset_on_configuration_change: bool,
dummy_value: fn(&str) -> String,
- request_header: RequestHeader,
+ translate_request_header: TranslateRequestHeader,
request_header_value: fn(&str) -> Option<HeaderValue>,
insert_request_header: fn(&mut HeaderMap, HeaderValue),
}
@@ -26,6 +27,7 @@ pub(super) struct CredentialProvider {
#[derive(Clone, PartialEq, Eq)]
pub(super) enum CredentialHostBinding {
ExactHost(String),
+ ExactHosts(Vec<String>),
HostPattern {
exact_hosts: &'static [&'static str],
suffixes: &'static [&'static str],
@@ -34,7 +36,8 @@ pub(super) enum CredentialHostBinding {
pub(super) struct CredentialSource {
pub(super) env_vars: &'static [&'static str],
- pub(super) host_binding: fn(&HashMap<String, String>) -> Option<CredentialHostBinding>,
+ pub(super) host_binding:
+ fn(&HashMap<String, String>, Option<&str>) -> Option<CredentialHostBinding>,
}
const CREDENTIAL_PROVIDERS: &[&CredentialProvider] = &[&github::PROVIDER, &openai::PROVIDER];
@@ -48,8 +51,13 @@ impl CredentialProvider {
(self.dummy_value)(real_value)
}
- pub(super) fn request_header<'a>(&self, headers: &'a HeaderMap) -> Option<&'a HeaderValue> {
- (self.request_header)(headers)
+ pub(super) fn translate_request_header(
+ &self,
+ headers: &HeaderMap,
+ expected_value: &str,
+ replacement_value: &str,
+ ) -> Option<HeaderValue> {
+ (self.translate_request_header)(headers, expected_value, replacement_value)
}
pub(super) fn request_header_value(&self, value: &str) -> Option<HeaderValue> {
@@ -65,6 +73,9 @@ impl CredentialHostBinding {
pub(super) fn matches_host(&self, host: &str) -> bool {
match self {
Self::ExactHost(expected_host) => host == expected_host,
+ Self::ExactHosts(expected_hosts) => {
+ expected_hosts.iter().any(|expected| host == expected)
+ }
Self::HostPattern {
exact_hosts,
suffixes,
@@ -75,14 +86,26 @@ impl CredentialHostBinding {
}
}
-pub(super) fn credential_broker_env_keys() -> impl Iterator<Item = &'static str> {
+pub(super) fn credential_context_env_keys(
+ brokered_keys: &[String],
+) -> impl Iterator<Item = &'static str> + '_ {
credential_providers()
+ .filter(move |provider| {
+ provider.sources().iter().any(|source| {
+ source.env_vars.iter().any(|key| {
+ brokered_keys
+ .iter()
+ .any(|brokered_key| super::env_key_matches(brokered_key, key))
+ })
+ })
+ })
.flat_map(|provider| provider.context_env_vars.iter().copied())
- .chain(
- credential_providers()
- .flat_map(CredentialProvider::sources)
- .flat_map(|source| source.env_vars.iter().copied()),
- )
+}
+
+pub(super) fn credential_env_keys() -> impl Iterator<Item = &'static str> {
+ credential_providers()
+ .flat_map(CredentialProvider::sources)
+ .flat_map(|source| source.env_vars.iter().copied())
}
pub(super) fn credential_providers() -> impl Iterator<Item = &'static CredentialProvider> {
diff --git a/codex-rs/network-proxy/src/credential_broker/providers/github.rs b/codex-rs/network-proxy/src/credential_broker/providers/github.rs
index ced353ee7a..523277ba29 100644
--- a/codex-rs/network-proxy/src/credential_broker/providers/github.rs
+++ b/codex-rs/network-proxy/src/credential_broker/providers/github.rs
@@ -1,8 +1,10 @@
+use super::super::env_value;
use super::CredentialHostBinding;
use super::CredentialProvider;
use super::CredentialSource;
use super::shaped_dummy_value;
use crate::policy::normalize_host;
+use base64::Engine as _;
use rama_http::HeaderMap;
use rama_http::HeaderValue;
use rama_http::header::AUTHORIZATION;
@@ -14,7 +16,7 @@ const GITHUB_TOKEN_MIN_LEN: usize = 40;
const GITHUB_CLOUD_TOKEN_ENV_VARS: &[&str] = &["GH_TOKEN", "GITHUB_TOKEN"];
const GITHUB_ENTERPRISE_TOKEN_ENV_VARS: &[&str] =
&["GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN"];
-const GITHUB_CLOUD_HOSTS: &[&str] = &["api.github.com", "github.com"];
+const GITHUB_CLOUD_HOSTS: &[&str] = &["api.github.com", "github.com", "uploads.github.com"];
const GITHUB_CLOUD_HOST_SUFFIXES: &[&str] = &[".ghe.com"];
pub(super) static PROVIDER: CredentialProvider = CredentialProvider {
@@ -29,8 +31,9 @@ pub(super) static PROVIDER: CredentialProvider = CredentialProvider {
host_binding: github_enterprise_binding,
},
],
+ reset_on_configuration_change: false,
dummy_value,
- request_header,
+ translate_request_header,
request_header_value,
insert_request_header,
};
@@ -43,10 +46,6 @@ fn dummy_value(real_value: &str) -> String {
)
}
-fn request_header(headers: &HeaderMap) -> Option<&HeaderValue> {
- headers.get(AUTHORIZATION)
-}
-
fn request_header_value(value: &str) -> Option<HeaderValue> {
HeaderValue::from_str(&format!("Bearer {value}")).ok()
}
@@ -55,14 +54,54 @@ fn insert_request_header(headers: &mut HeaderMap, value: HeaderValue) {
headers.insert(AUTHORIZATION, value);
}
-fn github_cloud_binding(_: &HashMap<String, String>) -> Option<CredentialHostBinding> {
+fn translate_request_header(
+ headers: &HeaderMap,
+ expected_value: &str,
+ replacement_value: &str,
+) -> Option<HeaderValue> {
+ let header = headers.get(AUTHORIZATION)?.to_str().ok()?;
+ let (scheme, value) = header.split_once(' ')?;
+ let value = value.trim();
+ if scheme.eq_ignore_ascii_case("basic") {
+ let decoded = base64::engine::general_purpose::STANDARD
+ .decode(value)
+ .ok()?;
+ let separator = decoded.iter().position(|byte| *byte == b':')?;
+ let mut translated = Vec::with_capacity(decoded.len() + replacement_value.len());
+ if &decoded[..separator] == expected_value.as_bytes() {
+ translated.extend_from_slice(replacement_value.as_bytes());
+ translated.extend_from_slice(&decoded[separator..]);
+ } else if &decoded[separator + 1..] == expected_value.as_bytes() {
+ translated.extend_from_slice(&decoded[..=separator]);
+ translated.extend_from_slice(replacement_value.as_bytes());
+ } else {
+ return None;
+ }
+ let encoded = base64::engine::general_purpose::STANDARD.encode(translated);
+ HeaderValue::from_str(&format!("{scheme} {encoded}")).ok()
+ } else if (scheme.eq_ignore_ascii_case("bearer") || scheme.eq_ignore_ascii_case("token"))
+ && value == expected_value
+ {
+ HeaderValue::from_str(&format!("{scheme} {replacement_value}")).ok()
+ } else {
+ None
+ }
+}
+
+fn github_cloud_binding(
+ _: &HashMap<String, String>,
+ _: Option<&str>,
+) -> Option<CredentialHostBinding> {
Some(CredentialHostBinding::HostPattern {
exact_hosts: GITHUB_CLOUD_HOSTS,
suffixes: GITHUB_CLOUD_HOST_SUFFIXES,
})
}
-fn github_enterprise_binding(env: &HashMap<String, String>) -> Option<CredentialHostBinding> {
+fn github_enterprise_binding(
+ env: &HashMap<String, String>,
+ _: Option<&str>,
+) -> Option<CredentialHostBinding> {
github_host_hint(env)
.filter(|host| !github_cloud_host(host))
.map(CredentialHostBinding::ExactHost)
@@ -84,8 +123,7 @@ fn github_token_prefix(value: &str) -> &str {
}
fn github_host_hint(env: &HashMap<String, String>) -> Option<String> {
- env.get(GH_HOST_ENV_VAR)
- .map(String::as_str)
+ env_value(env, GH_HOST_ENV_VAR)
.map(normalize_host)
.filter(|host| !host.is_empty())
}
diff --git a/codex-rs/network-proxy/src/credential_broker/providers/openai.rs b/codex-rs/network-proxy/src/credential_broker/providers/openai.rs
index c3af9261f8..a7e14db1e4 100644
--- a/codex-rs/network-proxy/src/credential_broker/providers/openai.rs
+++ b/codex-rs/network-proxy/src/credential_broker/providers/openai.rs
@@ -1,24 +1,28 @@
+use super::super::env_value;
use super::CredentialHostBinding;
use super::CredentialProvider;
use super::CredentialSource;
use super::shaped_dummy_value;
+use crate::config::trusted_credential_broker_host;
use rama_http::HeaderMap;
use rama_http::HeaderValue;
use rama_http::header::AUTHORIZATION;
use std::collections::HashMap;
const OPENAI_API_KEY_ENV_VARS: &[&str] = &["OPENAI_API_KEY"];
+const OPENAI_BASE_URL_ENV_VAR: &str = "OPENAI_BASE_URL";
const OPENAI_API_KEY_MIN_LEN: usize = 51;
const OPENAI_API_HOST: &str = "api.openai.com";
pub(super) static PROVIDER: CredentialProvider = CredentialProvider {
- context_env_vars: &[],
+ context_env_vars: &[OPENAI_BASE_URL_ENV_VAR],
sources: &[CredentialSource {
env_vars: OPENAI_API_KEY_ENV_VARS,
host_binding,
}],
+ reset_on_configuration_change: true,
dummy_value,
- request_header,
+ translate_request_header,
request_header_value,
insert_request_header,
};
@@ -31,8 +35,16 @@ fn dummy_value(real_value: &str) -> String {
)
}
-fn request_header(headers: &HeaderMap) -> Option<&HeaderValue> {
- headers.get(AUTHORIZATION)
+fn translate_request_header(
+ headers: &HeaderMap,
+ expected_value: &str,
+ replacement_value: &str,
+) -> Option<HeaderValue> {
+ headers
+ .get(AUTHORIZATION)
+ .and_then(|header| header.to_str().ok())
+ .filter(|header| header.contains(expected_value))?;
+ request_header_value(replacement_value)
}
fn request_header_value(value: &str) -> Option<HeaderValue> {
@@ -43,10 +55,25 @@ fn insert_request_header(headers: &mut HeaderMap, value: HeaderValue) {
headers.insert(AUTHORIZATION, value);
}
-fn host_binding(_: &HashMap<String, String>) -> Option<CredentialHostBinding> {
- Some(CredentialHostBinding::ExactHost(
- OPENAI_API_HOST.to_string(),
- ))
+fn host_binding(
+ env: &HashMap<String, String>,
+ configured_host: Option<&str>,
+) -> Option<CredentialHostBinding> {
+ let mut hosts = vec![OPENAI_API_HOST.to_string()];
+ for host in configured_host
+ .map(str::to_string)
+ .into_iter()
+ .chain(env_value(env, OPENAI_BASE_URL_ENV_VAR).and_then(trusted_credential_broker_host))
+ {
+ if !hosts.contains(&host) {
+ hosts.push(host);
+ }
+ }
+
+ Some(match hosts.as_slice() {
+ [host] => CredentialHostBinding::ExactHost(host.clone()),
+ _ => CredentialHostBinding::ExactHosts(hosts),
+ })
}
fn openai_api_key_prefix(value: &str) -> &str {
diff --git a/codex-rs/network-proxy/src/credential_broker_tests.rs b/codex-rs/network-proxy/src/credential_broker_tests.rs
index 186e891634..fc89aa3a33 100644
--- a/codex-rs/network-proxy/src/credential_broker_tests.rs
+++ b/codex-rs/network-proxy/src/credential_broker_tests.rs
@@ -1,5 +1,7 @@
use super::*;
+use base64::Engine as _;
+use base64::engine::general_purpose::STANDARD;
use pretty_assertions::assert_eq;
use rama_http::HeaderValue;
use rama_http::header::AUTHORIZATION;
@@ -12,10 +14,14 @@ fn env_map<const N: usize>(entries: [(&str, &str); N]) -> HashMap<String, String
}
fn headers_with_bearer(value: &str) -> HeaderMap {
+ headers_with_authorization(&format!("Bearer {value}"))
+}
+
+fn headers_with_authorization(value: &str) -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(
AUTHORIZATION,
- HeaderValue::from_str(&format!("Bearer {value}")).expect("valid bearer header"),
+ HeaderValue::from_str(value).expect("valid authorization header"),
);
headers
}
@@ -57,11 +63,53 @@ fn virtualize_child_env_replaces_supported_credentials() {
let openai_dummy = env.get("OPENAI_API_KEY").expect("dummy OpenAI API key");
assert_credential_shape(github_token, github_dummy, "github_pat_");
assert_credential_shape(openai_api_key, openai_dummy, "sk-proj-");
+ let mut command = vec![
+ format!("Authorization: Bearer {github_dummy}"),
+ format!("Authorization: Bearer {openai_dummy}"),
+ ];
+ let openai_dummy = openai_dummy.clone();
env.insert("OPENAI_API_KEY".to_string(), "sk-user-override".to_string());
assert_eq!(
brokered_credential_dummy_env_keys(&env),
vec!["GH_TOKEN".to_string()]
);
+
+ broker.restore_child_env(&mut env, &mut command);
+ assert_eq!(env.get("GH_TOKEN").map(String::as_str), Some(github_token));
+ assert_eq!(
+ env.get("OPENAI_API_KEY").map(String::as_str),
+ Some("sk-user-override")
+ );
+ assert_eq!(
+ command,
+ vec![
+ format!("Authorization: Bearer {github_token}"),
+ format!("Authorization: Bearer {openai_dummy}"),
+ ]
+ );
+}
+
+#[cfg(windows)]
+#[test]
+fn brokered_credentials_match_environment_keys_case_insensitively_on_windows() {
+ let broker = CredentialBroker::new(/*enabled*/ true);
+ let mut env = env_map([
+ ("gh_host", "github.example.com"),
+ ("gh_enterprise_token", "ghp-enterprise-real"),
+ ]);
+
+ broker.virtualize_child_env(&mut env);
+ let dummy = env
+ .get("GH_ENTERPRISE_TOKEN")
+ .expect("dummy GitHub enterprise token");
+ let mut headers = headers_with_bearer(dummy);
+ broker.inject_request_headers("github.example.com", &mut headers);
+
+ assert_eq!(
+ brokered_credential_dummy_env_keys(&env),
+ vec!["GH_ENTERPRISE_TOKEN".to_string()]
+ );
+ assert_eq!(authorization(&headers), Some("Bearer ghp-enterprise-real"));
}
#[test]
@@ -84,6 +132,27 @@ fn virtualize_child_env_preserves_live_dummy_mappings() {
assert_eq!(authorization(&second_headers), Some("Bearer ghp-real-two"));
}
+#[test]
+fn brokered_credential_env_keys_only_include_registered_credentials() {
+ let broker = CredentialBroker::new(/*enabled*/ true);
+ let mut env = env_map([
+ ("OPENAI_API_KEY", "sk-real"),
+ ("GH_TOKEN", ""),
+ ("GH_HOST", "github.example.com"),
+ ]);
+
+ broker.virtualize_child_env(&mut env);
+ env.insert(
+ "GH_TOKEN".to_string(),
+ "ghp_added_after_brokerage".to_string(),
+ );
+
+ assert_eq!(
+ brokered_credential_env_keys(&env).collect::<Vec<_>>(),
+ vec!["OPENAI_API_KEY"]
+ );
+}
+
#[test]
fn virtualize_child_env_uses_fresh_dummy_capabilities() {
let mut first_env = env_map([("OPENAI_API_KEY", "sk-proj-abcdefghijklmnopqrstuvwxyz")]);
@@ -146,6 +215,47 @@ fn inject_request_headers_requires_dummy_to_select_ambiguous_github_credential()
assert_eq!(authorization(&headers), Some("Bearer ghp-real-two"));
}
+#[test]
+fn request_translation_preserves_provider_scheme_and_host_binding() {
+ let broker = CredentialBroker::new(/*enabled*/ true);
+ let mut env = env_map([("GH_TOKEN", "ghp-real")]);
+ broker.virtualize_child_env(&mut env);
+ let gh = &env["GH_TOKEN"];
+ let basic_dummy = STANDARD.encode(format!("x-access-token:{gh}"));
+ let basic_real = STANDARD.encode("x-access-token:ghp-real");
+ let basic_username_dummy = STANDARD.encode(format!("{gh}:x-oauth-basic"));
+ let basic_username_real = STANDARD.encode("ghp-real:x-oauth-basic");
+ let basic_dummy = basic_dummy.as_str();
+ let basic_real = basic_real.as_str();
+ let basic_username_dummy = basic_username_dummy.as_str();
+ let basic_username_real = basic_username_real.as_str();
+
+ for (host, scheme, input, expected) in [
+ ("github.com", "Basic", basic_dummy, basic_real),
+ ("example.com", "Basic", basic_dummy, basic_dummy),
+ (
+ "github.com",
+ "Basic",
+ basic_username_dummy,
+ basic_username_real,
+ ),
+ (
+ "example.com",
+ "Basic",
+ basic_username_dummy,
+ basic_username_dummy,
+ ),
+ ("api.github.com", "Bearer", gh.as_str(), "ghp-real"),
+ ("uploads.github.com", "Bearer", gh.as_str(), "ghp-real"),
+ ("api.github.com", "token", gh.as_str(), "ghp-real"),
+ ] {
+ let mut headers = headers_with_authorization(&format!("{scheme} {input}"));
+ broker.inject_request_headers(host, &mut headers);
+ let expected = format!("{scheme} {expected}");
+ assert_eq!(authorization(&headers), Some(expected.as_str()), "{host}");
+ }
+}
+
#[test]
fn inject_request_headers_requires_dummy_and_preserves_explicit_authorization() {
let broker = CredentialBroker::new(/*enabled*/ true);
@@ -167,6 +277,54 @@ fn inject_request_headers_requires_dummy_and_preserves_explicit_authorization()
assert_eq!(authorization(&explicit_headers), Some("Bearer sk-explicit"));
}
+#[test]
+fn openai_credentials_bind_only_to_default_and_configured_trusted_hosts() {
+ let broker = CredentialBroker::new(/*enabled*/ true);
+ let mut config = NetworkProxyConfig::default();
+ config.set_credential_broker_enabled(/*enabled*/ true);
+ config.set_credential_broker_openai_base_url(
+ /*base_url*/ Some("https://gateway.example.com./v1"),
+ );
+ broker.configure(&config);
+
+ let mut env = env_map([
+ ("OPENAI_API_KEY", "sk-real"),
+ ("OPENAI_BASE_URL", "https://sdk.example.com./v1"),
+ ("GH_TOKEN", "ghp-real"),
+ ]);
+ broker.virtualize_child_env(&mut env);
+ assert!(brokered_credential_env_keys(&env).any(|key| key == "OPENAI_BASE_URL"));
+ let dummy = &env["OPENAI_API_KEY"];
+
+ for (host, expected_credential) in [
+ ("api.openai.com", "sk-real"),
+ ("gateway.example.com", "sk-real"),
+ ("sdk.example.com", "sk-real"),
+ ("attacker.example", dummy.as_str()),
+ ] {
+ let mut headers = headers_with_bearer(dummy);
+ broker.inject_request_headers(host, &mut headers);
+ let expected = format!("Bearer {expected_credential}");
+ assert_eq!(authorization(&headers), Some(expected.as_str()), "{host}");
+ }
+
+ config.set_credential_broker_openai_base_url(
+ /*base_url*/ Some("https://replacement.example/v1"),
+ );
+ broker.configure(&config);
+
+ let mut github_headers = headers_with_bearer(&env["GH_TOKEN"]);
+ broker.inject_request_headers("api.github.com", &mut github_headers);
+ assert_eq!(authorization(&github_headers), Some("Bearer ghp-real"));
+
+ let mut openai_headers = headers_with_bearer(dummy);
+ broker.inject_request_headers("gateway.example.com", &mut openai_headers);
+ assert_eq!(
+ authorization(&openai_headers),
+ Some(format!("Bearer {dummy}").as_str())
+ );
+}
+
#[test]
fn github_cloud_credentials_match_ghe_com_host_hint() {
let broker = CredentialBroker::new(/*enabled*/ true);
@@ -207,6 +365,7 @@ fn github_enterprise_credentials_bind_to_gh_host() {
("GH_ENTERPRISE_TOKEN", "ghp-enterprise-real"),
]);
broker.virtualize_child_env(&mut env);
+ assert!(brokered_credential_env_keys(&env).any(|key| key == "GH_HOST"));
let github_token = env
.get("GH_ENTERPRISE_TOKEN")
.expect("dummy GitHub enterprise token");
diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rs
index 5c37ef15c1..dfdfc788b8 100644
--- a/codex-rs/network-proxy/src/proxy.rs
+++ b/codex-rs/network-proxy/src/proxy.rs
@@ -603,7 +603,11 @@ pub fn is_managed_proxy_env_var(key: &str, value: &str) -> bool {
}
pub fn strip_managed_proxy_env(env: &mut HashMap<String, String>) {
- env.retain(|key, value| !is_managed_proxy_env_var(key, value));
+ let brokered_credential_dummy_env_keys =
+ crate::credential_broker::brokered_credential_dummy_env_keys(env);
+ env.retain(|key, value| {
+ !brokered_credential_dummy_env_keys.contains(key) && !is_managed_proxy_env_var(key, value)
+ });
}
#[cfg(target_os = "macos")]
@@ -828,9 +832,27 @@ impl NetworkProxy {
/// Captures the static inputs needed to launch a matching executor-local proxy.
pub async fn remote_launch_config(&self) -> Result<crate::RemoteNetworkProxyLaunchConfig> {
- let proxy = crate::RemoteNetworkProxyConfig::from_effective_config(
- &self.state.current_cfg().await?,
- )?;
+ let (mut config, brokerage_created_default_allowlist) =
+ self.state.current_cfg_with_brokerage_provenance().await?;
+ let mut broker_only_config = config::NetworkProxyConfig {
+ enabled: config.enabled,
+ credential_broker_openai_host: config.credential_broker_openai_host.clone(),
+ dangerously_allow_plaintext_credential_injection: config
+ .dangerously_allow_plaintext_credential_injection,
+ ..config::NetworkProxyConfig::default()
+ };
+ broker_only_config.set_credential_broker_enabled(/*enabled*/ true);
+ broker_only_config.set_allowed_domains(vec!["*".to_string()]);
+ let broker_only = brokerage_created_default_allowlist && config == broker_only_config;
+ if config.credential_broker {
+ config.enabled &= !broker_only;
+ config.credential_broker = false;
+ config.dangerously_allow_plaintext_credential_injection = false;
+ if config.mitm && config.mitm_hooks.is_empty() {
+ config.mitm = false;
+ }
+ }
+ let proxy = crate::RemoteNetworkProxyConfig::from_effective_config(&config)?;
let (environment_id, execution_id) = self
.execution_scope
.as_ref()
@@ -1027,6 +1049,15 @@ impl NetworkProxy {
);
}
+ /// Restores known dummy credentials before a child intentionally leaves managed networking.
+ pub fn restore_brokered_credentials(
+ &self,
+ env: &mut HashMap<String, String>,
+ command: &mut [String],
+ ) {
+ self.state.restore_child_credentials(env, command);
+ }
+
pub fn apply_to_env_for_environment(
&self,
env: &mut HashMap<String, String>,
@@ -1969,7 +2000,12 @@ mod tests {
async fn remote_launch_config_carries_execution_scope() -> Result<()> {
#[cfg(target_os = "windows")]
let _permit = WINDOWS_INGRESS_TEST_LOCK.acquire().await.unwrap();
- let state = Arc::new(network_proxy_state_for_policy(NetworkProxyConfig::default()));
+ let mut config = NetworkProxyConfig {
+ dangerously_allow_plaintext_credential_injection: true,
+ ..NetworkProxyConfig::default()
+ };
+ config.set_credential_broker_enabled(/*enabled*/ true);
+ let state = Arc::new(network_proxy_state_for_policy(config));
let proxy = match NetworkProxy::builder().state(state).build().await {
Ok(proxy) => proxy,
Err(err) => {
@@ -1995,6 +2031,39 @@ mod tests {
assert_eq!(launch.environment_id.as_deref(), Some("remote-env"));
assert_eq!(launch.execution_id.as_deref(), Some("execution-1"));
+ assert!(!launch.proxy.enabled);
+ for (enabled, mode, allowed_domain, proxy_url) in [
+ (false, config::NetworkMode::Full, Some("*"), None),
+ (false, config::NetworkMode::Full, Some("example.com"), None),
+ (
+ false,
+ config::NetworkMode::Full,
+ None,
+ Some("http://127.0.0.1:8123"),
+ ),
+ (true, config::NetworkMode::Full, None, None),
+ (true, config::NetworkMode::Limited, None, None),
+ ] {
+ let mut config = NetworkProxyConfig {
+ enabled,
+ mode,
+ ..NetworkProxyConfig::default()
+ };
+ if let Some(domain) = allowed_domain {
+ config.set_allowed_domains(vec![domain.to_string()]);
+ }
+ if let Some(proxy_url) = proxy_url {
+ config.proxy_url = proxy_url.to_string();
+ }
+ config.set_credential_broker_enabled(/*enabled*/ true);
+ let proxy = NetworkProxy::builder()
+ .state(Arc::new(network_proxy_state_for_policy(config)))
+ .build()
+ .await?;
+ let launch = proxy.remote_launch_config().await?;
+ assert!(launch.proxy.enabled);
+ assert_eq!(launch.proxy.mode, mode);
+ }
assert_eq!(
prepared
.env
diff --git a/codex-rs/network-proxy/src/runtime.rs b/codex-rs/network-proxy/src/runtime.rs
index 10f1367fa9..3cd1ec9f2a 100644
--- a/codex-rs/network-proxy/src/runtime.rs
+++ b/codex-rs/network-proxy/src/runtime.rs
@@ -167,6 +167,7 @@ fn blocked_request_violation_log_line(entry: &BlockedRequest) -> String {
#[derive(Clone)]
pub struct ConfigState {
pub config: NetworkProxyConfig,
+ pub(crate) brokerage_created_default_allowlist: bool,
pub allow_set: GlobSet,
pub deny_set: GlobSet,
pub mitm: Option<Arc<MitmState>>,
@@ -343,8 +344,10 @@ impl NetworkProxyState {
audit_metadata: NetworkProxyAuditMetadata,
blocked_request_observer: Option<Arc<dyn BlockedRequestObserver>>,
) -> Self {
+ let credential_broker = CredentialBroker::new(state.config.credential_broker);
+ credential_broker.configure(&state.config);
Self {
- credential_broker: CredentialBroker::new(state.config.credential_broker),
+ credential_broker,
state: Arc::new(RwLock::new(state)),
reloader,
blocked_request_observer: Arc::new(RwLock::new(blocked_request_observer)),
@@ -418,6 +421,14 @@ impl NetworkProxyState {
self.credential_broker.virtualize_child_env(env);
}
+ pub(crate) fn restore_child_credentials(
+ &self,
+ env: &mut HashMap<String, String>,
+ command: &mut [String],
+ ) {
+ self.credential_broker.restore_child_env(env, command);
+ }
+
pub fn inject_request_credentials(&self, host: &str, headers: &mut rama_http::HeaderMap) {
self.credential_broker.inject_request_headers(host, headers);
}
@@ -431,11 +442,22 @@ impl NetworkProxyState {
}
pub async fn current_cfg(&self) -> Result<NetworkProxyConfig> {
+ self.current_cfg_with_brokerage_provenance()
+ .await
+ .map(|(config, _)| config)
+ }
+
+ pub(crate) async fn current_cfg_with_brokerage_provenance(
+ &self,
+ ) -> Result<(NetworkProxyConfig, bool)> {
// Callers treat `NetworkProxyState` as a live view of policy. We reload-on-demand so edits to
// `config.toml` (including Codex-managed writes) take effect without a restart.
self.reload_if_needed().await?;
let guard = self.state.read().await;
- Ok(guard.config.clone())
+ Ok((
+ guard.config.clone(),
+ guard.brokerage_created_default_allowlist,
+ ))
}
pub async fn current_patterns(&self) -> Result<(Vec<String>, Vec<String>)> {
@@ -461,7 +483,7 @@ impl NetworkProxyState {
match self.reloader.reload_now().await {
Ok(mut new_state) => {
- self.ensure_credential_broker_enablement_unchanged(&new_state)?;
+ self.credential_broker.configure(&new_state.config);
// Policy changes are operationally sensitive; logging diffs makes changes traceable
// without needing to dump full config blobs (which can include unrelated settings).
log_policy_changes(&previous_cfg, &new_state.config);
@@ -484,7 +506,7 @@ impl NetworkProxyState {
pub async fn replace_config_state(&self, mut new_state: ConfigState) -> Result<()> {
self.reload_if_needed().await?;
- self.ensure_credential_broker_enablement_unchanged(&new_state)?;
+ self.credential_broker.configure(&new_state.config);
let mut guard = self.state.write().await;
log_policy_changes(&guard.config, &new_state.config);
new_state.blocked = guard.blocked.clone();
@@ -829,7 +851,7 @@ impl NetworkProxyState {
match self.reloader.maybe_reload().await? {
None => Ok(()),
Some(mut new_state) => {
- self.ensure_credential_broker_enablement_unchanged(&new_state)?;
+ self.credential_broker.configure(&new_state.config);
let (previous_cfg, blocked, blocked_total) = {
let guard = self.state.read().await;
(
@@ -851,14 +873,6 @@ impl NetworkProxyState {
}
}
}
-
- fn ensure_credential_broker_enablement_unchanged(&self, new_state: &ConfigState) -> Result<()> {
- anyhow::ensure!(
- self.credential_broker.enabled() == new_state.config.credential_broker,
- "network.credential_broker cannot change while the proxy is running"
- );
- Ok(())
- }
}
#[derive(Clone, Copy)]
@@ -1025,10 +1039,14 @@ fn unix_timestamp() -> i64 {
#[cfg(test)]
pub(crate) fn network_proxy_state_for_policy(
- mut network: crate::config::NetworkProxyConfig,
+ mut config: crate::config::NetworkProxyConfig,
) -> NetworkProxyState {
- network.enabled = true;
- let config = network;
+ let brokerage_created_default_allowlist =
+ config.credential_broker && !config.enabled && config.allowed_domains().is_none();
+ config.enabled = true;
+ if brokerage_created_default_allowlist {
+ config.set_allowed_domains(vec!["*".to_string()]);
+ }
let state = ConfigState {
allow_set: crate::policy::compile_allowlist_globset(
&config.allowed_domains().unwrap_or_default(),
@@ -1036,7 +1054,7 @@ pub(crate) fn network_proxy_state_for_policy(
.unwrap(),
blocked: VecDeque::new(),
blocked_total: 0,
- config: config.clone(),
+ brokerage_created_default_allowlist,
constraints: NetworkProxyConstraints::default(),
deny_set: crate::policy::compile_denylist_globset(
&config.denied_domains().unwrap_or_default(),
@@ -1044,6 +1062,7 @@ pub(crate) fn network_proxy_state_for_policy(
.unwrap(),
mitm: None,
mitm_hooks: crate::mitm_hook::compile_mitm_hooks(&config).unwrap(),
+ config,
};
NetworkProxyState::with_reloader(state, Arc::new(NoopReloader))
@@ -1128,16 +1147,17 @@ mod tests {
}
#[tokio::test]
- async fn reload_rejects_credential_broker_enablement_changes() {
- let initial_state = build_config_state(
- NetworkProxyConfig::default(),
- NetworkProxyConstraints::default(),
- )
- .unwrap();
- let mut reloaded_state = initial_state.clone();
- reloaded_state
- .config
- .set_credential_broker_enabled(/*enabled*/ true);
+ async fn reload_applies_credential_broker_enablement_changes() {
+ let config = NetworkProxyConfig {
+ enabled: true,
+ ..NetworkProxyConfig::default()
+ };
+ let initial_state =
+ build_config_state(config.clone(), NetworkProxyConstraints::default()).unwrap();
+ let mut reloaded_config = config;
+ reloaded_config.set_credential_broker_enabled(/*enabled*/ true);
+ let reloaded_state =
+ build_config_state(reloaded_config, NetworkProxyConstraints::default()).unwrap();
let state = NetworkProxyState::with_reloader(
initial_state,
Arc::new(StaticReloader {
@@ -1145,20 +1165,33 @@ mod tests {
}),
);
- let err = state
+ state
.force_reload()
.await
- .expect_err("credential broker enablement should require a proxy restart");
+ .expect("enable credential broker");
let mut env = HashMap::from([("OPENAI_API_KEY".to_string(), "sk-real".to_string())]);
+ state.virtualize_child_credentials(&mut env);
+ assert_ne!(env["OPENAI_API_KEY"], "sk-real");
+ }
+
+ #[test]
+ fn managed_disabled_proxy_does_not_virtualize_credentials() {
+ let mut config = NetworkProxyConfig::default();
+ config.set_credential_broker_enabled(/*enabled*/ true);
+ let config_state = build_config_state(
+ config,
+ NetworkProxyConstraints {
+ enabled: Some(false),
+ ..NetworkProxyConstraints::default()
+ },
+ )
+ .expect("managed-disabled credential broker should fail open");
+ let state = NetworkProxyState::with_reloader(config_state, Arc::new(NoopReloader));
+ let mut env = HashMap::from([("OPENAI_API_KEY".to_string(), "sk-real".to_string())]);
+
state.virtualize_child_credentials(&mut env);
- assert!(
- format!("{err:#}")
- .contains("network.credential_broker cannot change while the proxy is running"),
- "unexpected error: {err:#}"
- );
assert_eq!(env["OPENAI_API_KEY"], "sk-real");
- assert!(!state.credential_broker.enabled());
}
#[tokio::test]
@@ -1192,6 +1225,30 @@ mod tests {
state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),
HostBlockDecision::Blocked(HostBlockReason::NotAllowed)
);
+ for enabled in [false, true] {
+ let mut config = NetworkProxyConfig {
+ enabled,
+ ..NetworkProxyConfig::default()
+ };
+ config.set_credential_broker_enabled(/*enabled*/ true);
+ let config_state = build_config_state(config, NetworkProxyConstraints::default())
+ .expect("valid credential-broker configuration");
+ assert_eq!(config_state.brokerage_created_default_allowlist, !enabled);
+ let state = NetworkProxyState::with_reloader(config_state, Arc::new(NoopReloader));
+
+ assert_eq!(
+ state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),
+ if enabled {
+ HostBlockDecision::Blocked(HostBlockReason::NotAllowed)
+ } else {
+ HostBlockDecision::Allowed
+ }
+ );
+ assert_eq!(
+ state.host_blocked("127.0.0.1", /*port*/ 80).await.unwrap(),
+ HostBlockDecision::Blocked(HostBlockReason::NotAllowedLocal)
+ );
+ }
}
#[tokio::test]
diff --git a/codex-rs/network-proxy/src/state.rs b/codex-rs/network-proxy/src/state.rs
index 1d295618af..90731a8b4e 100644
--- a/codex-rs/network-proxy/src/state.rs
+++ b/codex-rs/network-proxy/src/state.rs
@@ -58,9 +58,22 @@ pub struct PartialNetworkProxyConfig {
}
pub fn build_config_state(
- config: NetworkProxyConfig,
+ mut config: NetworkProxyConfig,
constraints: NetworkProxyConstraints,
) -> anyhow::Result<ConfigState> {
+ if constraints.enabled == Some(false) {
+ config.credential_broker = false;
+ }
+ let brokerage_created_proxy = config.credential_broker && !config.enabled;
+ let brokerage_created_default_allowlist = brokerage_created_proxy
+ && config.allowed_domains().is_none()
+ && constraints.allowed_domains.is_none();
+ if brokerage_created_proxy {
+ config.enabled = true;
+ }
+ if brokerage_created_default_allowlist {
+ config.set_allowed_domains(vec!["*".to_string()]);
+ }
crate::config::validate_unix_socket_allowlist_paths(&config)?;
anyhow::ensure!(
!config.credential_broker || config.mitm,
@@ -82,6 +95,7 @@ pub fn build_config_state(
};
Ok(ConfigState {
config,
+ brokerage_created_default_allowlist,
allow_set,
deny_set,
mitm,