Lightweight coding agent that runs in your terminal
Rust
Mark built-in dummy credentials and strengthen collision checks (#56297)
viyatb-oaie4deed398182
diff --git a/codex-rs/core/tests/suite/scenarios_credential_masking.rs b/codex-rs/core/tests/suite/scenarios_credential_masking.rsindex 64e12e329d..9bf8fd1f05 100644--- a/codex-rs/core/tests/suite/scenarios_credential_masking.rs+++ b/codex-rs/core/tests/suite/scenarios_credential_masking.rs@@ -42,7 +42,7 @@ async fn remote_credential_masking_request_history(("OPENAI_API_KEY","sk-proj-executor-only-0000000000000000000000000000000000",- "sk-proj-",+ "sk-proj-masked",)};const CALL_ID: &str = "print-credential";diff --git a/codex-rs/exec-server/tests/exec_process.rs b/codex-rs/exec-server/tests/exec_process.rsindex 2fbd64dc20..68235743d8 100644--- a/codex-rs/exec-server/tests/exec_process.rs+++ b/codex-rs/exec-server/tests/exec_process.rs@@ -862,7 +862,7 @@ async fn shell_snapshot_v2_remote_managed_proxy_uses_prepared_execution_context(.split_once('|').context("command should expose the child API key")?;if expect_masking {- assert!(child_api_key.starts_with("sk-proj-"));+ assert!(child_api_key.starts_with("sk-proj-masked"));assert_ne!(child_api_key, API_KEY);assert!(!stdout.contains(API_KEY));} else {diff --git a/codex-rs/network-proxy/src/credential_broker.rs b/codex-rs/network-proxy/src/credential_broker.rsindex 7e8c019921..cd0dfa0e7f 100644--- a/codex-rs/network-proxy/src/credential_broker.rs+++ b/codex-rs/network-proxy/src/credential_broker.rs@@ -1642,6 +1642,44 @@ impl CredentialBrokerState {return None;}+ let mut alias_identities = Vec::new();+ if matches!(&provider, BrokeredCredentialProvider::Builtin(_))+ && !self.configured_providers.is_empty()+ {+ let context_keys = self.environment(existing_env).provider_context_keys;+ for (key, value) in existing_env {+ if key.eq_ignore_ascii_case("PATH")+ || key.to_ascii_uppercase().ends_with("_PATH")+ || crate::is_managed_proxy_env_var(key, value)+ || context_keys+ .iter()+ .any(|context| env_key_matches(key, context))+ {+ continue;+ }+ let known = matching::known_credential_matches(self, value, existing_env);+ let uncovered = matching::mask_known_credentials(value, &known);+ for configured in &self.configured_providers {+ for matched in configured.find_discoverable_credentials(&uncovered) {+ let value = &uncovered[matched.range.clone()];+ if value.contains('\0')+ || matching::is_operational_path_match(+ &uncovered,+ matched.range.start,+ matched.range.end,+ )+ {+ continue;+ }+ alias_identities.push((+ BrokeredCredentialProvider::Configured(Arc::clone(configured)),+ value.to_string(),+ ));+ }+ }+ }+ }+let Some(dummy_value) = (0..64).find_map(|_| {let candidate = provider.dummy_value(real_value)?;(candidate != real_value@@ -1656,10 +1694,51 @@ impl CredentialBrokerState {|| credential.real_value == candidate|| credential.contains_embedded_value(&candidate, &credential.dummy_value)|| credential.contains_embedded_value(&candidate, &credential.real_value)+ || is_builtin_shaped_credential(real_value)+ && credential.dummy_value.contains(&candidate)+ || provider.contains_embedded_value(&credential.dummy_value, &candidate)})- && !credential_provider_definitions(self).any(|other| {- !other.same_provider(&provider)- && other.recognizes_strictly_embedded_dummy_collision_in(&candidate)+ && match &provider {+ BrokeredCredentialProvider::Builtin(_) => {+ // Check observed identities even when their sources have not registered.+ !credential_provider_definitions(self).any(|owner_provider| {+ self.credential_owners.iter().any(|owner| {+ let owns_key = match &owner_provider {+ BrokeredCredentialProvider::Builtin(provider) => {+ provider.sources().iter().any(|source| {+ source.env_vars.iter().any(|key| {+ env_key_matches(key, &owner.env_var)+ })+ })+ }+ BrokeredCredentialProvider::Configured(provider) => provider+ .config+ .env+ .iter()+ .any(|key| env_key_matches(key, &owner.env_var)),+ };+ owns_key+ && (candidate == owner.real_value+ || is_builtin_shaped_credential(&owner.real_value)+ && candidate.contains(&owner.real_value)+ || owner_provider.contains_embedded_value(+ &candidate,+ &owner.real_value,+ ))+ })+ })+ }+ BrokeredCredentialProvider::Configured(_) => {+ !credential_provider_definitions(self).any(|other| {+ !other.same_provider(&provider)+ && other.recognizes_strictly_embedded_dummy_collision_in(&candidate)+ })+ }+ }+ && !alias_identities.iter().any(|(alias_provider, value)| {+ candidate == *value+ || is_builtin_shaped_credential(value) && candidate.contains(value)+ || alias_provider.contains_embedded_value(&candidate, value)})).then_some(candidate)}) else {diff --git a/codex-rs/network-proxy/src/credential_broker/configured_tests.rs b/codex-rs/network-proxy/src/credential_broker/configured_tests.rsindex f23f0f6c11..34699e8e00 100644--- a/codex-rs/network-proxy/src/credential_broker/configured_tests.rs+++ b/codex-rs/network-proxy/src/credential_broker/configured_tests.rs@@ -2109,6 +2109,101 @@ fn configured_provider_does_not_register_a_credential_inside_an_existing_dummy()assert_eq!(env["SECONDARY_TOKEN"], overlapping_real);}+#[test]+fn builtin_dummy_rejects_known_and_late_credential_collisions() {+ for (custom_real, known_before_builtin) in [("mask", true), ("mask", false), ("pass", false)] {+ let broker = broker_for(CredentialProviderConfig {+ env: vec!["CUSTOM_TOKEN".to_string()],+ patterns: if known_before_builtin {+ vec!["^[a-z]{4}$".to_string(), "^ghp_[A-Za-z0-9]+$".to_string()]+ } else {+ vec!["^(?:pass|mask)$".to_string()]+ },+ url_prefix_from_env: Some("CUSTOM_HOST".to_string()),+ ..CredentialProviderConfig::default()+ });+ if known_before_builtin {+ let mut unbound =+ HashMap::from([("CUSTOM_TOKEN".to_string(), custom_real.to_string())]);+ broker.virtualize_child_env(&mut unbound);+ assert!(broker.read_state().credentials.is_empty());+ }+ let github_real = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";+ let mut builtin_env = HashMap::from([("GH_TOKEN".to_string(), github_real.to_string())]);+ broker.virtualize_child_env(&mut builtin_env);+ let github_dummy = &builtin_env["GH_TOKEN"];+ if known_before_builtin {+ assert_eq!(github_dummy, github_real);+ assert!(broker.read_state().credentials.is_empty());+ continue;+ }+ assert!(github_dummy.starts_with("ghp_masked"));++ // The earlier dummy is not carried, so environment containment cannot reject the overlap.+ let mut late_env = HashMap::from([+ ("CUSTOM_TOKEN".to_string(), custom_real.to_string()),+ (+ "CUSTOM_HOST".to_string(),+ "api.provider.example".to_string(),+ ),+ ]);+ broker.virtualize_child_env(&mut late_env);+ assert_eq!(late_env["CUSTOM_TOKEN"], custom_real);+ assert_eq!(broker.read_state().credentials.len(), 1);++ let mut headers = HeaderMap::from_iter([(+ AUTHORIZATION,+ HeaderValue::from_str(&format!("Bearer {github_dummy}")).unwrap(),+ )]);+ broker.inject_request_headers("api.github.com", &mut headers);+ assert_eq!(headers[AUTHORIZATION], format!("Bearer {github_real}"));+ let mut restored = github_dummy.clone();+ assert!(broker.restore_text(&mut restored));+ assert_eq!(restored, github_real);++ let mut headers =+ HeaderMap::from_iter([(AUTHORIZATION, HeaderValue::from_static("Bearer mask"))]);+ broker.inject_request_headers("https://api.provider.example/", &mut headers);+ assert_eq!(headers[AUTHORIZATION], "Bearer mask");+ }++ let broker = broker_for(CredentialProviderConfig {+ env: vec!["CUSTOM_TOKEN".to_string()],+ patterns: vec!["mask[a-z]{2}".to_string()],+ url_prefixes: vec!["https://custom.example".to_string()],+ ..CredentialProviderConfig::default()+ });+ let github_real = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";+ let mut env = HashMap::from([+ ("GH_TOKEN".to_string(), github_real.to_string()),+ ("CUSTOM_ALIAS".to_string(), "masked".to_string()),+ ]);+ broker.virtualize_child_env(&mut env);+ assert_eq!(env["GH_TOKEN"], github_real);+ assert!(!env.contains_key("CUSTOM_TOKEN"));+ assert!(+ broker+ .read_state()+ .credentials+ .iter()+ .all(|credential| { credential.env_var == "CUSTOM_TOKEN" })+ );+ let alias_dummy = &env["CUSTOM_ALIAS"];+ assert_ne!(alias_dummy, "masked");+ let mut headers = HeaderMap::from_iter([(+ AUTHORIZATION,+ HeaderValue::from_str(&format!("Bearer {alias_dummy}")).unwrap(),+ )]);+ let original = headers.clone();+ broker.inject_request_headers("https://unrelated.example/", &mut headers);+ assert_eq!(headers, original);+ broker.inject_request_headers("https://custom.example/", &mut headers);+ assert_eq!(headers[AUTHORIZATION], "Bearer masked");+ let mut restored = alias_dummy.clone();+ assert!(broker.restore_text(&mut restored));+ assert_eq!(restored, "masked");+}+#[test]fn configured_provider_reload_preserves_credentials_and_rejects_overlapping_sources() {let token = "provider_abcdefghijklmnopqrstuvwx";diff --git a/codex-rs/network-proxy/src/credential_broker/providers.rs b/codex-rs/network-proxy/src/credential_broker/providers.rsindex 36adc873d1..725b73212d 100644--- a/codex-rs/network-proxy/src/credential_broker/providers.rs+++ b/codex-rs/network-proxy/src/credential_broker/providers.rs@@ -202,15 +202,13 @@ pub(super) fn translate_standard_request_header(}fn shaped_dummy_value(real_value: &str, prefix: &str, minimum_len: usize) -> String {- let target_len = real_value.len().max(minimum_len).max(prefix.len() + 16);+ let mut dummy = format!("{prefix}masked");+ // Keep over 128 bits of randomness after the visible marker.+ let target_len = real_value.len().max(minimum_len).max(dummy.len() + 22);+ dummy.reserve(target_len - dummy.len());let mut rng = rand::rng();- let mut dummy = String::with_capacity(target_len);- dummy.push_str(prefix);- for index in prefix.len()..target_len {- let character = match real_value.as_bytes().get(index).copied() {- Some(template) if !template.is_ascii_alphanumeric() => template,- _ => DUMMY_ALPHANUMERIC[rng.random_range(0..DUMMY_ALPHANUMERIC.len())],- };+ for _ in dummy.len()..target_len {+ let character = DUMMY_ALPHANUMERIC[rng.random_range(0..DUMMY_ALPHANUMERIC.len())];dummy.push(char::from(character));}dummydiff --git a/codex-rs/network-proxy/src/credential_broker_tests.rs b/codex-rs/network-proxy/src/credential_broker_tests.rsindex fc7c356725..cace43523e 100644--- a/codex-rs/network-proxy/src/credential_broker_tests.rs+++ b/codex-rs/network-proxy/src/credential_broker_tests.rs@@ -34,16 +34,13 @@ fn authorization(headers: &HeaderMap) -> Option<&str> {fn assert_credential_shape(real_value: &str, dummy_value: &str, prefix: &str) {assert_ne!(dummy_value, real_value);- assert_eq!(dummy_value.len(), real_value.len());- assert_eq!(&dummy_value[..prefix.len()], prefix);- let same_shape = real_value- .bytes()- .zip(dummy_value.bytes())- .skip(prefix.len())- .all(|(real, dummy)| {- real.is_ascii_alphanumeric() && dummy.is_ascii_alphanumeric() || real == dummy- });- assert!(same_shape);+ assert!(dummy_value.len() >= real_value.len());+ let marker = format!("{prefix}masked");+ let suffix = dummy_value+ .strip_prefix(&marker)+ .expect("masked credential");+ assert!(suffix.len() >= 22);+ assert!(suffix.bytes().all(|byte| byte.is_ascii_alphanumeric()));}#[test]@@ -754,8 +751,12 @@ fn virtualize_child_env_keeps_adjacent_provider_credentials_separate() {let dummy_bundle = env["AUTH_BUNDLE"].clone();assert!(!dummy_bundle.contains(github_token));assert!(!dummy_bundle.contains(openai_token));- let github_dummy = &dummy_bundle[..github_token.len()];- let openai_dummy = &dummy_bundle[github_token.len() + 1..];+ let (github_dummy, openai_suffix) = dummy_bundle+ .split_once("_sk-proj-")+ .expect("separate provider credentials");+ let openai_dummy = format!("sk-proj-{openai_suffix}");+ assert_credential_shape(github_token, github_dummy, "ghp_");+ assert_credential_shape(openai_token, &openai_dummy, "sk-proj-");let mut github_headers = headers_with_bearer(github_dummy);broker.inject_request_headers("api.github.com", &mut github_headers);@@ -764,7 +765,7 @@ fn virtualize_child_env_keeps_adjacent_provider_credentials_separate() {Some(format!("Bearer {github_token}").as_str()));- let mut openai_headers = headers_with_bearer(openai_dummy);+ let mut openai_headers = headers_with_bearer(&openai_dummy);broker.inject_request_headers("api.openai.com", &mut openai_headers);assert_eq!(authorization(&openai_headers),@@ -898,13 +899,42 @@ fn brokered_credential_value_env_keys_include_dummy_aliases() {#[test]fn virtualize_child_env_uses_fresh_dummy_capabilities() {- let mut first_env = env_map([("OPENAI_API_KEY", "sk-proj-abcdefghijklmnopqrstuvwxyz")]);- let mut second_env = first_env.clone();-- CredentialBroker::new(/*enabled*/ true).virtualize_child_env(&mut first_env);- CredentialBroker::new(/*enabled*/ true).virtualize_child_env(&mut second_env);+ for (source, real_value, prefix) in [+ ("GH_TOKEN", "ghp_short", "ghp_"),+ ("GH_TOKEN", "opaque:.credential/🦀", "ghp_"),+ ("OPENAI_API_KEY", "sk-proj-short", "sk-proj-"),+ ("OPENAI_API_KEY", "sk-svcacct-short", "sk-svcacct-"),+ ("OPENAI_API_KEY", "opaque:.credential/🦀", "sk-"),+ ] {+ let mut first_env = env_map([(source, real_value)]);+ let mut second_env = first_env.clone();++ for env in [&mut first_env, &mut second_env] {+ let broker = CredentialBroker::new(/*enabled*/ true);+ broker.configure(&NetworkProxyConfig {+ credential_broker: true,+ credential_providers: BTreeMap::from([(+ "custom".to_string(),+ CredentialProviderConfig {+ env: vec!["CUSTOM_TOKEN".to_string()],+ patterns: vec![+ "^ghp_[A-Za-z0-9]+$".to_string(),+ "^sk-proj-[A-Za-z0-9]+$".to_string(),+ "^[a-z]{4}$".to_string(),+ ],+ url_prefixes: vec!["https://custom.example".to_string()],+ ..CredentialProviderConfig::default()+ },+ )]),+ ..NetworkProxyConfig::default()+ });+ broker.virtualize_child_env(env);+ }- assert_ne!(first_env["OPENAI_API_KEY"], second_env["OPENAI_API_KEY"]);+ assert_credential_shape(real_value, &first_env[source], prefix);+ assert_credential_shape(real_value, &second_env[source], prefix);+ assert_ne!(first_env[source], second_env[source]);+ }}#[test]@@ -1076,10 +1106,14 @@ fn inject_request_headers_requires_dummy_and_preserves_explicit_authorization()broker.inject_request_headers("api.openai.com", &mut headers);assert_eq!(authorization(&headers), Some("Bearer sk-real"));- let mut explicit_headers = headers_with_bearer("sk-explicit");- broker.inject_request_headers("api.openai.com", &mut explicit_headers);-- assert_eq!(authorization(&explicit_headers), Some("Bearer sk-explicit"));+ for explicit_value in [+ "sk-explicit",+ "sk-masked000000000000000000000000000000000000000000",+ ] {+ let mut explicit_headers = headers_with_bearer(explicit_value);+ broker.inject_request_headers("api.openai.com", &mut explicit_headers);+ assert_eq!(explicit_headers, headers_with_bearer(explicit_value));+ }}#[test]