Lightweight coding agent that runs in your terminal
Rust
Harden credential handling in shell snapshots and replay (#44040)
Winston Howesec512d23470c
diff --git a/codex-rs/config/src/loader/tests.rs b/codex-rs/config/src/loader/tests.rsindex 412167fd68..9be08e94f1 100644--- a/codex-rs/config/src/loader/tests.rs+++ b/codex-rs/config/src/loader/tests.rs@@ -971,14 +971,16 @@ async fn local_layers_keep_raw_paths_order_and_legacy_requirements() {std::fs::write(&system_file,"model_instructions_file='./system.md'\n\- [shell_environment_policy.set]\nGH_HOST='github.stale.example'\n",+ [shell_environment_policy.set]\nGH_HOST='github.stale.example'\n\+ GH_ENTERPRISE_TOKEN='ghp_stale'\n",).expect("write stale system GitHub host");std::fs::write(&user_file,format!("{}\n[features.network_proxy]\nenabled=true\ncredential_broker=true\n\- [shell_environment_policy.set]\ngh_host='github.trusted.example'\n",+ [shell_environment_policy.set]\ngh_host='github.trusted.example'\n\+ gh_enterprise_token='ghp_trusted'\n",user_config("trusted")),)@@ -1007,6 +1009,8 @@ async fn local_layers_keep_raw_paths_order_and_legacy_requirements() {Some("github.trusted.example"));assert!(!binding.contains_key("GH_HOST"));+ assert!(!binding.contains_key("gh_enterprise_token"));+ assert!(!binding.contains_key("GH_ENTERPRISE_TOKEN"));}std::fs::write(&user_file, user_config("untrusted")).expect("write user config");diff --git a/codex-rs/config/src/merge.rs b/codex-rs/config/src/merge.rsindex 14a5c5a5af..177436cf60 100644--- a/codex-rs/config/src/merge.rs+++ b/codex-rs/config/src/merge.rs@@ -1,6 +1,6 @@use crate::key_aliases::normalize_key_aliases;use crate::key_aliases::normalized_with_key_aliases;-use codex_network_proxy::credential_broker_provider_context_env_keys;+use codex_network_proxy::is_credential_broker_provider_env_key;use codex_network_proxy::normalize_host;use toml::Value as TomlValue;@@ -109,10 +109,10 @@ fn merge_toml_values_at_path(base: &mut TomlValue, overlay: &TomlValue, path: &mif cfg!(windows)&& matches!(path.as_slice(), [policy, field] if policy == "shell_environment_policy" && field == "set"){- for key in overlay_table.keys().filter(|key| {- credential_broker_provider_context_env_keys()- .any(|binding_key| key.eq_ignore_ascii_case(binding_key))- }) {+ for key in overlay_table+ .keys()+ .filter(|key| is_credential_broker_provider_env_key(key))+ {base_table.retain(|candidate, _| {candidate == key || !candidate.eq_ignore_ascii_case(key)});diff --git a/codex-rs/core/src/exec.rs b/codex-rs/core/src/exec.rsindex fc1b99ffcc..95b78ebace 100644--- a/codex-rs/core/src/exec.rs+++ b/codex-rs/core/src/exec.rs@@ -119,6 +119,8 @@ pub enum ExecCapturePolicy {FullBuffer,/// Internal helpers that need complete output but must honor timeout and cancellation.FullBufferWithExpiration,+ /// Full-buffer helpers that honor expiration and suppress unredacted sandbox diagnostics.+ SensitiveFullBuffer,}fn select_process_exec_tool_sandbox_type(@@ -268,7 +270,7 @@ impl ExecCapturePolicy {fn retained_bytes_cap(self) -> Option<usize> {match self {Self::ShellTool => Some(EXEC_OUTPUT_MAX_BYTES),- Self::FullBuffer | Self::FullBufferWithExpiration => None,+ Self::FullBuffer | Self::FullBufferWithExpiration | Self::SensitiveFullBuffer => None,}}@@ -278,7 +280,7 @@ impl ExecCapturePolicy {fn uses_expiration(self) -> bool {match self {- Self::ShellTool | Self::FullBufferWithExpiration => true,+ Self::ShellTool | Self::FullBufferWithExpiration | Self::SensitiveFullBuffer => true,Self::FullBuffer => false,}}@@ -470,7 +472,7 @@ pub(crate) async fn execute_exec_request().await;let duration = start.elapsed();- finalize_exec_result(raw_output_result, sandbox, duration)+ finalize_exec_result(raw_output_result, sandbox, duration, capture_policy)}#[allow(clippy::too_many_arguments)]@@ -748,6 +750,7 @@ fn finalize_exec_result(raw_output_result: std::result::Result<RawExecToolCallOutput, CodexErr>,sandbox_type: SandboxType,duration: Duration,+ capture_policy: ExecCapturePolicy,) -> Result<ExecToolCallOutput> {match raw_output_result {Ok(raw_output) => {@@ -789,7 +792,9 @@ fn finalize_exec_result(}if is_likely_sandbox_denied(sandbox_type, &exec_output) {- record_filesystem_sandbox_violation(sandbox_type, &exec_output);+ if capture_policy != ExecCapturePolicy::SensitiveFullBuffer {+ record_filesystem_sandbox_violation(sandbox_type, &exec_output);+ }return Err(CodexErr::Sandbox(SandboxErr::Denied {output: Box::new(exec_output),network_policy_decision: None,@@ -1070,7 +1075,10 @@ async fn consume_output(let mut stdout_handle = stdout_handle;let mut stderr_handle = stderr_handle;- let (stdout, stderr) = if capture_policy == ExecCapturePolicy::FullBufferWithExpiration {+ let (stdout, stderr) = if matches!(+ capture_policy,+ ExecCapturePolicy::FullBufferWithExpiration | ExecCapturePolicy::SensitiveFullBuffer+ ) {let mut stdout_done = false;let mut stderr_done = false;let drain = async {diff --git a/codex-rs/core/src/exec_tests.rs b/codex-rs/core/src/exec_tests.rsindex b343126dd5..fde92af514 100644--- a/codex-rs/core/src/exec_tests.rs+++ b/codex-rs/core/src/exec_tests.rs@@ -341,16 +341,20 @@ enum CaptureDrainFailure {}#[cfg(unix)]-#[test_case("stdout", CaptureDrainFailure::Cancellation; "cancel_stdout")]-#[test_case("stderr", CaptureDrainFailure::Cancellation; "cancel_stderr")]-#[test_case("stdout", CaptureDrainFailure::Timeout; "timeout_stdout")]-#[test_case("stderr", CaptureDrainFailure::Timeout; "timeout_stderr")]-#[test_case("stdout", CaptureDrainFailure::DrainTimeout; "incomplete_stdout")]-#[test_case("stderr", CaptureDrainFailure::DrainTimeout; "incomplete_stderr")]+#[test_case("stdout", CaptureDrainFailure::Cancellation, ExecCapturePolicy::FullBufferWithExpiration; "cancel_stdout")]+#[test_case("stderr", CaptureDrainFailure::Cancellation, ExecCapturePolicy::FullBufferWithExpiration; "cancel_stderr")]+#[test_case("stdout", CaptureDrainFailure::Timeout, ExecCapturePolicy::FullBufferWithExpiration; "timeout_stdout")]+#[test_case("stderr", CaptureDrainFailure::Timeout, ExecCapturePolicy::FullBufferWithExpiration; "timeout_stderr")]+#[test_case("stdout", CaptureDrainFailure::DrainTimeout, ExecCapturePolicy::FullBufferWithExpiration; "incomplete_stdout")]+#[test_case("stderr", CaptureDrainFailure::DrainTimeout, ExecCapturePolicy::FullBufferWithExpiration; "incomplete_stderr")]+#[test_case("stdout", CaptureDrainFailure::Cancellation, ExecCapturePolicy::SensitiveFullBuffer; "sensitive_cancel")]+#[test_case("stderr", CaptureDrainFailure::Timeout, ExecCapturePolicy::SensitiveFullBuffer; "sensitive_timeout")]+#[test_case("stdout", CaptureDrainFailure::DrainTimeout, ExecCapturePolicy::SensitiveFullBuffer; "sensitive_drain_timeout")]#[tokio::test]async fn full_buffer_expiration_cleans_up_after_leader_exit(pipe: &str,failure: CaptureDrainFailure,+ capture_policy: ExecCapturePolicy,) -> anyhow::Result<()> {let dir = tempfile::tempdir()?;let redirect = match pipe {@@ -379,7 +383,7 @@ async fn full_buffer_expiration_cleans_up_after_leader_exit(let capture = consume_output(child,expiration,- ExecCapturePolicy::FullBufferWithExpiration,+ capture_policy,/*stdout_stream*/ None,);let after_leader_exit = async {diff --git a/codex-rs/core/src/shell_snapshot.rs b/codex-rs/core/src/shell_snapshot.rsindex ad48f88ed7..c8b689dbf2 100644--- a/codex-rs/core/src/shell_snapshot.rs+++ b/codex-rs/core/src/shell_snapshot.rs@@ -20,7 +20,10 @@ use codex_network_proxy::NetworkProxy;use codex_network_proxy::brokered_credential_binding_env_keys;use codex_network_proxy::brokered_credential_dummy_env_keys;use codex_network_proxy::brokered_credential_env_keys;+use codex_network_proxy::brokered_credential_marker_env_keys;+use codex_network_proxy::brokered_credential_value_env_keys;use codex_network_proxy::credential_broker_provider_context_env_keys;+use codex_network_proxy::credential_broker_provider_sources_allowed;use codex_network_proxy::is_credential_broker_provider_env_key;use codex_otel::SessionTelemetry;use codex_protocol::ThreadId;@@ -80,8 +83,13 @@ struct SnapshotCredentials {network_proxy: NetworkProxy,broker_config_revision: u64,shell_environment_policy: ShellEnvironmentPolicy,+ protected_startup_env: Option<String>,credential_env: HashMap<String, String>,+ unset_credential_keys: Vec<String>,+ // Retain discovered key identity even when policy replaces or removes its value.+ startup_credential_keys: Vec<String>,context_env: HashMap<String, String>,+ fail_open_aliases: HashMap<String, FailOpenAlias>,context_credential_keys: HashMap<String, Vec<String>>,binding_context_credential_keys: HashMap<String, Vec<String>>,}@@ -92,6 +100,12 @@ struct SnapshotCredentialBroker {allow_login_shell: bool,}+struct FailOpenAlias {+ value: String,+ dummy_value: Option<String>,+ authorized: bool,+}+const SNAPSHOT_TIMEOUT: Duration = Duration::from_secs(10);const SNAPSHOT_RETENTION: Duration = Duration::from_secs(60 * 60 * 24 * 3); // 3 days retention.const SNAPSHOT_DIR: &str = "shell_snapshots";@@ -332,6 +346,18 @@ impl ShellSnapshotFile {self.path.clone()}+ pub(crate) fn protected_startup_env(&self) -> Option<&str> {+ self.credentials+ .as_ref()+ .and_then(|credentials| credentials.protected_startup_env.as_deref())+ }++ pub(crate) fn startup_credential_keys(&self) -> &[String] {+ self.credentials.as_ref().map_or(&[], |credentials| {+ credentials.startup_credential_keys.as_slice()+ })+ }+pub(crate) fn restore_credentials(&self,env: &mut HashMap<String, String>,@@ -341,7 +367,7 @@ impl ShellSnapshotFile {return;};- let allowed_snapshot_env = create_env_from_vars(+ let mut allowed_snapshot_env = create_env_from_vars(credentials.credential_env.iter()@@ -351,6 +377,12 @@ impl ShellSnapshotFile {/*thread_id*/ None,);let explicit_env_overrides = &shell_environment_policy.r#set;+ for key in &credentials.unset_credential_keys {+ if !contains_env_key(explicit_env_overrides, key) {+ remove_env_value(env, key);+ remove_env_value(&mut allowed_snapshot_env, key);+ }+ }let mut snapshot_real_credentials = credentials.credential_env.clone();snapshot_real_credentials.insert(CREDENTIAL_BROKER_ACTIVE_ENV_KEY.to_string(),@@ -361,12 +393,13 @@ impl ShellSnapshotFile {.restore_brokered_credentials(&mut snapshot_real_credentials, &mut []);let mut restored_credential_keys = Vec::new();for (key, value) in &credentials.credential_env {- if explicit_env_overrides.contains_key(key) || !allowed_snapshot_env.contains_key(key) {+ if contains_env_key(explicit_env_overrides, key)+ || !contains_env_key(&allowed_snapshot_env, key)+ {continue;}- let current = env.entry(key.clone()).or_default();- if snapshot_real_credentials.get(key) != Some(current) {- current.clone_from(value);+ if snapshot_real_credentials.get(key) != env_value(env, key) {+ insert_env_value(env, key, value);restored_credential_keys.push(key);}}@@ -374,11 +407,11 @@ impl ShellSnapshotFile {let Some(credential_keys) = credentials.context_credential_keys.get(key) else {continue;};- if explicit_env_overrides.contains_key(key)- || !allowed_snapshot_env.contains_key(key)+ if contains_env_key(explicit_env_overrides, key)+ || !contains_env_key(&allowed_snapshot_env, key)|| !credential_keys.iter()- .any(|credential_key| allowed_snapshot_env.contains_key(credential_key))+ .any(|credential_key| contains_env_key(&allowed_snapshot_env, credential_key)){continue;}@@ -390,8 +423,8 @@ impl ShellSnapshotFile {.iter().any(|credential_key| restored_credential_keys.contains(&credential_key))});- if restores_binding_context || !env.contains_key(key) {- env.insert(key.clone(), value.clone());+ if restores_binding_context || !contains_env_key(env, key) {+ insert_env_value(env, key, value);}}@@ -408,6 +441,57 @@ impl ShellSnapshotFile {env.remove(CREDENTIAL_BROKER_ACTIVE_ENV_KEY);}}++ pub(crate) fn restore_fail_open_aliases(&self, env: &mut HashMap<String, String>) {+ let Some(credentials) = self.credentials.as_ref() else {+ return;+ };+ if env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY).is_some_and(|active| active == "1") {+ for (key, alias) in &credentials.fail_open_aliases {+ let has_snapshot_dummy = alias+ .dummy_value+ .as_ref()+ .is_some_and(|dummy| env_value(env, key) == Some(dummy));+ if has_snapshot_dummy {+ if !alias.authorized {+ remove_env_value(env, key);+ }+ continue;+ }+ if env_value(env, key).is_some_and(|value| {+ let mut virtualized = value.clone();+ !credentials+ .network_proxy+ .virtualize_brokered_text(&mut virtualized, env)+ }) {+ remove_env_value(env, key);+ }+ }+ return;+ }++ let policy = &credentials.shell_environment_policy;+ for (key, alias) in &credentials.fail_open_aliases {+ if contains_env_key(&policy.r#set, key)+ || credentials.unset_credential_keys.contains(key)+ {+ continue;+ }+ let has_snapshot_dummy = alias+ .dummy_value+ .as_ref()+ .is_some_and(|dummy| env_value(env, key) == Some(dummy));+ if has_snapshot_dummy {+ if alias.authorized {+ insert_env_value(env, key, &alias.value);+ } else {+ remove_env_value(env, key);+ }+ } else if alias.authorized && !contains_env_key(env, key) {+ insert_env_value(env, key, &alias.value);+ }+ }+ }}impl Drop for ShellSnapshotFile {@@ -499,6 +583,11 @@ async fn capture_snapshot(.filter_map(|entry| entry.split_once('=')).map(|(key, value)| (key.to_string(), value.to_string())).collect::<HashMap<_, _>>();+ // The inherited broker marker survives startup even when its credential variables do not.+ let mut unset_credential_keys = brokered_credential_marker_env_keys(&original_env)+ .into_iter()+ .filter(|key| !contains_env_key(&original_env, key))+ .collect::<Vec<_>>();let policy = &credential_broker.shell_environment_policy;let inherited_env = create_env_from_vars(std::env::vars(), policy, /*thread_id*/ None);let mut restored_env = original_env.clone();@@ -512,11 +601,11 @@ async fn capture_snapshot(credential_broker_provider_context_env_keys(),);for (key, value) in &policy.r#set {- if !discovery_env.contains_key(key)+ if !contains_env_key(&discovery_env, key)|| credential_broker_provider_context_env_keys().any(|context_key| context_key.eq_ignore_ascii_case(key)){- discovery_env.insert(key.clone(), value.clone());+ insert_env_value(&mut discovery_env, key, value);}}credential_broker@@ -537,15 +626,128 @@ async fn capture_snapshot();credential_broker.network_proxy.apply_to_env(&mut env);let allowed_brokered_keys = brokered_credential_dummy_env_keys(&env);+ let unbrokered_credentials: HashMap<String, String> = env+ .iter()+ .filter(|(key, _)| {+ is_credential_broker_provider_env_key(key)+ && !credential_broker_provider_context_env_keys()+ .any(|context| context.eq_ignore_ascii_case(key))+ && !allowed_brokered_keys.contains(key)+ })+ .map(|(key, value)| (key.clone(), value.clone()))+ .collect();+ let protected_startup_env = capture.startup_environment.as_ref().and_then(|startup| {+ let startup_env = String::from_utf8_lossy(startup.environment)+ .split('\0')+ .filter_map(|entry| entry.split_once('='))+ .map(|(key, value)| (key.to_string(), value.to_string()))+ .collect::<HashMap<_, _>>();+ original_env+ .iter()+ .any(|(key, value)| {+ env_value(&startup_env, key) != Some(value) && {+ let mut virtualized = value.clone();+ credential_broker+ .network_proxy+ .virtualize_brokered_text(&mut virtualized, &env);+ virtualized != *value+ }+ })+ .then(|| startup.path.to_string())+ });+ let mut brokered_alias_keys = Vec::new();+ let fail_open_aliases: HashMap<String, FailOpenAlias> = env+ .iter()+ .filter(|(key, _)| !is_credential_broker_provider_env_key(key))+ .filter_map(|(key, value)| {+ let mut real_value = env_value(&restored_env, key)+ .or_else(|| env_value(&policy.r#set, key))?+ .clone();+ let restored_dummy = credential_broker+ .network_proxy+ .restore_brokered_text(&mut real_value);+ let mut virtualized = real_value.clone();+ let virtualized_allowed = credential_broker+ .network_proxy+ .virtualize_brokered_text(&mut virtualized, &env);+ let has_brokered_source = brokered_keys.iter().any(|source| {+ env_value(&restored_env, source)+ .or_else(|| env_value(&policy.r#set, source))+ .is_some_and(|source_value| {+ real_value == *source_value+ || source_value.len() >= 16 && real_value.contains(source_value)+ })+ });+ let brokered_alias = !has_brokered_source+ && real_value != *value+ && (restored_dummy || virtualized_allowed && virtualized == *value);+ if !brokered_alias && virtualized_allowed {+ return None;+ }+ if brokered_alias {+ brokered_alias_keys.push(key.clone());+ }++ let authorized = credential_broker_provider_sources_allowed(+ &real_value,+ if brokered_alias { value } else { &virtualized },+ &restored_env,+ |source| {+ let allowed_sources = create_env_from_vars(+ std::iter::once((source.to_string(), "1".to_string())),+ policy,+ /*thread_id*/ None,+ );+ env_value(&allowed_sources, source)+ .is_some_and(|source_value| !source_value.is_empty())+ && env_value(&policy.r#set, source).is_none_or(|source_value| {+ env_value(&restored_env, source) == Some(source_value)+ })+ },+ );+ Some((+ key.clone(),+ FailOpenAlias {+ value: real_value,+ dummy_value: brokered_alias.then(|| value.clone()),+ authorized,+ },+ ))+ })+ .collect();+ // Known unbound credentials also need live source references for their aliases.+ let mut snapshot_credential_keys = brokered_keys.clone();+ snapshot_credential_keys.extend(+ restored_env+ .iter()+ .filter(|&(key, value)| {+ is_credential_broker_provider_env_key(key)+ && !credential_broker_provider_context_env_keys()+ .any(|context| context.eq_ignore_ascii_case(key))+ && !value.is_empty()+ })+ .map(|(key, _)| key.clone()),+ );+ snapshot_credential_keys.sort_unstable();+ snapshot_credential_keys.dedup();+ let mut allowed_snapshot_credential_keys = allowed_brokered_keys.clone();+ allowed_snapshot_credential_keys.extend(+ unbrokered_credentials+ .iter()+ .filter(|(_, value)| !value.is_empty())+ .map(|(key, _)| key.clone()),+ );let mut snapshot_env = env.clone();for key in credential_broker_provider_context_env_keys() {- if original_env.get(key) != env.get(key) {- snapshot_env.remove(key);+ if env_value(&original_env, key) != env_value(&env, key) {+ remove_env_value(&mut snapshot_env, key);}}- let PreparedSnapshot {- script: snapshot, ..- } = prepare_snapshot_credentials(+ let Some(PreparedSnapshot {+ script: snapshot,+ aliases: mut credential_env,+ rejected_alias_keys,+ }) = prepare_snapshot_credentials(&capture,SnapshotCredentialEnvironment {original: &original_env,@@ -561,9 +763,9 @@ async fn capture_snapshot().contains_key(key)},- brokered_keys: &brokered_keys,- brokered_alias_keys: &[],- allowed_brokered_keys: &allowed_brokered_keys,+ brokered_keys: &snapshot_credential_keys,+ brokered_alias_keys: &brokered_alias_keys,+ allowed_brokered_keys: &allowed_snapshot_credential_keys,},|value| {credential_broker@@ -571,12 +773,51 @@ async fn capture_snapshot(.virtualize_brokered_text(value, &env)},)- .ok_or_else(|| anyhow!("shell snapshot contains a credential outside supported exports"))?;+ else {+ bail!("shell snapshot contains a brokered credential outside exported environment");+ };+ let mut startup_credential_keys = brokered_credential_value_env_keys(&discovery_env);+ startup_credential_keys.extend(unbrokered_credentials.keys().cloned());+ unset_credential_keys.extend(rejected_alias_keys.into_iter().filter(|key| {+ startup_credential_keys.contains(key)+ || env_value(&original_env, key).is_some_and(|value| {+ snapshot_credential_keys.iter().any(|source| {+ !brokered_keys.contains(source)+ && env_value(&restored_env, source).is_some_and(|real| {+ value == real || real.len() >= 16 && value.contains(real)+ })+ })+ })+ }));- let credential_env = allowed_brokered_keys- .iter()- .filter_map(|key| env.get(key).map(|value| (key.clone(), value.clone())))- .collect();+ credential_env.extend(+ allowed_brokered_keys+ .iter()+ .filter_map(|key| env_value(&env, key).map(|value| (key.clone(), value.clone()))),+ );+ credential_env.extend(unbrokered_credentials);+ for key in &brokered_alias_keys {+ if fail_open_aliases+ .get(key)+ .is_some_and(|alias| alias.authorized)+ && let Some(value) = env_value(&env, key)+ {+ credential_env.insert(key.clone(), value.clone());+ } else {+ unset_credential_keys.push(key.clone());+ }+ }+ unset_credential_keys.extend(+ startup_credential_keys+ .iter()+ .filter(|key| !contains_env_key(&env, key))+ .cloned(),+ );+ unset_credential_keys.sort_unstable();+ unset_credential_keys.dedup();+ startup_credential_keys.extend(unset_credential_keys.iter().cloned());+ startup_credential_keys.sort_unstable();+ startup_credential_keys.dedup();let mut context_credential_keys = HashMap::<String, Vec<String>>::new();let mut binding_context_credential_keys = HashMap::<String, Vec<String>>::new();for key in &allowed_brokered_keys {@@ -600,7 +841,7 @@ async fn capture_snapshot(}let context_env = context_credential_keys.keys()- .filter_map(|key| env.get(key).map(|value| (key.clone(), value.clone())))+ .filter_map(|key| env_value(&env, key).map(|value| (key.clone(), value.clone()))).collect();Ok((snapshot,@@ -608,8 +849,12 @@ async fn capture_snapshot(network_proxy: credential_broker.network_proxy.clone(),broker_config_revision,shell_environment_policy: policy.clone(),+ protected_startup_env,credential_env,+ unset_credential_keys,+ startup_credential_keys,context_env,+ fail_open_aliases,context_credential_keys,binding_context_credential_keys,}),@@ -622,12 +867,41 @@ fn replace_provider_context_with_inherited(context_keys: impl Iterator<Item = &'static str>,) {for key in context_keys {- if let Some(value) = inherited_env.get(key) {- env.insert(key.to_string(), value.clone());+ if let Some(value) = env_value(inherited_env, key) {+ insert_env_value(env, key, value);}}}+fn contains_env_key(env: &HashMap<String, String>, key: &str) -> bool {+ env_value(env, key).is_some()+}++fn env_value<'a>(env: &'a HashMap<String, String>, key: &str) -> Option<&'a String> {+ env.get(key).or_else(|| {+ cfg!(windows)+ .then(|| {+ env.iter().find_map(|(candidate, value)| {+ candidate.eq_ignore_ascii_case(key).then_some(value)+ })+ })+ .flatten()+ })+}++fn insert_env_value(env: &mut HashMap<String, String>, key: &str, value: &str) {+ #[cfg(windows)]+ env.retain(|candidate, _| !candidate.eq_ignore_ascii_case(key));+ env.insert(key.to_string(), value.to_string());+}++fn remove_env_value(env: &mut HashMap<String, String>, key: &str) {+ #[cfg(windows)]+ env.retain(|candidate, _| !candidate.eq_ignore_ascii_case(key));+ #[cfg(not(windows))]+ env.remove(key);+}+#[derive(Clone, Copy)]enum SnapshotShellMode<'a> {Login,@@ -676,30 +950,10 @@ async fn run_script_with_timeout(let mut prepared_env = None;if let Some(credential_broker) = credential_broker {let policy = &credential_broker.shell_environment_policy;- let mut inherited_policy = policy.clone();- inherited_policy.r#set.clear();- let mut env =- create_env_from_vars(std::env::vars(), &inherited_policy, /*thread_id*/ None);- env.extend(- policy- .r#set- .iter()- .filter(|(key, _)| {- (is_credential_broker_provider_env_key(key)- || matches!(- (shell.shell_type, key.as_str()),- (ShellType::Zsh, "ZDOTDIR") | (ShellType::Bash, "BASH_ENV")- ))- && (policy.include_only.is_empty()- || policy- .include_only- .iter()- .any(|pattern| pattern.matches(key)))- })- .map(|(key, value)| (key.clone(), value.clone())),- );+ let mut env = create_env_from_vars(std::env::vars(), policy, /*thread_id*/ None);if suppress_startup_files {env.remove("BASH_ENV");+ env.remove("ENV");}credential_broker.network_proxy.apply_to_env(&mut env);prepared_env = Some(env);diff --git a/codex-rs/core/src/shell_snapshot_sandbox.rs b/codex-rs/core/src/shell_snapshot_sandbox.rsindex 3d3b924594..758aa3dbd5 100644--- a/codex-rs/core/src/shell_snapshot_sandbox.rs+++ b/codex-rs/core/src/shell_snapshot_sandbox.rs@@ -197,7 +197,7 @@ impl ShellSnapshotSandbox {request,ExecOptions {expiration,- capture_policy: ExecCapturePolicy::FullBufferWithExpiration,+ capture_policy: ExecCapturePolicy::SensitiveFullBuffer,},workspace_roots,)diff --git a/codex-rs/core/src/shell_snapshot_tests.rs b/codex-rs/core/src/shell_snapshot_tests.rsindex 6ca44a49e9..9222989e8f 100644--- a/codex-rs/core/src/shell_snapshot_tests.rs+++ b/codex-rs/core/src/shell_snapshot_tests.rs@@ -2,6 +2,12 @@ use super::*;#[cfg(unix)]use crate::config::NetworkProxySpec;#[cfg(unix)]+use crate::tools::runtimes::RuntimePathPrepends;+#[cfg(unix)]+use crate::tools::runtimes::maybe_wrap_shell_lc_with_snapshot;+#[cfg(unix)]+use crate::tools::runtimes::prepare_brokered_shell_snapshot_env;+#[cfg(unix)]use codex_network_proxy::NetworkProxyConfig;#[cfg(unix)]use codex_protocol::config_types::EnvironmentVariablePattern;@@ -88,6 +94,27 @@ fn assert_posix_snapshot_sections(snapshot: &str) {assert!(snapshot.contains("setopts "));}+#[cfg(windows)]+#[test]+fn inherited_provider_context_matches_windows_environment_casing() {+ let mut env = HashMap::new();+ let inherited = HashMap::from([("gh_host".to_string(), "github.example.com".to_string())]);++ replace_provider_context_with_inherited(&mut env, &inherited, std::iter::once("GH_HOST"));++ assert_eq!(+ env,+ HashMap::from([("GH_HOST".to_string(), "github.example.com".to_string())])+ );++ insert_env_value(&mut env, "gh_host", "github.alternate.example");+ assert_eq!(+ env_value(&env, "GH_HOST").map(String::as_str),+ Some("github.alternate.example")+ );+ assert_eq!(env.len(), 1);+}+async fn get_snapshot(shell_type: ShellType) -> Result<String> {let dir = tempdir()?;let path = dir.path().join("snapshot.sh");@@ -532,7 +559,8 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resullet startup = dir.path().join("startup.sh");std::fs::write(&startup,- "export GH_TOKEN='ghp_shell_only_secret'\n\+ "unset GITHUB_ENTERPRISE_TOKEN UNSET_AUTH_HEADER\n\+ export GH_TOKEN='ghp_shell_only_secret'\n\export AUTH_HEADER=\"Bearer $GH_TOKEN\"\n\declare -rx GITHUB_TOKEN='ghp_readonly_secret'\n\declare -rx HOMEBREW_GITHUB_API_TOKEN=\"$GITHUB_TOKEN\"\n\@@ -544,7 +572,9 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resulexport OPENAI_BASE_URL='https://api.snapshot.example/v1'\n\export IDENTITY_SEEN=\"${OPENAI_IDENTITY_TOKEN_FILE-missing}\"\n\export EXCLUDED_PARENT_HOME=\"${HOME-missing}\"\n\- export STARTUP_PATH_OVERRIDE_SEEN=\"${PATH%%:*}\"\n",+ export STARTUP_PATH_OVERRIDE_SEEN=\"${PATH%%:*}\"\n\+ export STARTUP_CORP_REGION_SEEN=\"${CORP_REGION-missing}\"\n\+ export STARTUP_NPM_TOKEN_SEEN=\"${NPM_TOKEN-missing}\"\n",)?;let mut network_config = NetworkProxyConfig::default();@@ -577,13 +607,20 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resultrusted_startup.clone(),("GH_HOST".to_string(), "github.example.com".to_string()),(- "OPENAI_IDENTITY_TOKEN_FILE".to_string(),- "identity-token-secret".to_string(),+ "GITHUB_ENTERPRISE_TOKEN".to_string(),+ "ghp_removed_enterprise_secret".to_string(),),(- "PATH".to_string(),- format!("/repository-controlled:{}", std::env::var("PATH")?),+ "UNSET_AUTH_HEADER".to_string(),+ "Bearer ghp_removed_enterprise_secret".to_string(),),+ (+ "OPENAI_IDENTITY_TOKEN_FILE".to_string(),+ "identity-token-secret".to_string(),+ ),+ ("PATH".to_string(), "/enterprise/bin".to_string()),+ ("CORP_REGION".to_string(), "production".to_string()),+ ("NPM_TOKEN".to_string(), "npm_enterprise_token".to_string()),]),..ShellEnvironmentPolicy::default()};@@ -616,7 +653,10 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resulassert!(snapshot.contains("api.snapshot.example"));assert!(snapshot.contains("IDENTITY_SEEN=\"missing\""));assert!(snapshot.contains("EXCLUDED_PARENT_HOME=\"missing\""));- assert!(!snapshot.contains("STARTUP_PATH_OVERRIDE_SEEN=\"/repository-controlled\""));+ assert!(snapshot.contains("STARTUP_PATH_OVERRIDE_SEEN=\"/enterprise/bin\""));+ assert!(snapshot.contains("declare -x PATH=\"/enterprise/bin\""));+ assert!(snapshot.contains("STARTUP_CORP_REGION_SEEN=\"production\""));+ assert!(snapshot.contains("STARTUP_NPM_TOKEN_SEEN=\"npm_enterprise_token\""));assert!(snapshot.contains("declare -rx HOMEBREW_GITHUB_API_TOKEN=\"${GITHUB_TOKEN-}\""));validate_snapshot(@@ -671,6 +711,33 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resul.contains("EXCLUDED_PARENT_HOME"));+ let mut excluded_credential_broker = SnapshotCredentialBroker {+ network_proxy: network_proxy.clone(),+ shell_environment_policy: shell_environment_policy.clone(),+ allow_login_shell: false,+ };+ excluded_credential_broker+ .shell_environment_policy+ .exclude+ .push(EnvironmentVariablePattern::new_case_insensitive("GH_TOKEN"));+ let (_, excluded_credentials) = capture_snapshot(+ &shell,+ &dir.path().abs(),+ Some(&excluded_credential_broker),+ /*sandbox*/ None,+ )+ .await?;+ assert_eq!(+ excluded_credentials.unwrap().unset_credential_keys,+ [+ "AUTH_BUNDLE",+ "AUTH_HEADER",+ "GH_TOKEN",+ "GITHUB_ENTERPRISE_TOKEN",+ "UNSET_AUTH_HEADER",+ ]+ );+let inherited_secret = "ghp_inherited_enterprise_secret";let inherited_context = HashMap::from([("GH_HOST".to_string(),@@ -720,12 +787,44 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resulassert!(!inherited_snapshot.contains(inherited_secret));let snapshot_file = ShellSnapshotFile { path, credentials };+ let unset_credential_keys = snapshot_file+ .credentials+ .as_ref()+ .unwrap()+ .unset_credential_keys+ .as_slice();+ assert_eq!(+ unset_credential_keys,+ &["GITHUB_ENTERPRISE_TOKEN", "UNSET_AUTH_HEADER"]+ );+ let mut unset_policy = shell_environment_policy.clone();+ let mut unset_env = HashMap::new();+ for key in unset_credential_keys {+ unset_env.insert(key.clone(), unset_policy.r#set.remove(key).unwrap());+ }+ snapshot_file.restore_credentials(&mut unset_env, &unset_policy);+ snapshot_file.restore_fail_open_aliases(&mut unset_env);+ assert!(+ unset_credential_keys+ .iter()+ .all(|key| !unset_env.contains_key(key))+ );+let mut env = HashMap::from([("GH_HOST".to_string(), "github.example.com".to_string())]);+ env.extend(+ shell_environment_policy+ .r#set+ .iter()+ .filter(|(key, _)| unset_credential_keys.contains(key))+ .map(|(key, value)| (key.clone(), value.clone())),+ );snapshot_file.restore_credentials(&mut env, &shell_environment_policy);for (key, value) in [("GH_TOKEN", "ghp_shell_only_secret"),("GITHUB_TOKEN", "ghp_readonly_secret"),("GH_ENTERPRISE_TOKEN", "ghp_enterprise_secret"),+ ("GITHUB_ENTERPRISE_TOKEN", "ghp_removed_enterprise_secret"),+ ("UNSET_AUTH_HEADER", "Bearer ghp_removed_enterprise_secret"),("OPENAI_API_KEY", "sk-proj-snapshot-secret"),] {assert_eq!(env.get(key).map(String::as_str), Some(value), "{key}");@@ -754,13 +853,21 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resulassert_ne!(env["GITHUB_TOKEN"], "ghp_readonly_secret");assert_ne!(env["GH_ENTERPRISE_TOKEN"], "ghp_enterprise_secret");assert_ne!(env["OPENAI_API_KEY"], "sk-proj-snapshot-secret");- let replay = Command::new("/bin/bash")- .arg("-c")- .arg(- ". \"$1\" && printf '%s\\n%s\\n%s' \"$HOMEBREW_GITHUB_API_TOKEN\" \"$AUTH_HEADER\" \"$AUTH_BUNDLE\"",- )- .arg("snapshot")- .arg(snapshot_file.path().as_path())+ let snapshot_path = snapshot_file.path();+ prepare_brokered_shell_snapshot_env(&mut env, Some(&snapshot_path), &shell);+ let replay_command = maybe_wrap_shell_lc_with_snapshot(+ &shell.derive_exec_args(+ "printf '%s\\n%s\\n%s' \"$HOMEBREW_GITHUB_API_TOKEN\" \"$AUTH_HEADER\" \"$AUTH_BUNDLE\"",+ /*use_login_shell*/ false,+ ),+ &shell,+ Some(&snapshot_path),+ &shell_environment_policy.r#set,+ &env,+ &RuntimePathPrepends::default(),+ );+ let replay = Command::new(&replay_command[0])+ .args(&replay_command[1..]).env_clear().envs(&env).output()?;@@ -815,7 +922,7 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resul),)?;let partially_filtered_path = dir.path().join("partially-filtered-snapshot.sh").abs();- write_shell_snapshot(+ let filtered_credentials = write_shell_snapshot(&shell,&partially_filtered_path,&dir.path().abs(),@@ -836,13 +943,74 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> ResulString::from_utf8(filtered_replay.stdout)?,"Bearer ghp_filtered_dummy\nunset");+ let filtered_snapshot = ShellSnapshotFile {+ path: partially_filtered_path,+ credentials: filtered_credentials,+ };+ let mut fail_open_env = HashMap::new();+ filtered_snapshot.restore_fail_open_aliases(&mut fail_open_env);+ assert!(!fail_open_env.contains_key("AUTH_BUNDLE"));}+ let posix_startup = dir.path().join("posix-startup.sh");+ std::fs::write(+ &posix_startup,+ "export GH_TOKEN='ghp_posix_shell_secret'\nexport POSIX_STARTUP_LOADED=1\n",+ )?;+ let posix_shell = Shell {+ shell_type: ShellType::Sh,+ shell_path: PathBuf::from("/bin/sh"),+ };+ let posix_credential_broker = SnapshotCredentialBroker {+ network_proxy: network_proxy.clone(),+ shell_environment_policy: ShellEnvironmentPolicy {+ r#set: HashMap::from([("ENV".to_string(), "$PWD/posix-startup.sh".to_string())]),+ ..ShellEnvironmentPolicy::default()+ },+ allow_login_shell: true,+ };+ let posix_snapshot_path = dir.path().join("posix-snapshot.sh").abs();+ let posix_credentials = write_shell_snapshot(+ &posix_shell,+ &posix_snapshot_path,+ &dir.path().abs(),+ Some(&posix_credential_broker),+ /*sandbox*/ None,+ )+ .await?+ .expect("brokered POSIX snapshot has credentials");+ let posix_snapshot = fs::read_to_string(&posix_snapshot_path).await?;+ assert!(posix_snapshot.contains("POSIX_STARTUP_LOADED"));+ assert!(!posix_snapshot.contains("ghp_posix_shell_secret"));+ assert_eq!(+ posix_credentials+ .protected_startup_env+ .as_deref()+ .map(std::fs::canonicalize)+ .transpose()?,+ Some(std::fs::canonicalize(&posix_startup)?)+ );++ std::fs::write(&posix_startup, "export APPLICATION_SETTING=production\n")?;+ let application_snapshot_path = dir.path().join("posix-application-snapshot.sh").abs();+ let application_credentials = write_shell_snapshot(+ &posix_shell,+ &application_snapshot_path,+ &dir.path().abs(),+ Some(&posix_credential_broker),+ /*sandbox*/ None,+ )+ .await?+ .expect("brokered POSIX application snapshot has credentials");+ assert!(application_credentials.protected_startup_env.is_none());+std::fs::write(&startup,"export GH_TOKEN='ghp_hidden_alias_secret'\n\- export HIDDEN_HEADER=\"Bearer $GH_TOKEN\"\n\- unset GH_TOKEN GITHUB_ENTERPRISE_TOKEN\n",+ export HIDDEN_HEADER=\"prefix\\\"$GH_TOKEN\\\"suffix\"\n\+ export GITHUB_TOKEN='ghp_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh'\n\+ export UNKNOWN_HEADER=\"Bearer $GITHUB_TOKEN\"\n\+ unset GH_TOKEN GITHUB_TOKEN GITHUB_ENTERPRISE_TOKEN\n",)?;let mut previously_brokered_env = HashMap::from([("GH_TOKEN".to_string(),@@ -850,7 +1018,7 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resul)]);network_proxy.apply_to_env(&mut previously_brokered_env);let inherited_credential_broker = SnapshotCredentialBroker {- network_proxy,+ network_proxy: network_proxy.clone(),shell_environment_policy: ShellEnvironmentPolicy {r#set: HashMap::from([trusted_startup]),..ShellEnvironmentPolicy::default()@@ -858,7 +1026,7 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resulallow_login_shell: false,};let inherited_path = dir.path().join("inherited-snapshot.sh").abs();- write_shell_snapshot(+ let inherited_credentials = write_shell_snapshot(&shell,&inherited_path,&dir.path().abs(),@@ -866,12 +1034,204 @@ async fn snapshot_discovers_and_redacts_shell_initialized_credentials() -> Resul/*sandbox*/ None,).await?;+ let inherited_snapshot = fs::read_to_string(&inherited_path).await?;+ assert!(!inherited_snapshot.contains("ghp_hidden_alias_secret"));+ assert!(!inherited_snapshot.contains("ghp_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"));+ let inherited_replay = Command::new("/bin/bash")+ .arg("-c")+ .arg(". \"$1\" && printf '%s\\n%s' \"${HIDDEN_HEADER-unset}\" \"${UNKNOWN_HEADER-unset}\"")+ .arg("snapshot")+ .arg(inherited_path.as_path())+ .env_clear()+ .output()?;+ assert!(inherited_replay.status.success());+ assert_eq!(String::from_utf8(inherited_replay.stdout)?, "unset\nunset");++ let snapshot_file = ShellSnapshotFile {+ path: inherited_path,+ credentials: inherited_credentials,+ };+ let real_hidden_header = "prefix\"ghp_hidden_alias_secret\"suffix";+ let real_header = "Bearer ghp_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh";+ let mut brokered_env = HashMap::new();+ snapshot_file.restore_credentials(+ &mut brokered_env,+ &inherited_credential_broker.shell_environment_policy,+ );+ inherited_credential_broker+ .network_proxy+ .apply_to_env(&mut brokered_env);+ let dummy_header = brokered_env["UNKNOWN_HEADER"].clone();+ let dummy_hidden_header = brokered_env["HIDDEN_HEADER"].clone();+ assert_ne!(dummy_header, real_header);+ assert_ne!(dummy_hidden_header, real_hidden_header);+ snapshot_file.restore_fail_open_aliases(&mut brokered_env);+ assert_eq!(+ brokered_env.get("UNKNOWN_HEADER").map(String::as_str),+ Some(dummy_header.as_str())+ );+ assert_eq!(+ brokered_env.get("HIDDEN_HEADER").map(String::as_str),+ Some(dummy_hidden_header.as_str())+ );++ let mut fail_open_env = HashMap::new();+ snapshot_file.restore_credentials(+ &mut fail_open_env,+ &inherited_credential_broker.shell_environment_policy,+ );+ snapshot_file.restore_fail_open_aliases(&mut fail_open_env);+ assert_eq!(+ fail_open_env.get("UNKNOWN_HEADER").map(String::as_str),+ Some(real_header)+ );+ assert_eq!(+ fail_open_env.get("HIDDEN_HEADER").map(String::as_str),+ Some(real_hidden_header)+ );++ std::fs::write(+ &startup,+ "export GH_TOKEN='ghp_hidden_alias_secret'\n\+ credential_function() { printf '%s' 'ghp_hidden_alias_secret'; }\n\+ unset GH_TOKEN\n",+ )?;+ let residual_credential = capture_snapshot(+ &shell,+ &dir.path().abs(),+ Some(&inherited_credential_broker),+ /*sandbox*/ None,+ )+ .await;assert!(- !fs::read_to_string(inherited_path)- .await?- .contains("ghp_hidden_alias_secret")+ residual_credential.is_err(),+ "snapshot with a credential-bearing shell function must be rejected");+ std::fs::write(+ &startup,+ "unset PATH\nset -u\nexport GH_TOKEN='ghp_unset_path_secret'\n",+ )?;+ let (unset_path_snapshot, _) = capture_snapshot(+ &shell,+ &dir.path().abs(),+ Some(&inherited_credential_broker),+ /*sandbox*/ None,+ )+ .await?;+ assert!(!unset_path_snapshot.contains("declare -x PATH="));+ assert!(!unset_path_snapshot.contains("ghp_unset_path_secret"));++ for real in [+ "ghp_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGH",+ "opaque_enterprise_credential",+ "0123456789abcdef0123456789abcdef01234567",+ ] {+ std::fs::write(+ &startup,+ format!(+ "unset GH_HOST\nexport GH_ENTERPRISE_TOKEN='{real}'\nexport AUTH_HEADER=\"Bearer $GH_ENTERPRISE_TOKEN\"\n"+ ),+ )?;+ let (snapshot, credentials) = capture_snapshot(+ &shell,+ &dir.path().abs(),+ Some(&inherited_credential_broker),+ /*sandbox*/ None,+ )+ .await?;+ assert!(!snapshot.contains(real));+ let snapshot_file = ShellSnapshotFile {+ path: dir.path().join("hostless-snapshot.sh").abs(),+ credentials,+ };+ let policy = &inherited_credential_broker.shell_environment_policy;+ let mut restored = HashMap::new();+ snapshot_file.restore_credentials(&mut restored, policy);+ network_proxy.apply_to_env(&mut restored);+ snapshot_file.restore_fail_open_aliases(&mut restored);+ assert_eq!(+ restored.get("GH_ENTERPRISE_TOKEN").map(String::as_str),+ Some(real)+ );++ let mut excluded = policy.clone();+ excluded+ .exclude+ .push(EnvironmentVariablePattern::new_case_insensitive(+ "GH_ENTERPRISE_TOKEN",+ ));+ let mut filtered = HashMap::new();+ snapshot_file.restore_credentials(&mut filtered, &excluded);+ assert!(!filtered.contains_key("GH_ENTERPRISE_TOKEN"));++ let mut overridden = policy.clone();+ overridden+ .r#set+ .insert("GH_ENTERPRISE_TOKEN".to_string(), String::new());+ let mut empty = overridden.r#set.clone();+ snapshot_file.restore_credentials(&mut empty, &overridden);+ assert_eq!(+ empty.get("GH_ENTERPRISE_TOKEN").map(String::as_str),+ Some("")+ );++ let policies = if real.starts_with("ghp_") {+ vec![excluded, overridden]+ } else {+ vec![policy.clone(), excluded, overridden]+ };+ for policy in policies {+ let broker = SnapshotCredentialBroker {+ network_proxy: network_proxy.clone(),+ shell_environment_policy: policy.clone(),+ allow_login_shell: false,+ };+ let (snapshot, credentials) = capture_snapshot(+ &shell,+ &dir.path().abs(),+ Some(&broker),+ /*sandbox*/ None,+ )+ .await?;+ assert!(!snapshot.contains(real));+ let snapshot_file = ShellSnapshotFile {+ path: dir.path().join("hostless-alias-snapshot.sh").abs(),+ credentials,+ };+ std::fs::write(&snapshot_file.path, snapshot)?;+ let mut env = HashMap::from([("AUTH_HEADER".to_string(), format!("Bearer {real}"))]);+ snapshot_file.restore_credentials(&mut env, &policy);+ network_proxy.apply_to_env(&mut env);+ snapshot_file.restore_fail_open_aliases(&mut env);+ let replayed = Command::new("/bin/bash")+ .args([+ "-c",+ ". \"$1\"; printf '%s' \"${AUTH_HEADER-}\"",+ "snapshot",+ ])+ .arg(snapshot_file.path.as_path())+ .env_clear()+ .envs(env)+ .output()?;+ assert!(replayed.status.success());+ let expected =+ if policy.exclude.is_empty() && !policy.r#set.contains_key("GH_ENTERPRISE_TOKEN") {+ format!("Bearer {real}")+ } else {+ String::new()+ };+ assert_eq!(String::from_utf8(replayed.stdout)?, expected);+ }++ restored.insert("GH_HOST".to_string(), "github.later.example".to_string());+ network_proxy.apply_to_env(&mut restored);+ assert_ne!(+ restored.get("GH_ENTERPRISE_TOKEN").map(String::as_str),+ Some(real)+ );+ }+Ok(())}diff --git a/codex-rs/core/src/tools/runtimes/mod.rs b/codex-rs/core/src/tools/runtimes/mod.rsindex b2c0300ac9..727ff73917 100644--- a/codex-rs/core/src/tools/runtimes/mod.rs+++ b/codex-rs/core/src/tools/runtimes/mod.rs@@ -27,6 +27,7 @@ pub(crate) use codex_network_proxy::is_managed_proxy_env_var;pub(crate) use codex_network_proxy::strip_managed_proxy_env;use codex_protocol::config_types::WindowsSandboxLevel;use codex_protocol::shell_environment::is_non_inheritable_env_var;+use codex_shell_command::shell_snapshot::posix_env_path_expansion_function;use codex_utils_absolute_path::AbsolutePathBuf;use std::collections::HashMap;use std::path::Path;@@ -35,6 +36,12 @@ pub(crate) mod apply_patch;pub(crate) mod unified_exec;pub(crate) mod zsh_fork;+const SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_ORIGINAL_BASH_ENV";+const SNAPSHOT_ORIGINAL_POSIX_ENV_ENV_KEY: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_ORIGINAL_POSIX_ENV";+const SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_ORIGINAL_ZDOTDIR";+const SNAPSHOT_BROKERED_VALUE_ENV_PREFIX: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_BROKERED_VALUE_";+const SNAPSHOT_BROKERED_UNSET_ENV_PREFIX: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_BROKERED_UNSET_";+pub(crate) fn exec_env_for_sandbox_permissions(env: &HashMap<String, String>,sandbox_permissions: SandboxPermissions,@@ -204,13 +211,57 @@ fn prepare_powershell_command_for_elevated_windows_sandbox_with_fallback(pub(crate) fn prepare_brokered_shell_snapshot_env(env: &mut HashMap<String, String>,shell_snapshot: Option<&AbsolutePathBuf>,+ shell: &Shell,) {if shell_snapshot.is_some()&& env.get(CREDENTIAL_BROKER_ACTIVE_ENV_KEY).is_some_and(|active| active == "1"){- env.remove("BASH_ENV");+ if !cfg!(windows) {+ env.retain(|key, _| {+ !key.starts_with(SNAPSHOT_BROKERED_VALUE_ENV_PREFIX)+ && !key.starts_with(SNAPSHOT_BROKERED_UNSET_ENV_PREFIX)+ });+ for key in codex_network_proxy::brokered_credential_value_env_keys(env) {+ if is_valid_shell_variable_name(&key)+ && let Some(value) = env.get(&key).cloned()+ {+ env.insert(format!("{SNAPSHOT_BROKERED_VALUE_ENV_PREFIX}{key}"), value);+ }+ }+ for key in codex_network_proxy::brokered_credential_marker_env_keys(env) {+ if !is_valid_shell_variable_name(&key) {+ continue;+ }+ if let Some(value) = env.get(&key).cloned() {+ env.entry(format!("{SNAPSHOT_BROKERED_VALUE_ENV_PREFIX}{key}"))+ .or_insert(value);+ } else {+ env.insert(+ format!("{SNAPSHOT_BROKERED_UNSET_ENV_PREFIX}{key}"),+ "1".to_string(),+ );+ }+ }+ }+ let bash_env = env.remove("BASH_ENV");+ if !cfg!(windows)+ && let Some(bash_env) = bash_env+ && !bash_env.is_empty()+ {+ env.insert(SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY.to_string(), bash_env);+ } else {+ env.remove(SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY);+ }+ if shell.shell_type == ShellType::Zsh {+ if let Some(zdotdir) = env.remove("ZDOTDIR") {+ env.insert(SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY.to_string(), zdotdir);+ } else {+ env.remove(SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY);+ }+ env.insert("ZDOTDIR".to_string(), "/dev/null".to_string());+ }}}@@ -320,18 +371,136 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot(],);let (proxy_captures, proxy_exports) = build_proxy_env_exports(env);+ let (env_captures, replayed_startup_capture, env_exports) = if brokered {+ let bash_env_key = SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY;+ let posix_env_key = SNAPSHOT_ORIGINAL_POSIX_ENV_ENV_KEY;+ let startup_env_key =+ if session_shell.shell_type == ShellType::Sh && env.contains_key(posix_env_key) {+ posix_env_key+ } else {+ bash_env_key+ };+ let alternate_startup_env_key = if startup_env_key == posix_env_key {+ bash_env_key+ } else {+ posix_env_key+ };+ let zdotdir_key = SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY;+ let expand_env_function = posix_env_path_expansion_function();+ (+ format!(+ r#"__CODEX_SNAPSHOT_ORIGINAL_ENV_SET="${{ENV+x}}"+__CODEX_SNAPSHOT_ORIGINAL_ENV="${{ENV-}}"+{expand_env_function}+__codex_snapshot_expand_env_with_zdotdir() (+ if [ -n "${{{zdotdir_key}+x}}" ]; then+ export ZDOTDIR="${{{zdotdir_key}}}"+ elif [ -n "${{ZSH_VERSION-}}" ] && [ "${{ZDOTDIR-}}" = /dev/null ]; then+ unset ZDOTDIR+ fi+ __codex_snapshot_expand_env "$1"+)+__CODEX_SNAPSHOT_PROTECTED_ENV=$(+ __codex_snapshot_expand_env_with_zdotdir "${{{startup_env_key}-}}"+)+__CODEX_SNAPSHOT_ALTERNATE_PROTECTED_ENV=$(+ __codex_snapshot_expand_env_with_zdotdir "${{{alternate_startup_env_key}-}}"+)"#+ ),+ "__CODEX_SNAPSHOT_REPLAYED_BASH_ENV=\"${BASH_ENV-}\"".to_string(),+ format!(+ r#"__CODEX_SNAPSHOT_CURRENT_ENV=$(+ __codex_snapshot_expand_env_with_zdotdir "${{ENV-}}"+)+__CODEX_SNAPSHOT_ORIGINAL_EXPANDED_ENV=$(+ __codex_snapshot_expand_env_with_zdotdir "$__CODEX_SNAPSHOT_ORIGINAL_ENV"+)+__CODEX_SNAPSHOT_REPLAYED_PROTECTED_ENV=$(+ __codex_snapshot_expand_env_with_zdotdir "$__CODEX_SNAPSHOT_REPLAYED_BASH_ENV"+)+unset -f __codex_snapshot_expand_env __codex_snapshot_expand_env_with_zdotdir+__codex_snapshot_env_is_protected() (+ for __codex_protected_env in \+ "$__CODEX_SNAPSHOT_PROTECTED_ENV" \+ "$__CODEX_SNAPSHOT_ALTERNATE_PROTECTED_ENV" \+ "$__CODEX_SNAPSHOT_REPLAYED_PROTECTED_ENV"; do+ if [ -n "$__codex_protected_env" ] &&+ {{ [ "$1" = "$__codex_protected_env" ] ||+ [ "$1" -ef "$__codex_protected_env" ] 2>/dev/null; }}; then+ return 0+ fi+ done+ return 1+)+if __codex_snapshot_env_is_protected "$__CODEX_SNAPSHOT_CURRENT_ENV"; then+ if [ -n "$__CODEX_SNAPSHOT_ORIGINAL_ENV_SET" ] &&+ ! __codex_snapshot_env_is_protected "$__CODEX_SNAPSHOT_ORIGINAL_EXPANDED_ENV"; then+ builtin export ENV="$__CODEX_SNAPSHOT_ORIGINAL_ENV" 2>/dev/null ||+ command export ENV="$__CODEX_SNAPSHOT_ORIGINAL_ENV" || exit 1+ [ "${{ENV-}}" = "$__CODEX_SNAPSHOT_ORIGINAL_ENV" ] || exit 1+ else+ builtin unset ENV 2>/dev/null || command unset ENV || exit 1+ [ -z "${{ENV+x}}" ] || exit 1+ fi+fi+unset -f __codex_snapshot_env_is_protected+unset __CODEX_SNAPSHOT_ORIGINAL_ENV_SET __CODEX_SNAPSHOT_ORIGINAL_ENV \+ __CODEX_SNAPSHOT_PROTECTED_ENV __CODEX_SNAPSHOT_ALTERNATE_PROTECTED_ENV \+ __CODEX_SNAPSHOT_REPLAYED_BASH_ENV __CODEX_SNAPSHOT_REPLAYED_PROTECTED_ENV \+ __CODEX_SNAPSHOT_CURRENT_ENV __CODEX_SNAPSHOT_ORIGINAL_EXPANDED_ENV \+ {bash_env_key} {posix_env_key}"#+ ),+ )+ } else {+ (String::new(), String::new(), String::new())+ };+ let zsh_startup_exports = if brokered && session_shell.shell_type == ShellType::Zsh {+ let key = SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY;+ format!(+ "if [ -n \"${{{key}+x}}\" ]; then\n export ZDOTDIR=\"${{{key}}}\"\nelif [ \"${{ZDOTDIR-}}\" = /dev/null ]; then\n unset ZDOTDIR\nfi\nunset {key}"+ )+ } else {+ String::new()+ };+ // Zsh always reads the global zshenv, even with `-f`. Keep private copies of child-visible+ // dummy values until the command shell has finished startup, then remove the copies.+ let outer_brokered_credential_exports = if brokered {+ build_brokered_credential_exports(env, /*remove_copies*/ false)+ } else {+ String::new()+ };+ let inner_brokered_credential_exports = if brokered {+ build_brokered_credential_exports(env, /*remove_copies*/ true)+ } else {+ String::new()+ };+ let original_script = if !inner_brokered_credential_exports.is_empty() {+ format!("{inner_brokered_credential_exports}\n{}", command[2])+ } else {+ command[2].clone()+ };let runtime_path_prepend_exports =runtime_path_prepends.shell_exports_after_snapshot(explicit_env_overrides);- let override_captures = join_shell_blocks([override_captures, proxy_captures]);+ let override_captures = join_shell_blocks([+ outer_brokered_credential_exports.clone(),+ override_captures,+ proxy_captures,+ env_captures,+ ]);let override_exports = join_shell_blocks([+ outer_brokered_credential_exports.clone(),+ replayed_startup_capture,override_exports,proxy_exports,runtime_path_prepend_exports,+ env_exports,+ zsh_startup_exports,+ outer_brokered_credential_exports,]);let run_original = if reuse_session_shell {- command[2].clone()+ original_script} else {- let original_script = shell_single_quote(&command[2]);+ let original_script = shell_single_quote(&original_script);format!("exec '{original_shell}' {original_shell_flag} '{original_script}'{trailing_args}")};let rewritten_script = if override_exports.is_empty() {@@ -358,6 +527,60 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot(rewritten}+fn build_brokered_credential_exports(env: &HashMap<String, String>, remove_copies: bool) -> String {+ let mut value_copies = env+ .keys()+ .filter_map(|copy_key| {+ let key = copy_key.strip_prefix(SNAPSHOT_BROKERED_VALUE_ENV_PREFIX)?;+ is_valid_shell_variable_name(key).then_some((key, copy_key))+ })+ .collect::<Vec<_>>();+ value_copies.sort_unstable();+ let value_exports = value_copies+ .into_iter()+ .map(|(key, copy_key)| {+ let restore = format!(+ "if [ -z \"${{{copy_key}+x}}\" ]; then exit 1; fi\nif [ -n \"${{{key}+x}}\" ] && [ -n \"${{{key}}}\" ] && [ \"${{{key}}}\" != \"${{{copy_key}}}\" ]; then export {key}=\"${{{copy_key}}}\" || exit 1; fi\nif [ -n \"${{{key}+x}}\" ] && [ -n \"${{{key}}}\" ] && [ \"${{{key}}}\" != \"${{{copy_key}}}\" ]; then exit 1; fi"+ );+ if remove_copies {+ format!("{restore}\nunset {copy_key} || exit 1")+ } else {+ restore+ }+ })+ .collect::<Vec<_>>()+ .join("\n");+ let mut unset_markers = env+ .keys()+ .filter_map(|marker_key| {+ let key = marker_key.strip_prefix(SNAPSHOT_BROKERED_UNSET_ENV_PREFIX)?;+ is_valid_shell_variable_name(key).then_some((key, marker_key))+ })+ .collect::<Vec<_>>();+ unset_markers.sort_unstable();+ let unset_exports = unset_markers+ .into_iter()+ .map(|(key, marker_key)| {+ let restore = format!(+ "if [ -z \"${{{marker_key}+x}}\" ]; then exit 1; fi\nif [ -n \"${{{key}+x}}\" ] && [ -n \"${{{key}}}\" ]; then unset {key} || exit 1; fi\nif [ -n \"${{{key}+x}}\" ] && [ -n \"${{{key}}}\" ]; then exit 1; fi"+ );+ if remove_copies {+ format!("{restore}\nunset {marker_key} || exit 1")+ } else {+ restore+ }+ })+ .collect::<Vec<_>>()+ .join("\n");+ let exports = join_shell_blocks([value_exports, unset_exports]);+ if exports.is_empty() {+ return exports;+ }+ format!(+ "case $- in\n *x*) __CODEX_SNAPSHOT_BROKER_XTRACE=1; set +x ;;\n *) __CODEX_SNAPSHOT_BROKER_XTRACE= ;;\nesac\n{exports}\nif [ -n \"$__CODEX_SNAPSHOT_BROKER_XTRACE\" ]; then\n unset __CODEX_SNAPSHOT_BROKER_XTRACE\n set -x\nelse\n unset __CODEX_SNAPSHOT_BROKER_XTRACE\nfi"+ )+}+fn build_override_exports(explicit_env_overrides: &HashMap<String, String>,restore_even_when_absent: &[&str],@@ -448,7 +671,7 @@ fn build_override_exports_for_keys(variable_prefix: &str, keys: &[&str]) -> (Strlet set_var = format!("{variable_prefix}_SET_{idx}");let value_var = format!("{variable_prefix}_{idx}");format!(- "if [ -n \"${{{set_var}}}\" ]; then\n if [ -z \"${{{key}+x}}\" ] || [ \"${{{key}-}}\" != \"${{{value_var}}}\" ]; then export {key}=\"${{{value_var}}}\"; else export {key}; fi\nelse builtin unset {key} 2>/dev/null || command unset {key}; fi"+ "if [ -n \"${{{set_var}}}\" ]; then\n if [ -z \"${{{key}+x}}\" ] || [ \"${{{key}-}}\" != \"${{{value_var}}}\" ]; then export {key}=\"${{{value_var}}}\"; else export {key}; fi\nelse builtin unset {key} 2>/dev/null || command unset {key}; fi\nbuiltin unset {set_var} {value_var} 2>/dev/null || command unset {set_var} {value_var}")}).collect::<Vec<_>>()@@ -617,7 +840,6 @@ mod prepare_powershell_command_tests {assert_eq!(rewritten, command);}-#[test]fn local_elevated_powershell_uses_discovered_fallback() {let command = vec![diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rsindex 734c07dbb4..8d0d9b5f8b 100644--- a/codex-rs/core/src/tools/runtimes/mod_tests.rs+++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs@@ -27,6 +27,7 @@ use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;use core_test_support::PathBufExt;use pretty_assertions::assert_eq;+use std::os::unix::fs::PermissionsExt;use std::path::PathBuf;use std::process::Command;use std::sync::Arc;@@ -461,6 +462,14 @@ fn maybe_wrap_shell_lc_with_snapshot_reuses_brokered_session_zsh() {std::fs::write(&snapshot_path, "# Snapshot file\n").expect("write snapshot");let (session_shell, shell_snapshot) =shell_with_snapshot(ShellType::Zsh, "/bin/zsh", snapshot_path.abs());+ let copy_key = format!("{SNAPSHOT_BROKERED_VALUE_ENV_PREFIX}OPENAI_API_KEY");+ let env = HashMap::from([+ (+ CREDENTIAL_BROKER_ACTIVE_ENV_KEY.to_string(),+ "1".to_string(),+ ),+ (copy_key.clone(), "dummy-openai-key".to_string()),+ ]);for (flag, expected_flag) in [("-c", "-fc"), ("-lc", "-lfc")] {let command = vec!["/bin/zsh".to_string(),@@ -469,10 +478,6 @@ fn maybe_wrap_shell_lc_with_snapshot_reuses_brokered_session_zsh() {"arg0".to_string(),"arg1".to_string(),];- let env = HashMap::from([(- CREDENTIAL_BROKER_ACTIVE_ENV_KEY.to_string(),- "1".to_string(),- )]);let rewritten = maybe_wrap_shell_lc_with_snapshot(&command,@@ -490,6 +495,7 @@ fn maybe_wrap_shell_lc_with_snapshot_reuses_brokered_session_zsh() {shell_single_quote(&shell_snapshot.to_string_lossy()))));assert!(rewritten[2].ends_with(&command[2]));+ assert!(rewritten[2].contains(&format!("unset {copy_key} || exit 1")));assert!(!rewritten[2].contains("exec '/bin/zsh'"));assert_eq!(rewritten[3..], command[3..]);}@@ -855,7 +861,8 @@ async fn snapshot_wrapper_replays_dummy_and_preserves_unbrokered_credentials() -std::fs::write(&snapshot,format!(- "# Snapshot file\ncorp_auth() {{ printf '%s\\n%s\\n%s' \"$OPENAI_API_KEY\" \"${{GITHUB_TOKEN-unset}}\" \"$1\"; }}\nexport OPENAI_API_KEY='stale'\nexport GITHUB_TOKEN='ghp_snapshot_only'\nexport GH_HOST='github.example.com'\nexport BASH_ENV='{}'\nexport ZDOTDIR='{}'\n",+ "# Snapshot file\ncorp_auth() {{ printf '%s\\n%s\\n%s' \"$OPENAI_API_KEY\" \"${{GITHUB_TOKEN-unset}}\" \"$1\"; }}\nexport OPENAI_API_KEY='stale'\nexport GITHUB_TOKEN='ghp_snapshot_only'\nexport GH_HOST='github.example.com'\nexport BASH_ENV='{}'\nexport ENV='{}'\nexport ZDOTDIR='{}'\n",+ startup.display(),startup.display(),dir.path().display()),@@ -866,13 +873,27 @@ async fn snapshot_wrapper_replays_dummy_and_preserves_unbrokered_credentials() -"OPENAI_API_KEY".to_string(),"sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_".to_string(),),+ (+ "AUTH_HEADER".to_string(),+ "Bearer sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"+ .to_string(),+ ),("GITHUB_TOKEN".to_string(), String::new()),("BASH_ENV".to_string(), startup.display().to_string()),+ ("ENV".to_string(), startup.display().to_string()),]);proxy.apply_to_env(&mut env);- prepare_brokered_shell_snapshot_env(&mut env, Some(&snapshot));- assert!(!env.contains_key("BASH_ENV"));let dummy = env["OPENAI_API_KEY"].clone();+ let dummy_alias = env["AUTH_HEADER"].clone();+ let mut alias_only_env = env.clone();+ alias_only_env.remove("OPENAI_API_KEY");+ let mut empty_canonical_env = env.clone();+ empty_canonical_env.insert("OPENAI_API_KEY".to_string(), String::new());+ let mut absent_alias_env = env.clone();+ absent_alias_env.remove("AUTH_HEADER");+ prepare_brokered_shell_snapshot_env(&mut env, Some(&snapshot), &shell);+ assert!(!env.contains_key("BASH_ENV"));+ assert_eq!(env.get("ENV"), Some(&startup.display().to_string()));let command = vec!["/bin/bash".to_string(),"-c".to_string(),@@ -900,6 +921,341 @@ async fn snapshot_wrapper_replays_dummy_and_preserves_unbrokered_credentials() -format!("{dummy}\nghp_snapshot_only\ngithub.example.com"));+ let (posix_shell, _) = shell_with_snapshot(ShellType::Sh, "/bin/sh", snapshot.clone());+ let no_prepends = RuntimePathPrepends::default();+ let wrap_brokered_snapshot = |shell: &Shell,+ snapshot: &AbsolutePathBuf,+ env: &HashMap<String, String>,+ prepends: &RuntimePathPrepends| {+ maybe_wrap_shell_lc_with_snapshot(+ &[+ shell.shell_path.to_string_lossy().into_owned(),+ if shell.shell_type == ShellType::Sh {+ "-lc"+ } else {+ "-c"+ }+ .to_string(),+ "/bin/sh -ic 'printf \"%s|%s\" \"$OPENAI_API_KEY\" \"${ENV-unset}\"'".to_string(),+ ],+ shell,+ Some(snapshot),+ &HashMap::new(),+ env,+ prepends,+ )+ };+ let wrap_snapshot = |snapshot: &AbsolutePathBuf, env: &HashMap<String, String>| {+ wrap_brokered_snapshot(&posix_shell, snapshot, env, &no_prepends)+ };+ let nested = wrap_snapshot(&snapshot, &env);+ let run_nested =+ |command: &[String], env: &HashMap<String, String>| -> anyhow::Result<String> {+ let output = Command::new(&command[0])+ .args(&command[1..])+ .current_dir(dir.path())+ .env_clear()+ .envs(env)+ .output()?;+ anyhow::ensure!(output.status.success(), "nested shell failed: {output:?}");+ Ok(String::from_utf8(output.stdout)?)+ };+ let posix_startup = dir.path().join("posix-startup.sh");+ std::fs::write(&posix_startup, "export OPENAI_API_KEY='sk-posix-secret'\n")?;+ let posix_snapshot = dir.path().join("posix-startup-snapshot.sh").abs();+ std::fs::write(+ &posix_snapshot,+ format!("export ENV='{}'\n", posix_startup.display()),+ )?;+ let mut posix_startup_env = env.clone();+ posix_startup_env.insert(+ SNAPSHOT_ORIGINAL_POSIX_ENV_ENV_KEY.to_string(),+ posix_startup.display().to_string(),+ );+ let distinct = wrap_snapshot(&posix_snapshot, &posix_startup_env);+ assert_eq!(+ run_nested(&distinct, &posix_startup_env)?,+ format!("{dummy}|unset")+ );+ posix_startup_env.remove(SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY);+ posix_startup_env.insert("ENV".to_string(), posix_startup.display().to_string());+ let inherited = wrap_snapshot(&posix_snapshot, &posix_startup_env);+ assert_eq!(+ run_nested(&inherited, &posix_startup_env)?,+ format!("{dummy}|unset")+ );++ let wrap_bash_snapshot = |snapshot: &AbsolutePathBuf, env: &HashMap<String, String>| {+ wrap_brokered_snapshot(&shell, snapshot, env, &no_prepends)+ };+ let readonly_snapshot = dir.path().join("readonly-env-snapshot.sh").abs();+ for initial_env in [None, Some("production"), Some(startup.to_str().unwrap())] {+ let mut case_env = env.clone();+ case_env.remove("ENV");+ if let Some(value) = initial_env {+ case_env.insert("ENV".to_string(), value.to_string());+ }+ for (value, succeeds) in [(startup.to_str().unwrap(), false), ("production", true)] {+ std::fs::write(+ &readonly_snapshot,+ format!("export ENV='{value}'\nreadonly ENV\n"),+ )?;+ for command_shell in [&shell, &posix_shell] {+ let command = wrap_brokered_snapshot(+ command_shell,+ &readonly_snapshot,+ &case_env,+ &no_prepends,+ );+ let output = Command::new(&command[0])+ .args(&command[1..])+ .current_dir(dir.path())+ .env_clear()+ .envs(&case_env)+ .output()?;+ assert_eq!(output.status.success(), succeeds, "{output:?}");+ assert_eq!(+ String::from_utf8(output.stdout)?,+ if succeeds {+ format!("{dummy}|production")+ } else {+ String::new()+ }+ );+ }+ }+ }+ let prepended_path_snapshot = dir.path().join("prepended-path-snapshot.sh").abs();+ std::fs::write(+ &prepended_path_snapshot,+ "export ENV='${PATH%%:*}/startup.sh'\nexport PATH='/safe'\n",+ )?;+ let mut prepended_env = env.clone();+ prepended_env.insert("PATH".to_string(), "/safe".to_string());+ prepended_env.insert("ENV".to_string(), "${PATH%%:*}/startup.sh".to_string());+ let mut prepends = RuntimePathPrepends::default();+ prepends.prepend(&mut prepended_env, dir.path());+ let command =+ wrap_brokered_snapshot(&shell, &prepended_path_snapshot, &prepended_env, &prepends);+ assert_eq!(+ run_nested(&command, &prepended_env)?,+ format!("{dummy}|unset")+ );+ let relative_startup_snapshot = dir.path().join("relative-startup-snapshot.sh").abs();+ let startup_path = startup.display().to_string();+ let mut expanded_startup_env = env.clone();+ expanded_startup_env.extend([+ ("SNAPSHOT_STARTUP_FILE".to_string(), startup_path.clone()),+ ("ORIGINAL_STARTUP_FILE".to_string(), startup_path.clone()),+ (+ "SNAPSHOT_APPLICATION_FILE".to_string(),+ "/safe-application.env".to_string(),+ ),+ (+ SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY.to_string(),+ "$SNAPSHOT_STARTUP_FILE".to_string(),+ ),+ ]);+ let application_script =+ format!("export ENV='{startup_path}'\nexport SNAPSHOT_APPLICATION_FILE='{startup_path}'\n");+ let changed_startup_script = "export ENV='$ORIGINAL_STARTUP_FILE'\nexport SNAPSHOT_STARTUP_FILE='/different-startup.sh'\n";+ let strict_script = format!("set -eu\nexport ENV='{startup_path}'\n");+ for (original_env, script, expected_env) in [+ (+ startup_path.as_str(),+ "export ENV='./startup.sh'\n",+ "unset",+ ),+ (+ startup_path.as_str(),+ "export ENV='$SNAPSHOT_STARTUP_FILE'\n",+ "unset",+ ),+ (+ "$SNAPSHOT_APPLICATION_FILE",+ application_script.as_str(),+ "unset",+ ),+ (+ "${SNAPSHOT_APPLICATION_FILE}",+ application_script.as_str(),+ "unset",+ ),+ (startup_path.as_str(), changed_startup_script, "unset"),+ (+ "$OPTIONAL_APPLICATION_FILE",+ strict_script.as_str(),+ "$OPTIONAL_APPLICATION_FILE",+ ),+ ] {+ let mut case_env = expanded_startup_env.clone();+ case_env.insert("ENV".to_string(), original_env.to_string());+ std::fs::write(&relative_startup_snapshot, script)?;+ let command = wrap_bash_snapshot(&relative_startup_snapshot, &case_env);+ assert_eq!(+ run_nested(&command, &case_env)?,+ format!("{dummy}|{expected_env}")+ );+ }++ for bash_env in ["", "$OPTIONAL_STARTUP"] {+ let mut case_env = env.clone();+ case_env.insert("BASH_ENV".to_string(), bash_env.to_string());+ case_env.insert("ENV".to_string(), String::new());+ prepare_brokered_shell_snapshot_env(&mut case_env, Some(&snapshot), &shell);+ let command = wrap_bash_snapshot(&snapshot, &case_env);+ assert_eq!(run_nested(&command, &case_env)?, format!("{dummy}|"));+ }++ let mut expanded_env = env.clone();+ expanded_env.insert("ENV".to_string(), "$SNAPSHOT_STARTUP_FILE".to_string());+ expanded_env.insert(+ "SNAPSHOT_STARTUP_FILE".to_string(),+ startup.display().to_string(),+ );+ assert_eq!(+ run_nested(&nested, &expanded_env)?,+ format!("{dummy}|unset")+ );+ expanded_env.insert("ENV".to_string(), "${SNAPSHOT_STARTUP_FILE}".to_string());+ assert_eq!(+ run_nested(&nested, &expanded_env)?,+ format!("{dummy}|unset")+ );++ let injection = "\"; printf CODEX_ENV_INJECTED; __codex_env_file=\"";+ expanded_env.insert("ENV".to_string(), injection.to_string());+ let startup_value_snapshot = dir.path().join("startup-value-snapshot.sh").abs();+ std::fs::write(+ &startup_value_snapshot,+ format!("export ENV='{injection}'\n"),+ )?;+ let expanded_command = wrap_snapshot(&startup_value_snapshot, &expanded_env);+ assert_eq!(+ run_nested(&expanded_command, &expanded_env)?,+ format!("{dummy}|{injection}")+ );++ std::fs::write(&startup_value_snapshot, "export ENV='~/startup.sh'\n")?;+ let bash_posix_path = dir.path().join("sh");+ std::os::unix::fs::symlink("/bin/bash", &bash_posix_path)?;+ let bash_posix_path = bash_posix_path.display().to_string();+ let (bash_posix_shell, _) =+ shell_with_snapshot(ShellType::Sh, &bash_posix_path, snapshot.clone());+ let bash_posix_command = vec![+ bash_posix_path.clone(),+ "-c".to_string(),+ format!(+ "'{bash_posix_path}' -ic 'printf \"%s|%s\" \"$OPENAI_API_KEY\" \"${{ENV-unset}}\"'"+ ),+ ];+ let mut tilde_env = env.clone();+ tilde_env.insert("ENV".to_string(), "~/startup.sh".to_string());+ tilde_env.insert("HOME".to_string(), dir.path().display().to_string());+ let bash_posix_command = maybe_wrap_shell_lc_with_snapshot(+ &bash_posix_command,+ &bash_posix_shell,+ Some(&startup_value_snapshot),+ &HashMap::new(),+ &tilde_env,+ &RuntimePathPrepends::default(),+ );+ assert_eq!(+ run_nested(&bash_posix_command, &tilde_env)?,+ format!("{dummy}|unset")+ );++ #[cfg(target_os = "macos")]+ {+ expanded_env.insert("ENV".to_string(), "~/startup.sh".to_string());+ expanded_env.insert("HOME".to_string(), dir.path().display().to_string());+ assert_eq!(+ run_nested(&nested, &expanded_env)?,+ format!("{dummy}|unset")+ );+ }++ std::fs::create_dir(dir.path().join("production"))?;+ let mut ordinary_env = env.clone();+ ordinary_env.insert("ENV".to_string(), "production".to_string());+ assert_eq!(+ run_nested(&nested, &ordinary_env)?,+ format!("{dummy}|production")+ );++ let application_env_file = dir.path().join(".env");+ std::fs::write(&application_env_file, "APPLICATION_SETTING=production\n")?;+ ordinary_env.insert(+ "ENV".to_string(),+ application_env_file.display().to_string(),+ );+ let application_command = vec![+ "/bin/bash".to_string(),+ "-c".to_string(),+ "printf '%s' \"$ENV\"".to_string(),+ ];+ let application_command = maybe_wrap_shell_lc_with_snapshot(+ &application_command,+ &shell,+ Some(&snapshot),+ &HashMap::new(),+ &ordinary_env,+ &RuntimePathPrepends::default(),+ );+ assert_eq!(+ run_nested(&application_command, &ordinary_env)?,+ application_env_file.display().to_string()+ );+ for flag in ["-c", "-lc"] {+ let posix_application_command = maybe_wrap_shell_lc_with_snapshot(+ &[+ "/bin/sh".to_string(),+ flag.to_string(),+ "printf '%s' \"$ENV\"".to_string(),+ ],+ &posix_shell,+ Some(&snapshot),+ &HashMap::new(),+ &ordinary_env,+ &RuntimePathPrepends::default(),+ );+ assert_eq!(+ run_nested(&posix_application_command, &ordinary_env)?,+ application_env_file.display().to_string()+ );+ }++ let changed_application_snapshot = dir.path().join("changed-application-snapshot.sh").abs();+ std::fs::write(+ &changed_application_snapshot,+ format!("export ENV='{}'\n", application_env_file.display()),+ )?;+ let bash_nested_command = wrap_bash_snapshot(&changed_application_snapshot, &env);+ assert_eq!(+ run_nested(&bash_nested_command, &env)?,+ format!("{dummy}|{}", application_env_file.display())+ );+ let posix_nested_command = wrap_snapshot(&changed_application_snapshot, &env);+ assert_eq!(+ run_nested(&posix_nested_command, &env)?,+ format!("{dummy}|{}", application_env_file.display())+ );+ let application_snapshot = dir.path().join("application-snapshot.sh");+ std::fs::write(&application_snapshot, "export ENV='production'\n")?;+ let application_snapshot = application_snapshot.abs();+ let application_command = wrap_snapshot(&application_snapshot, &env);+ assert_eq!(+ run_nested(&application_command, &env)?,+ format!("{dummy}|production")+ );+ let mut snapshot_env = env.clone();+ snapshot_env.remove("ENV");+ let application_command = wrap_snapshot(&application_snapshot, &snapshot_env);+ assert_eq!(+ run_nested(&application_command, &snapshot_env)?,+ format!("{dummy}|production")+ );+if std::path::Path::new("/bin/zsh").exists() {std::fs::write(dir.path().join(".zshenv"),@@ -909,7 +1265,7 @@ async fn snapshot_wrapper_replays_dummy_and_preserves_unbrokered_credentials() -std::os::unix::fs::symlink("/bin/zsh", &renamed_zsh)?;env.insert("ZDOTDIR".to_string(), dir.path().display().to_string());let (zsh, _) = shell_with_snapshot(ShellType::Zsh, "/bin/zsh", snapshot.clone());- prepare_brokered_shell_snapshot_env(&mut env, Some(&snapshot));+ prepare_brokered_shell_snapshot_env(&mut env, Some(&snapshot), &zsh);let command = vec![renamed_zsh.display().to_string(),"-lc".to_string(),@@ -923,6 +1279,8 @@ async fn snapshot_wrapper_replays_dummy_and_preserves_unbrokered_credentials() -&env,&RuntimePathPrepends::default(),);+ assert!(!rewritten[2].contains(&dummy));+ assert!(!rewritten[2].contains(&dummy_alias));assert_eq!(rewritten[1], "-lfc");let output = Command::new(&rewritten[0]).args(&rewritten[1..])@@ -934,6 +1292,106 @@ async fn snapshot_wrapper_replays_dummy_and_preserves_unbrokered_credentials() -String::from_utf8_lossy(&output.stdout),format!("{dummy}\n{}", dir.path().display()));++ let system_startup_dir = dir.path().join("system-startup");+ std::fs::create_dir(&system_startup_dir)?;+ let system_startup_zsh = system_startup_dir.join("zsh");+ std::fs::write(+ &system_startup_zsh,+ "#!/bin/sh\nexport OPENAI_API_KEY='sk-system-startup-secret'\nexport AUTH_HEADER='Bearer sk-system-startup-secret'\nexec /bin/zsh -ax \"$@\"\n",+ )?;+ let mut permissions = std::fs::metadata(&system_startup_zsh)?.permissions();+ permissions.set_mode(0o700);+ std::fs::set_permissions(&system_startup_zsh, permissions)?;+ let (system_zsh, _) = shell_with_snapshot(+ ShellType::Zsh,+ system_startup_zsh.to_string_lossy().as_ref(),+ snapshot.clone(),+ );+ for (mut startup_env, expected_canonical, expected_alias) in [+ (alias_only_env, "unset", dummy_alias.as_str()),+ (empty_canonical_env, "", dummy_alias.as_str()),+ (absent_alias_env, dummy.as_str(), "unset"),+ ] {+ prepare_brokered_shell_snapshot_env(&mut startup_env, Some(&snapshot), &system_zsh);+ let command = vec![+ system_startup_zsh.display().to_string(),+ "-c".to_string(),+ format!(+ "set +x\nprintf '%s\\n%s\\n%s\\n%s\\n%s\\n' \"${{OPENAI_API_KEY-unset}}\" \"${{AUTH_HEADER-unset}}\" \"${{{SNAPSHOT_BROKERED_VALUE_ENV_PREFIX}AUTH_HEADER-unset}}\" \"${{{SNAPSHOT_BROKERED_VALUE_ENV_PREFIX}OPENAI_API_KEY-unset}}\" \"${{{SNAPSHOT_BROKERED_UNSET_ENV_PREFIX}OPENAI_API_KEY-unset}}\"\nenv -0"+ ),+ ];+ let system_rewritten = maybe_wrap_shell_lc_with_snapshot(+ &command,+ &system_zsh,+ Some(&snapshot),+ &HashMap::new(),+ &startup_env,+ &RuntimePathPrepends::default(),+ );+ let output = Command::new(&system_rewritten[0])+ .args(&system_rewritten[1..])+ .env_clear()+ .envs(&startup_env)+ .output()?;+ assert!(+ output.status.success(),+ "system startup command failed: {output:?}"+ );+ let stdout = String::from_utf8_lossy(&output.stdout);+ let exported_env = stdout+ .strip_prefix(&format!(+ "{expected_canonical}\n{expected_alias}\nunset\nunset\nunset\n"+ ))+ .unwrap_or_else(|| panic!("unexpected system startup output: {stdout}"));+ assert!(!stdout.contains("sk-system-startup-secret"));+ assert!(+ !exported_env+ .split('\0')+ .any(|entry| entry.starts_with("__CODEX_SNAPSHOT_PROXY_OVERRIDE_"))+ );+ assert!(!String::from_utf8_lossy(&output.stderr).contains("sk-system-startup-secret"));+ }++ for (bash_env, posix_env, zdotdir) in [+ (+ "$ZDOTDIR/startup.sh",+ "$ZDOTDIR/startup.sh",+ Some(dir.path()),+ ),+ ("${ZDOTDIR:-$HOME}/startup.sh", "$HOME/startup.sh", None),+ ] {+ let mut nested_zsh_env = env.clone();+ nested_zsh_env.remove(SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY);+ nested_zsh_env.insert("HOME".to_string(), dir.path().display().to_string());+ nested_zsh_env.insert("BASH_ENV".to_string(), bash_env.to_string());+ nested_zsh_env.insert("ENV".to_string(), posix_env.to_string());+ if let Some(zdotdir) = zdotdir {+ nested_zsh_env.insert("ZDOTDIR".to_string(), zdotdir.display().to_string());+ } else {+ nested_zsh_env.remove("ZDOTDIR");+ }+ prepare_brokered_shell_snapshot_env(&mut nested_zsh_env, Some(&snapshot), &zsh);+ let command = wrap_brokered_snapshot(&zsh, &snapshot, &nested_zsh_env, &no_prepends);+ assert_eq!(+ run_nested(&command, &nested_zsh_env)?,+ format!("{dummy}|unset")+ );+ }++ env.remove("ZDOTDIR");+ env.remove(SNAPSHOT_ORIGINAL_ZDOTDIR_ENV_KEY);+ prepare_brokered_shell_snapshot_env(&mut env, Some(&snapshot), &zsh);+ let output = Command::new(&rewritten[0])+ .args(&rewritten[1..])+ .env_clear()+ .envs(env)+ .output()?;+ assert!(output.status.success(), "zsh command failed: {output:?}");+ assert_eq!(+ String::from_utf8_lossy(&output.stdout),+ format!("{dummy}\n{}", dir.path().display())+ );}Ok(())}@@ -1437,3 +1895,118 @@ fn maybe_wrap_shell_lc_with_snapshot_preserves_unset_override_variables() {assert!(output.status.success(), "command failed: {output:?}");assert_eq!(String::from_utf8_lossy(&output.stdout), "unset");}++#[test]+fn brokered_credential_exports_stop_when_startup_makes_credential_readonly() {+ let copy_key = format!("{SNAPSHOT_BROKERED_VALUE_ENV_PREFIX}OPENAI_API_KEY");+ let env = HashMap::from([(copy_key.clone(), "dummy-openai-key".to_string())]);+ let restore = build_brokered_credential_exports(&env, /*remove_copies*/ true);++ let unset_output = Command::new("/bin/bash")+ .args([+ "-c",+ &format!(+ "unset OPENAI_API_KEY\n{restore}\nprintf '%s|%s' \"${{OPENAI_API_KEY-unset}}\" \"${{{copy_key}-unset}}\""+ ),+ ])+ .env(©_key, "dummy-openai-key")+ .output()+ .expect("run unset credential probe");+ assert!(+ unset_output.status.success(),+ "unset credential probe failed: {unset_output:?}"+ );+ assert_eq!(String::from_utf8_lossy(&unset_output.stdout), "unset|unset");++ let empty_output = Command::new("/bin/bash")+ .args([+ "-c",+ &format!(+ "OPENAI_API_KEY=\n{restore}\nprintf '%s|%s' \"$OPENAI_API_KEY\" \"${{{copy_key}-unset}}\""+ ),+ ])+ .env(©_key, "dummy-openai-key")+ .output()+ .expect("run empty credential probe");+ assert!(+ empty_output.status.success(),+ "empty credential probe failed: {empty_output:?}"+ );+ assert_eq!(String::from_utf8_lossy(&empty_output.stdout), "|unset");++ let unchanged_output = Command::new("/bin/bash")+ .args([+ "-c",+ &format!(+ "readonly OPENAI_API_KEY=dummy-openai-key\n{restore}\nprintf '%s|%s' \"$OPENAI_API_KEY\" \"${{{copy_key}-unset}}\""+ ),+ ])+ .env(©_key, "dummy-openai-key")+ .output()+ .expect("run unchanged readonly credential probe");+ assert!(+ unchanged_output.status.success(),+ "unchanged readonly credential probe failed: {unchanged_output:?}"+ );+ assert_eq!(+ String::from_utf8_lossy(&unchanged_output.stdout),+ "dummy-openai-key|unset"+ );++ let xtrace_output = Command::new("/bin/bash")+ .args([+ "-c",+ &format!(+ "OPENAI_API_KEY=real-openai-key\nset -x\n{restore}\nset +x\nprintf '%s|%s' \"$OPENAI_API_KEY\" \"${{{copy_key}-unset}}\""+ ),+ ])+ .env(©_key, "dummy-openai-key")+ .output()+ .expect("run xtrace credential probe");+ assert!(+ xtrace_output.status.success(),+ "xtrace credential probe failed: {xtrace_output:?}"+ );+ assert_eq!(+ String::from_utf8_lossy(&xtrace_output.stdout),+ "dummy-openai-key|unset"+ );+ assert!(!String::from_utf8_lossy(&xtrace_output.stderr).contains("real-openai-key"));++ let unset_marker_key = format!("{SNAPSHOT_BROKERED_UNSET_ENV_PREFIX}OPENAI_API_KEY");+ let unset_env = HashMap::from([(unset_marker_key.clone(), "1".to_string())]);+ let unset_restore = build_brokered_credential_exports(&unset_env, /*remove_copies*/ true);+ let readonly_empty_output = Command::new("/bin/bash")+ .args([+ "-c",+ &format!(+ "readonly OPENAI_API_KEY=\n{unset_restore}\nprintf '%s|%s' \"$OPENAI_API_KEY\" \"${{{unset_marker_key}-unset}}\""+ ),+ ])+ .env(&unset_marker_key, "1")+ .output()+ .expect("run readonly empty credential probe");+ assert!(+ readonly_empty_output.status.success(),+ "readonly empty credential probe failed: {readonly_empty_output:?}"+ );+ assert_eq!(+ String::from_utf8_lossy(&readonly_empty_output.stdout),+ "|unset"+ );++ let output = Command::new("/bin/bash")+ .args([+ "-c",+ &format!("readonly OPENAI_API_KEY=real-openai-key\n{restore}\nprintf should-not-run"),+ ])+ .env(copy_key, "dummy-openai-key")+ .output()+ .expect("run readonly credential probe");++ assert!(!output.status.success(), "command unexpectedly succeeded");+ assert!(+ output.stdout.is_empty(),+ "protected command unexpectedly ran"+ );+}diff --git a/codex-rs/core/src/tools/runtimes/unified_exec.rs b/codex-rs/core/src/tools/runtimes/unified_exec.rsindex 2f9d9327e6..d6a04c4e7f 100644--- a/codex-rs/core/src/tools/runtimes/unified_exec.rs+++ b/codex-rs/core/src/tools/runtimes/unified_exec.rs@@ -43,6 +43,7 @@ use crate::unified_exec::UnifiedExecError;use crate::unified_exec::UnifiedExecProcess;use crate::unified_exec::UnifiedExecProcessManager;use codex_core_plugins::PluginMetricsSidecar;+use codex_network_proxy::CREDENTIAL_BROKER_ACTIVE_ENV_KEY;use codex_network_proxy::ManagedNetworkSandboxContext;use codex_network_proxy::NetworkProxy;use codex_protocol::error::CodexErr;@@ -405,7 +406,45 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRunt}None => (env, None, None),};- super::prepare_brokered_shell_snapshot_env(&mut env, shell_snapshot_location.as_ref());+ if let Some(snapshot) = shell_snapshot.as_ref() {+ snapshot.restore_fail_open_aliases(&mut env);+ }+ if managed_network.is_some()+ && !environment_is_remote+ && shell.shell_type == ShellType::Sh+ && env+ .get(CREDENTIAL_BROKER_ACTIVE_ENV_KEY)+ .is_some_and(|active| active == "1")+ && let Some(startup_env) = shell_snapshot+ .as_ref()+ .and_then(|snapshot| snapshot.protected_startup_env())+ {+ env.insert(+ super::SNAPSHOT_ORIGINAL_POSIX_ENV_ENV_KEY.to_string(),+ startup_env.to_string(),+ );+ }+ super::prepare_brokered_shell_snapshot_env(+ &mut env,+ shell_snapshot_location.as_ref(),+ shell,+ );+ if env+ .get(CREDENTIAL_BROKER_ACTIVE_ENV_KEY)+ .is_some_and(|active| active == "1")+ && let Some(snapshot) = shell_snapshot.as_ref()+ {+ for key in snapshot.startup_credential_keys() {+ if !super::is_valid_shell_variable_name(key) {+ continue;+ }+ let (prefix, value) = match env.get(key) {+ Some(value) => (super::SNAPSHOT_BROKERED_VALUE_ENV_PREFIX, value.clone()),+ None => (super::SNAPSHOT_BROKERED_UNSET_ENV_PREFIX, "1".to_string()),+ };+ env.insert(format!("{prefix}{key}"), value);+ }+ }let explicit_env_overrides = req.explicit_env_overrides.clone();let metrics_sidecar = sidecar_for_command(ctx,@@ -485,7 +524,7 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRuntif !environment_is_remote&& matches!(shell.shell_type, ShellType::PowerShell | ShellType::Cmd)&& env- .get(codex_network_proxy::CREDENTIAL_BROKER_ACTIVE_ENV_KEY)+ .get(CREDENTIAL_BROKER_ACTIVE_ENV_KEY).is_some_and(|active| active == "1")&& let Some(network) = managed_network{diff --git a/codex-rs/core/tests/suite/approvals.rs b/codex-rs/core/tests/suite/approvals.rsindex 9a6ffec4a2..efa1b98a88 100644--- a/codex-rs/core/tests/suite/approvals.rs+++ b/codex-rs/core/tests/suite/approvals.rs@@ -2805,6 +2805,8 @@ async fn spawned_subagent_execpolicy_amendment_propagates_to_parent_session() ->#[test_case("direct", false, false; "explicit_zsh")]#[test_case("direct", true, false; "non_login_in_login_enabled_session")]#[test_case("direct", true, true; "login_startup")]+#[test_case("filtered_startup", false, false; "filtered_global_startup")]+#[test_case("startup_override", false, false; "global_startup_overrides")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn shell_startup_credentials_are_brokered(shell_mode: &'static str,@@ -2816,6 +2818,8 @@ async fn shell_startup_credentials_are_brokered(const GH_HOST: &str = "github.example.com";const REAL_GITHUB_TOKEN: &str ="ghp_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";+ let global_startup = matches!(shell_mode, "filtered_startup" | "startup_override");+ let direct = shell_mode == "direct" || global_startup;let builder = if shell_mode == "zsh_fork" {let Some(runtime) = zsh_fork_runtime("zsh-fork credential broker environment test")? else {@@ -2844,6 +2848,7 @@ async fn shell_startup_credentials_are_brokered(format!("export GH_HOST='{GH_HOST}'\n\if [[ ! -o login ]]; then export GH_ENTERPRISE_TOKEN='{REAL_GITHUB_TOKEN}'; fi\n\+ export AUTH_HEADER=\"Bearer $GH_ENTERPRISE_TOKEN\"\n\export APP_SETTING EXCLUDED_SETTING\n\export BROKERED_STARTUP_CWD=\"$PWD\"\n\if {untrusted_snapshot_condition}; then\n\@@ -2860,13 +2865,32 @@ async fn shell_startup_credentials_are_brokered(fs::write(startup_dir.join(".zshrc"),format!(- "export LOGIN_SNAPSHOT_READY=ready\nexport GH_ENTERPRISE_TOKEN='{REAL_GITHUB_TOKEN}'\n"+ "export LOGIN_SNAPSHOT_READY=ready\nexport GH_ENTERPRISE_TOKEN='{REAL_GITHUB_TOKEN}'\n\+ export AUTH_HEADER=\"Bearer $GH_ENTERPRISE_TOKEN\"\n"),)?;fs::write(startup_dir.join(".zprofile"),"export LOGIN_SHELL_READY=ready\n",)?;+ let startup_shell = if global_startup {+ let Some(zsh) = codex_core::shell::get_shell(codex_core::shell::ShellType::Zsh) else {+ return Ok(());+ };+ let zsh_path = zsh.derive_exec_args("", /*use_login_shell*/ false)[0].clone();+ let path = startup_dir.join("zsh");+ fs::write(+ &path,+ format!(+ "#!/bin/sh\nexport GH_ENTERPRISE_TOKEN='{REAL_GITHUB_TOKEN}'\nexport AUTH_HEADER=\"Bearer $GH_ENTERPRISE_TOKEN\"\nexec {} \"$@\"\n",+ shlex::try_quote(&zsh_path)?+ ),+ )?;+ fs::set_permissions(&path, fs::Permissions::from_mode(/*mode*/ 0o700))?;+ Some(path)+ } else {+ None+ };fs::write(home.path().join("config.toml"),format!(@@ -2883,7 +2907,7 @@ ZDOTDIR = "{}"let mut builder = builder.with_home(home).with_cloud_config_bundle(managed_network_requirements_loader());- if shell_mode == "direct" && !allow_login_shell {+ if direct && !allow_login_shell {let Some(bash) = codex_core::shell::get_shell(codex_core::shell::ShellType::Bash) else {return Ok(());};@@ -2894,11 +2918,21 @@ ZDOTDIR = "{}"config.permissions.shell_environment_policy.exclude.push(EnvironmentVariablePattern::new_case_insensitive("EXCLUDED_SETTING"),);+ if shell_mode == "filtered_startup" {+ config.permissions.shell_environment_policy.exclude.push(+ EnvironmentVariablePattern::new_case_insensitive("GH_ENTERPRISE_TOKEN"),+ );+ } else if shell_mode == "startup_override" {+ config.permissions.shell_environment_policy.r#set.extend([+ ("GH_ENTERPRISE_TOKEN".to_string(), String::new()),+ ("AUTH_HEADER".to_string(), "enterprise-header".to_string()),+ ]);+ }config.features.enable(Feature::ShellSnapshot).expect("test config should allow ShellSnapshot override");- if shell_mode == "direct" {+ if direct {config.features.disable(Feature::ShellZshFork)@@ -2916,19 +2950,22 @@ ZDOTDIR = "{}"workdir};let call_id = "zsh-fork-brokered-github-credential";- let command = r#"printf '%s\n%s\n%s\n%s\n%s\n%s\n' "$GH_HOST" "$GH_ENTERPRISE_TOKEN" "$CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE" "$PWD" "$BROKERED_STARTUP_CWD" "${LOGIN_SNAPSHOT_READY-unset}""#;+ let command = r#"printf '%s\n%s\n%s\n%s\n%s\n%s\n%s\n' "$GH_HOST" "$GH_ENTERPRISE_TOKEN" "$CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE" "$PWD" "$BROKERED_STARTUP_CWD" "${LOGIN_SNAPSHOT_READY-unset}" "$AUTH_HEADER""#;let command = format!("APP_SETTING=production; EXCLUDED_SETTING=denied; [ \"$(/usr/bin/printenv APP_SETTING)\" = production ] || exit 1; if /usr/bin/printenv EXCLUDED_SETTING >/dev/null; then exit 1; fi; {command}");let snapshot_dir_arg = shlex::try_join([snapshot_dir.to_string_lossy().as_ref()])?;let command = format!("{command}; /bin/cat {snapshot_dir_arg}/*.sh > captured-snapshot");- let arguments = if shell_mode == "direct" {+ let arguments = if direct {let Some(zsh) = codex_core::shell::get_shell(codex_core::shell::ShellType::Zsh) else {return Ok(());};json!({"cmd": command,- "shell": zsh.derive_exec_args("", /*use_login_shell*/ false)[0],+ "shell": startup_shell.map_or_else(+ || zsh.derive_exec_args("", /*use_login_shell*/ false)[0].clone(),+ |path| path.display().to_string(),+ ),"workdir": workdir,"login": login,"yield_time_ms": 10_000,@@ -2978,11 +3015,24 @@ ZDOTDIR = "{}"assert_eq!(result.exit_code, Some(0), "command failed: {result:?}");assert!(!result.stdout.contains(REAL_GITHUB_TOKEN));let values = result.stdout.lines().collect::<Vec<_>>();- assert_eq!(values.len(), 6, "unexpected command output: {result:?}");+ assert_eq!(values.len(), 7, "unexpected command output: {result:?}");assert_eq!(values[0], GH_HOST);assert_ne!(values[1], REAL_GITHUB_TOKEN);- assert!(values[1].starts_with("ghp_"));- assert_eq!(values[1].len(), REAL_GITHUB_TOKEN.len());+ if global_startup {+ assert_eq!(values[1], "");+ assert_eq!(+ values[6],+ if shell_mode == "startup_override" {+ "enterprise-header"+ } else {+ ""+ }+ );+ } else {+ assert!(values[1].starts_with("ghp_"));+ assert_eq!(values[1].len(), REAL_GITHUB_TOKEN.len());+ assert_eq!(values[6], format!("Bearer {}", values[1]));+ }assert_eq!(values[2], "1");assert_eq!(PathBuf::from(values[3]), fs::canonicalize(&workdir)?);assert_eq!(PathBuf::from(values[4]), fs::canonicalize(&workdir)?);@@ -3253,6 +3303,117 @@ GH_TOKEN = "{REAL_GITHUB_TOKEN}"Ok(())}+#[cfg(unix)]+#[test_case(true; "credential_startup")]+#[test_case(false; "ordinary_application_env")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn brokered_posix_startup_preserves_application_env(credential_startup: bool) -> Result<()> {+ skip_if_no_network!(Ok(()));+ const REAL_TOKEN: &str = "ghp_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";+ let Some(shell) = codex_core::shell::get_shell(codex_core::shell::ShellType::Sh) else {+ return Ok(());+ };+ let home = Arc::new(TempDir::new()?);+ let startup = home.path().join("startup.sh");+ let credential_export = format!("export GH_TOKEN='{REAL_TOKEN}'\n");+ fs::write(+ &startup,+ format!(+ "export CORP_REGION=west\n{}",+ if credential_startup {+ credential_export.as_str()+ } else {+ ""+ }+ ),+ )?;+ fs::write(+ home.path().join("config.toml"),+ format!(+ r#"default_permissions = "brokered"+features = {{ network_proxy = {{ enabled = true, credential_broker = true }} }}+permissions = {{ brokered = {{ extends = ":workspace", network = {{ enabled = true, allow_local_binding = true }} }} }}+[shell_environment_policy.set]+ENV = "{}"+"#,+ startup.display()+ ),+ )?;+ let shell_path = shell.derive_exec_args("", /*use_login_shell*/ false)[0].clone();+ let server = start_mock_server().await;+ let test = test_codex()+ .with_home(home)+ .with_user_shell(shell)+ .with_cloud_config_bundle(managed_network_requirements_loader())+ .with_config(move |config| {+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::Never);+ config.permissions.allow_login_shell = true;+ config.features.enable(Feature::ShellSnapshot).unwrap();+ config.features.disable(Feature::ShellZshFork).unwrap();+ if !credential_startup {+ config+ .permissions+ .shell_environment_policy+ .r#set+ .insert("GH_TOKEN".to_string(), REAL_TOKEN.to_string());+ }+ })+ .build(&server)+ .await?;+ let script = r#"printf '%s\n%s\n%s\n%s\n' "$GH_TOKEN" "$CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE" "${ENV-unset}" "$CORP_REGION""#;+ let command = format!(+ "{} 2>/dev/null",+ shlex::try_join([shell_path.as_str(), "-i", "-c", script])?+ );+ let call_id = "brokered-posix-startup";+ let responses = mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_response_created("posix-startup-1"),+ shell_event(+ call_id,+ &command,+ /*timeout_ms*/ 5_000,+ SandboxPermissions::UseDefault,+ )?,+ ev_completed("posix-startup-1"),+ ]),+ sse(vec![+ ev_assistant_message("posix-startup-done", "done"),+ ev_completed("posix-startup-2"),+ ]),+ ],+ )+ .await;+ submit_turn_preserving_active_permission_profile(+ &test,+ "show the POSIX startup environment",+ AskForApproval::Never,+ )+ .await?;+ wait_for_completion_without_approval(&test).await;+ let result = parse_result(&responses.requests()[1].function_call_output(call_id));+ assert_eq!(result.exit_code, Some(0), "command failed: {result:?}");+ assert!(!result.stdout.contains(REAL_TOKEN));+ let values = result.stdout.lines().collect::<Vec<_>>();+ assert_eq!(values.len(), 4, "unexpected command output: {result:?}");+ assert!(values[0].starts_with("ghp_"));+ assert_eq!(+ &values[1..],+ &[+ "1",+ if credential_startup {+ "unset"+ } else {+ startup.to_str().unwrap()+ },+ "west"+ ]+ );+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]#[cfg(unix)]async fn env_zsh_script_spawned_by_python_can_request_escalation_under_zsh_fork() -> Result<()> {diff --git a/codex-rs/network-proxy/src/credential_broker.rs b/codex-rs/network-proxy/src/credential_broker.rsindex 10722da569..f2898014b1 100644--- a/codex-rs/network-proxy/src/credential_broker.rs+++ b/codex-rs/network-proxy/src/credential_broker.rs@@ -11,6 +11,7 @@ use std::sync::RwLock;pub const CREDENTIAL_BROKER_ACTIVE_ENV_KEY: &str = "CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE";pub(crate) const BROKERED_CREDENTIALS_ENV_KEY: &str = "CODEX_NETWORK_PROXY_BROKERED_CREDENTIALS";const MIN_EMBEDDED_CREDENTIAL_LENGTH: usize = 16;+const BROKERED_CREDENTIAL_ALIAS_MARKER_PREFIX: &str = "@alias:";#[derive(Clone)]pub(crate) struct CredentialBroker {@@ -596,19 +597,37 @@ fn update_brokered_credentials_marker(state: &CredentialBrokerState,env: &mut HashMap<String, String>,) {- let brokered = providers::credential_env_keys()- .filter_map(|key| {- let (actual_key, value) = env_entry(env, key)?;- state- .credentials- .iter()- .any(|credential| {- env_key_matches(actual_key, &credential.env_var)- && value == credential.dummy_value- })- .then_some((actual_key, value))+ let mut brokered = state+ .credentials+ .iter()+ .filter(|credential| {+ env.iter().any(|(key, value)| {+ !env_key_matches(key, CREDENTIAL_BROKER_ACTIVE_ENV_KEY)+ && !env_key_matches(key, BROKERED_CREDENTIALS_ENV_KEY)+ && (value == &credential.dummy_value+ || credential.dummy_value.len() >= MIN_EMBEDDED_CREDENTIAL_LENGTH+ && value.contains(&credential.dummy_value))+ })})+ .map(|credential| (credential.env_var.clone(), credential.dummy_value.clone()))+ .collect::<Vec<_>>();+ let brokered_dummy_values = brokered+ .iter()+ .map(|(_, dummy_value)| dummy_value.clone()).collect::<Vec<_>>();+ brokered.extend(state.credential_aliases.iter().filter_map(|alias| {+ let dummy_value = brokered_dummy_values.iter().find(|&dummy_value| {+ alias.dummy_value == *dummy_value+ || dummy_value.len() >= MIN_EMBEDDED_CREDENTIAL_LENGTH+ && alias.dummy_value.contains(dummy_value)+ })?;+ Some((+ format!("{BROKERED_CREDENTIAL_ALIAS_MARKER_PREFIX}{}", alias.env_var),+ dummy_value.clone(),+ ))+ }));+ brokered.sort_unstable();+ brokered.dedup();match serde_json::to_string(&brokered) {Ok(marker) => {set_env_value(env, BROKERED_CREDENTIALS_ENV_KEY, marker);@@ -660,6 +679,77 @@ pub fn brokered_credential_dummy_env_keys(env: &HashMap<String, String>) -> Vec<keys}+/// Returns canonical credential and known alias keys recorded for an active brokered child,+/// including keys that are currently absent.+pub fn brokered_credential_marker_env_keys(env: &HashMap<String, String>) -> Vec<String> {+ if env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY) != Some("1") {+ return Vec::new();+ }+ let entries = env_value(env, BROKERED_CREDENTIALS_ENV_KEY)+ .and_then(|marker| serde_json::from_str::<Vec<(String, String)>>(marker).ok())+ .unwrap_or_default();+ let dummy_values = entries+ .iter()+ .filter(|(key, _)| {+ providers::credential_env_keys().any(|candidate| env_key_matches(key, candidate))+ })+ .map(|(_, dummy_value)| dummy_value.clone())+ .collect::<Vec<_>>();+ let mut keys = entries+ .into_iter()+ .filter_map(|(key, value)| {+ if providers::credential_env_keys().any(|candidate| env_key_matches(&key, candidate)) {+ return Some(key);+ }+ let alias_key = key.strip_prefix(BROKERED_CREDENTIAL_ALIAS_MARKER_PREFIX)?;+ let known_alias = dummy_values.iter().any(|dummy_value| {+ value == *dummy_value+ || dummy_value.len() >= MIN_EMBEDDED_CREDENTIAL_LENGTH+ && value.contains(dummy_value)+ });+ known_alias.then(|| alias_key.to_string())+ })+ .collect::<Vec<_>>();+ keys.sort_unstable();+ keys.dedup();+ keys+}++/// Returns environment keys whose current values are brokered dummies or aliases containing them,+/// including aliases retained after their canonical source variable was removed.+pub fn brokered_credential_value_env_keys(env: &HashMap<String, String>) -> Vec<String> {+ if env_value(env, CREDENTIAL_BROKER_ACTIVE_ENV_KEY) != Some("1") {+ return Vec::new();+ }+ let dummy_values = 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_env_keys()+ .any(|candidate| env_key_matches(&key, candidate))+ .then_some(dummy_value)+ })+ .collect::<Vec<_>>();+ let mut keys = env+ .iter()+ .filter(|(key, _)| {+ !env_key_matches(key, CREDENTIAL_BROKER_ACTIVE_ENV_KEY)+ && !env_key_matches(key, BROKERED_CREDENTIALS_ENV_KEY)+ })+ .filter(|(_, value)| {+ dummy_values.iter().any(|dummy| {+ value.as_str() == dummy.as_str()+ || dummy.len() >= MIN_EMBEDDED_CREDENTIAL_LENGTH+ && value.contains(dummy.as_str())+ })+ })+ .map(|(key, _)| key.clone())+ .collect::<Vec<_>>();+ keys.sort_unstable();+ keys+}+/// Returns environment keys used to bind currently brokered credentials to hosts.pub fn brokered_credential_binding_env_keys(env: &HashMap<String, String>,diff --git a/codex-rs/network-proxy/src/credential_broker_tests.rs b/codex-rs/network-proxy/src/credential_broker_tests.rsindex d9155987a3..34e4244a81 100644--- a/codex-rs/network-proxy/src/credential_broker_tests.rs+++ b/codex-rs/network-proxy/src/credential_broker_tests.rs@@ -765,6 +765,54 @@ fn brokered_credential_env_keys_only_include_registered_credentials() {);}+#[test]+fn brokered_credential_value_env_keys_include_dummy_aliases() {+ let broker = CredentialBroker::new(/*enabled*/ true);+ let real = "sk-proj-abcdefghijklmnopqrstuvwxyz";+ let alias = format!("Bearer {real}");+ let mut env = env_map([("OPENAI_API_KEY", real), ("AUTH_HEADER", alias.as_str())]);++ broker.virtualize_child_env(&mut env);++ let marker: Vec<(String, String)> =+ serde_json::from_str(&env[BROKERED_CREDENTIALS_ENV_KEY]).unwrap();+ assert_eq!(+ marker,+ vec![+ (+ "@alias:AUTH_HEADER".to_string(),+ env["OPENAI_API_KEY"].clone()+ ),+ ("OPENAI_API_KEY".to_string(), env["OPENAI_API_KEY"].clone()),+ ]+ );++ assert_eq!(+ brokered_credential_value_env_keys(&env),+ vec!["AUTH_HEADER".to_string(), "OPENAI_API_KEY".to_string()]+ );++ let mut absent_alias_env = env.clone();+ absent_alias_env.remove("AUTH_HEADER");+ broker.virtualize_child_env(&mut absent_alias_env);+ assert_eq!(+ brokered_credential_marker_env_keys(&absent_alias_env),+ vec!["AUTH_HEADER".to_string(), "OPENAI_API_KEY".to_string()]+ );++ env.remove("OPENAI_API_KEY");+ broker.virtualize_child_env(&mut env);+ assert!(brokered_credential_dummy_env_keys(&env).is_empty());+ assert_eq!(+ brokered_credential_marker_env_keys(&env),+ vec!["AUTH_HEADER".to_string(), "OPENAI_API_KEY".to_string()]+ );+ assert_eq!(+ brokered_credential_value_env_keys(&env),+ vec!["AUTH_HEADER".to_string()]+ );+}+#[test]fn virtualize_child_env_uses_fresh_dummy_capabilities() {let mut first_env = env_map([("OPENAI_API_KEY", "sk-proj-abcdefghijklmnopqrstuvwxyz")]);diff --git a/codex-rs/network-proxy/src/lib.rs b/codex-rs/network-proxy/src/lib.rsindex f71a334aed..52543f5842 100644--- a/codex-rs/network-proxy/src/lib.rs+++ b/codex-rs/network-proxy/src/lib.rs@@ -47,6 +47,8 @@ pub use credential_broker::CREDENTIAL_BROKER_ACTIVE_ENV_KEY;pub use credential_broker::brokered_credential_binding_env_keys;pub use credential_broker::brokered_credential_dummy_env_keys;pub use credential_broker::brokered_credential_env_keys;+pub use credential_broker::brokered_credential_marker_env_keys;+pub use credential_broker::brokered_credential_value_env_keys;pub use credential_broker::credential_broker_provider_context_env_keys;pub use credential_broker::credential_broker_provider_sources_allowed;pub use credential_broker::is_credential_broker_provider_env_key;diff --git a/codex-rs/shell-command/src/shell_snapshot.rs b/codex-rs/shell-command/src/shell_snapshot.rsindex 228029cbd1..5ebdd569af 100644--- a/codex-rs/shell-command/src/shell_snapshot.rs+++ b/codex-rs/shell-command/src/shell_snapshot.rs@@ -6,6 +6,8 @@ mod capture;mod credentials;#[path = "shell_snapshot_exports.rs"]mod exports;+#[path = "shell_snapshot_literals.rs"]+mod literals;#[path = "shell_snapshot_render.rs"]mod render;@@ -17,6 +19,8 @@ pub use credentials::PreparedSnapshot;pub use credentials::SnapshotCredentialEnvironment;pub use credentials::prepare_snapshot_credentials;+use capture::BASH_SH_SNAPSHOT_HEADER;+#[cfg(all(test, unix))]#[path = "shell_snapshot_tests.rs"]mod tests;diff --git a/codex-rs/shell-command/src/shell_snapshot_capture.rs b/codex-rs/shell-command/src/shell_snapshot_capture.rsindex ecf8b4eef7..263d196970 100644--- a/codex-rs/shell-command/src/shell_snapshot_capture.rs+++ b/codex-rs/shell-command/src/shell_snapshot_capture.rs@@ -1,8 +1,9 @@//! Capture native shell state and decode complete export records without applying credential policy.-//! Retain native declaration flags and reject incomplete records.+//! Retain native declaration flags and tied-array boundaries; reject incomplete records.use super::SnapshotStartup;use super::exports;+use super::literals;use super::posix_env_path_expansion_function;use crate::shell_detect::ShellType;use std::borrow::Cow;@@ -156,6 +157,8 @@ SNAPSHOT_ENVIRONMENTformat!("{startup}{script}")}+pub(super) const BASH_SH_SNAPSHOT_HEADER: &str = "# Snapshot file\n# Bash-backed sh\n";+fn sh_snapshot_script(shell_startup: SnapshotStartup) -> String {let startup = match shell_startup {SnapshotStartup::Interactive => [@@ -229,6 +232,7 @@ SNAPSHOT_ENVIRONMENTpub struct CapturedSnapshot<'a> {/// Resolved POSIX startup file and its environment immediately before sourcing it.pub startup_environment: Option<CapturedStartupEnvironment<'a>>,+ pub(super) shell_type: ShellType,pub(super) state: &'a str,pub(super) aliases: &'a str,pub(super) exports: Vec<CapturedExport<'a>>,@@ -238,13 +242,26 @@ pub struct CapturedSnapshot<'a> {/// Optional pre-startup state captured alongside the final snapshot records.pub struct CapturedStartupEnvironment<'a> {- pub path: &'a str,+ pub path: Cow<'a, str>,pub environment: &'a [u8],}pub(super) struct CapturedExport<'a> {pub source: Cow<'a, str>,pub key: &'a str,+ pub value: ExportValue,+}++pub(super) enum ExportValue {+ Plain,+ TiedArray(CapturedArray),+ UnparsedArray,+}++pub(super) struct CapturedArray {+ pub span: std::ops::Range<usize>,+ pub values: Vec<Vec<u8>>,+ pub separator: Vec<u8>,}impl<'a> CapturedSnapshot<'a> {@@ -262,7 +279,7 @@ impl<'a> CapturedSnapshot<'a> {.position(|part| part == startup_marker){remaining = &remaining[start + startup_marker.len()..];- let path = std::str::from_utf8(take_record(&mut remaining)?).ok()?;+ let path = String::from_utf8_lossy(take_record(&mut remaining)?);let environment = remaining;while !take_record(&mut remaining)?.is_empty() {}let environment = &environment[..environment.len() - remaining.len() - 1];@@ -310,11 +327,13 @@ impl<'a> CapturedSnapshot<'a> {shlex::try_quote(&value).ok()?)),key,+ value: ExportValue::Plain,});}}return Some(Self {startup_environment,+ shell_type,state,aliases,exports: records,@@ -322,7 +341,75 @@ impl<'a> CapturedSnapshot<'a> {});}let source = String::from_utf8_lossy(take_record(&mut remaining)?);- records.push(CapturedExport { source, key });+ // Only tied arrays need syntax decoding; scalar values remain native declarations.+ let tied = shell_type == ShellType::Zsh+ && source+ .split_whitespace()+ .skip(/*n*/ 1)+ .take_while(|word| word.starts_with('-'))+ .any(|flags| flags.contains('T'));+ let tree = tied+ .then(|| crate::bash::try_parse_shell(&source))+ .flatten();+ let array = tree.as_ref().and_then(|tree| {+ if tree.root_node().has_error() {+ return None;+ }+ let mut cursor = tree.root_node().walk();+ tree.root_node()+ .named_child(/*i*/ 0)?+ .named_children(&mut cursor)+ .find_map(|child| {+ child+ .child_by_field_name("value")+ .filter(|value| value.kind() == "array")+ })+ });+ let value = if let Some(array) = array {+ let mut cursor = array.walk();+ let values = array+ .named_children(&mut cursor)+ .map(|node| {+ literals::literal_word_bytes(+ node,+ &source,+ shell_type,+ literals::Quoting::Posix,+ )+ })+ .collect::<Option<Vec<_>>>();+ let separator = array.parent().and_then(|node| node.next_named_sibling());+ let separator = if let Some(separator) = separator+ && separator.kind() == "variable_name"+ {+ separator+ .utf8_text(source.as_bytes())+ .ok()+ .map(|value| value.as_bytes().to_vec())+ } else if let Some(separator) = separator {+ literals::literal_word_bytes(+ separator,+ &source,+ shell_type,+ literals::Quoting::Posix,+ )+ } else {+ Some(vec![b':'])+ };+ match (values, separator) {+ (Some(values), Some(separator)) => ExportValue::TiedArray(CapturedArray {+ span: array.byte_range(),+ values,+ separator,+ }),+ _ => ExportValue::UnparsedArray,+ }+ } else if tied {+ ExportValue::UnparsedArray+ } else {+ ExportValue::Plain+ };+ records.push(CapturedExport { source, key, value });}}}diff --git a/codex-rs/shell-command/src/shell_snapshot_credentials.rs b/codex-rs/shell-command/src/shell_snapshot_credentials.rsindex d2cf0054f4..66a96f7b65 100644--- a/codex-rs/shell-command/src/shell_snapshot_credentials.rs+++ b/codex-rs/shell-command/src/shell_snapshot_credentials.rs@@ -1,7 +1,9 @@//! Apply credential and environment policy to captured exports, producing typed render values.-//! Native declarations are rendered only after applying the supplied credential policy.+//! The shared literal decoder still validates alias and function bodies without evaluating them.use super::capture::CapturedSnapshot;+use super::capture::ExportValue;+use super::literals;use super::render;use super::render::Export;use super::render::Value;@@ -32,7 +34,7 @@ pub struct PreparedSnapshot {/// Prepare a replay script from captured state without changing the captured data.////// Credential policy is applied before rendering. A rejected capture produces no script,-/// when the assembled source still contains a recognized credential.+/// including when executable source reconstructs a credential through shell quoting.pub fn prepare_snapshot_credentials(captured: &CapturedSnapshot<'_>,environment: SnapshotCredentialEnvironment<'_>,@@ -136,7 +138,7 @@ pub fn prepare_snapshot_credentials(let mut alias_values = HashMap::new();let mut rejected_alias_keys = Vec::new();let mut invalid_export = false;- let mut exports = captured+ let exports = captured.exports.iter().filter_map(|export| {@@ -148,14 +150,46 @@ pub fn prepare_snapshot_credentials(|| brokered_keys.iter().any(|credential_key| credential_key == key)- || brokered_alias_keys- .iter()- .any(|credential_key| credential_key == key)- || is_disallowed_credential_alias(key, &mut virtualize_text){return None;}+ if configured.contains_key(key)+ && let ExportValue::TiedArray(array) = &export.value+ {+ let value = allowed.get(key)?;+ let mut virtualized = value.clone();+ if !virtualize_text(&mut virtualized) || virtualized != *value {+ invalid_export = true;+ return Some(Export::Captured(line));+ }+ if credential_aliases.remove(key).is_some() {+ alias_values.insert(key.to_string(), value.clone());+ }+ // An explicit scalar override replaces captured elements, not the array binding.+ return Some(Export::ArrayBinding {+ key,+ declaration: line[..array.span.start].strip_suffix('=')?,+ suffix: &line[array.span.end..],+ });+ }++ if is_disallowed_credential_alias(key, &mut virtualize_text) {+ return None;+ }++ if brokered_alias_keys.iter().any(|alias_key| alias_key == key) {+ // Source-less aliases keep their live scalar value, including explicit unsets.+ return match &export.value {+ ExportValue::TiedArray(array) => Some(Export::ArrayBinding {+ key,+ declaration: line[..array.span.start].strip_suffix('=')?,+ suffix: &line[array.span.end..],+ }),+ ExportValue::Plain | ExportValue::UnparsedArray => None,+ };+ }+if let Some(credential_keys) = credential_aliases.remove(key) {if !credential_alias_is_allowed(&credential_keys) {rejected_alias_keys.push(key.to_string());@@ -167,12 +201,74 @@ pub fn prepare_snapshot_credentials(let (assignment, value) =credential_alias_assignment(allowed.get(key)?, &credential_keys)?;alias_values.insert(key.to_string(), value);- if line- .split_whitespace()- .skip(/*n*/ 1)- .take_while(|word| word.starts_with('-'))- .any(|flags| flags.contains('T'))- {+ if let ExportValue::TiedArray(array) = &export.value {+ let scalar = array.values.join(array.separator.as_slice());+ let crosses_element = credential_keys+ .iter()+ .flat_map(|key| {+ [+ real_credential_value(key),+ original.get(*key),+ discovered.get(*key),+ ]+ })+ .flatten()+ .filter(|credential| !credential.is_empty())+ .any(|credential| {+ scalar+ .windows(credential.len())+ .enumerate()+ .any(|(start, bytes)| {+ if bytes != credential.as_bytes() {+ return false;+ }+ let mut offset = 0;+ !array.values.iter().any(|value| {+ let contains = offset <= start+ && start + credential.len() <= offset + value.len();+ offset += value.len() + array.separator.len();+ contains+ })+ })+ });+ if crosses_element {+ invalid_export = true;+ return Some(Export::Captured(line));+ }+ let Some((elements, normalized)) = array+ .values+ .iter()+ .map(|bytes| {+ let mut text = String::from_utf8(bytes.clone()).ok()?;+ if !virtualize_text(&mut text) {+ return None;+ }+ credential_alias_assignment(&text, &credential_keys)+ })+ .collect::<Option<Vec<_>>>()+ .map(|values| values.into_iter().unzip::<_, _, Vec<_>, Vec<_>>())+ else {+ invalid_export = true;+ return Some(Export::Captured(line));+ };+ // Never replay a known credential that crosses array-element boundaries.+ if normalized+ .iter()+ .map(String::as_bytes)+ .collect::<Vec<_>>()+ .join(array.separator.as_slice())+ != allowed.get(key)?.as_bytes()+ {+ invalid_export = true;+ return Some(Export::Captured(line));+ }+ return Some(Export::Array {+ prefix: &line[..array.span.start],+ elements,+ suffix: &line[array.span.end..],+ });+ }+ if matches!(export.value, ExportValue::UnparsedArray) {invalid_export = true;return Some(Export::Captured(line));}@@ -185,6 +281,7 @@ pub fn prepare_snapshot_credentials(Some(Export::Captured(line))}).collect::<Vec<_>>();+ let snapshot = render::render(captured.state, captured.aliases, &exports)?;if invalid_export {return None;}@@ -192,38 +289,31 @@ pub fn prepare_snapshot_credentials(for (key, credential_keys) in credential_aliases {if !is_disallowed_credential_alias(key, &mut virtualize_text)&& credential_alias_is_allowed(&credential_keys)- && let Some((assignment, value)) = allowed+ && let Some((_, value)) = allowed.get(key).and_then(|value| credential_alias_assignment(value, &credential_keys)){- exports.push(Export::Alias {- key,- value: assignment,- });+ // Native capture can deliberately omit readonly exports; retain only their metadata.alias_values.insert(key.to_string(), value);} else {rejected_alias_keys.push(key.to_string());}}- let mut snapshot = render::render(captured.state, captured.aliases, &exports)?;- let mut credential_values = original- .values()- .chain(restored.values())- .chain(configured.values())- .collect::<Vec<_>>();- credential_values.sort_unstable_by_key(|value| (std::cmp::Reverse(value.len()), *value));- credential_values.dedup();- for value in credential_values {- let mut replacement = value.clone();- if virtualize_text(&mut replacement) && replacement != *value {- snapshot = snapshot.replace(value, &replacement);- }+ let mut virtualized = snapshot.clone();+ if !virtualize_text(&mut virtualized) || virtualized != snapshot {+ return None;}- Some(PreparedSnapshot {- script: snapshot,- aliases: alias_values,- rejected_alias_keys,- })+ literals::literal_words(&snapshot, captured.shell_type)?+ .into_iter()+ .all(|word| {+ let mut virtualized = word.clone();+ virtualize_text(&mut virtualized) && virtualized == word+ })+ .then_some(PreparedSnapshot {+ script: snapshot,+ aliases: alias_values,+ rejected_alias_keys,+ })}diff --git a/codex-rs/shell-command/src/shell_snapshot_literals.rs b/codex-rs/shell-command/src/shell_snapshot_literals.rsnew file mode 100644index 0000000000..6985a34d3b--- /dev/null+++ b/codex-rs/shell-command/src/shell_snapshot_literals.rs@@ -0,0 +1,715 @@+use crate::bash::try_parse_shell;+use crate::shell_detect::ShellType;+use std::collections::HashSet;+use tree_sitter::Node;++#[derive(Clone, Copy, Eq, Hash, PartialEq)]+pub(super) enum Quoting {+ Posix,+ LegacyBash,+ ZshRcQuotes,+}++impl Quoting {+ fn deferred_modes(shell_type: ShellType) -> &'static [Self] {+ if matches!(shell_type, ShellType::Bash | ShellType::Sh) {+ &[Self::Posix, Self::LegacyBash]+ } else {+ &[Self::Posix, Self::ZshRcQuotes]+ }+ }+}++#[derive(Clone, Copy)]+enum Parsing {+ Snapshot,+ Deferred(Quoting),+}++pub(super) fn literal_words(script: &str, shell_type: ShellType) -> Option<Vec<String>> {+ // Bash invoked as sh still parses its array and alias syntax; other sh dialects do not.+ let shell_type =+ if shell_type == ShellType::Sh && script.starts_with(super::BASH_SH_SNAPSHOT_HEADER) {+ ShellType::Bash+ } else {+ shell_type+ };+ let mut checked_aliases = HashSet::new();+ let mut words =+ literal_words_with_quoting(script, shell_type, Parsing::Snapshot, &mut checked_aliases)?;+ if matches!(shell_type, ShellType::Bash | ShellType::Sh) {+ words.extend(literal_words_with_quoting(+ script,+ shell_type,+ Parsing::Deferred(Quoting::LegacyBash),+ &mut checked_aliases,+ )?);+ }+ Some(words)+}++fn literal_words_with_quoting(+ script: &str,+ shell_type: ShellType,+ parsing: Parsing,+ checked_aliases: &mut HashSet<(String, Quoting)>,+) -> Option<Vec<String>> {+ let tree = try_parse_shell(script)?;+ let mut cursor = tree.root_node().walk();+ let mut quoting = match parsing {+ Parsing::Snapshot => Quoting::Posix,+ Parsing::Deferred(quoting) => quoting,+ };+ let mut pending = Vec::new();+ // Zsh snapshots emit function definitions before restoring options and aliases.+ for node in tree.root_node().named_children(&mut cursor) {+ if matches!(parsing, Parsing::Snapshot) && node.kind() == "command" {+ match node.utf8_text(script.as_bytes()).ok()? {+ "setopt rcquotes" => quoting = Quoting::ZshRcQuotes,+ "unsetopt rcquotes" => quoting = Quoting::Posix,+ _ => {}+ }+ }+ pending.push((node, quoting));+ }+ let mut words = Vec::new();+ let mut checked_nodes = HashSet::new();+ while let Some((node, quoting)) = pending.pop() {+ if !checked_nodes.insert((node.id(), quoting)) {+ continue;+ }+ if matches!(node.kind(), "command_substitution" | "process_substitution") {+ if let Some(body) = node+ .utf8_text(script.as_bytes())+ .ok()?+ .strip_prefix('`')+ .and_then(|body| body.strip_suffix('`'))+ {+ // Backticks remove one escape layer before their command body is parsed.+ let mut context = node.parent();+ if shell_type == ShellType::Zsh {+ while context.is_some_and(|parent| {+ matches!(parent.kind(), "expansion" | "concatenation")+ }) {+ context = context.and_then(|parent| parent.parent());+ }+ }+ let in_double_quotes = context.is_some_and(|parent| parent.kind() == "string");+ let mut chars = body.chars().peekable();+ let mut body = String::new();+ while let Some(character) = chars.next() {+ if character == '\\' {+ match chars.peek() {+ Some('\n') => {+ chars.next();+ continue;+ }+ Some('$' | '`' | '\\') => {+ body.push(chars.next()?);+ continue;+ }+ Some('"') if in_double_quotes => {+ body.push(chars.next()?);+ continue;+ }+ _ => {}+ }+ }+ body.push(character);+ }+ for "ing in Quoting::deferred_modes(shell_type) {+ if checked_aliases.insert((body.clone(), quoting)) {+ words.extend(literal_words_with_quoting(+ &body,+ shell_type,+ Parsing::Deferred(quoting),+ checked_aliases,+ )?);+ }+ }+ continue;+ }+ // Deferred bodies may be parsed after the snapshot restores RC_QUOTES.+ let mut cursor = node.walk();+ for child in node.named_children(&mut cursor) {+ pending.extend(+ Quoting::deferred_modes(shell_type)+ .iter()+ .map(|"ing| (child, quoting)),+ );+ }+ continue;+ }+ if node.kind() == "heredoc_body" {+ let parent = node.parent()?;+ let mut cursor = parent.walk();+ let delimiter = parent+ .named_children(&mut cursor)+ .find(|child| child.kind() == "heredoc_start")?+ .utf8_text(script.as_bytes())+ .ok()?;+ let quoted = delimiter.contains(['\'', '"', '\\']);+ let strip_tabs = parent+ .children(&mut cursor)+ .any(|child| child.kind() == "<<-");+ let mut start = node.start_byte();+ let mut cursor = node.walk();+ // Decode static heredoc text without joining across an expansion.+ for end in node+ .named_children(&mut cursor)+ .filter(|child| !quoted && child.kind() != "heredoc_content")+ .map(Some)+ .chain(std::iter::once(None))+ {+ let text = &script[start..end.map_or(node.end_byte(), |child| child.start_byte())];+ let text = if strip_tabs {+ text.split_inclusive('\n')+ .map(|line| line.trim_start_matches('\t'))+ .collect::<String>()+ } else {+ text.to_string()+ };+ let mut chars = text.chars().peekable();+ let mut decoded = String::new();+ while let Some(character) = chars.next() {+ if !quoted && character == '\\' {+ match chars.peek() {+ Some('\n') => {+ chars.next();+ continue;+ }+ Some('$' | '`' | '\\') => {+ decoded.push(chars.next()?);+ continue;+ }+ _ => {}+ }+ }+ decoded.push(character);+ }+ words.push(decoded);+ if let Some(child) = end {+ start = child.end_byte();+ pending.push((child, quoting));+ }+ }+ continue;+ }+ let mut command_words: Vec<(std::ops::Range<usize>, Option<Vec<u8>>)> = Vec::new();+ let declaration = if node.kind() == "command" {+ let mut cursor = node.walk();+ for argument in node+ .child_by_field_name("name")+ .into_iter()+ .chain(node.children_by_field_name("argument", &mut cursor))+ {+ let word = literal_word_bytes(argument, script, shell_type, quoting);+ if shell_type == ShellType::Zsh+ && let Some((previous_range, previous_word)) = command_words.last_mut()+ && has_continuation_gap(script, previous_range.end, argument.start_byte())+ {+ *previous_word = previous_word.take().zip(word).map(|(mut previous, word)| {+ previous.extend(word);+ previous+ });+ previous_range.end = argument.end_byte();+ } else {+ command_words.push((argument.byte_range(), word));+ }+ }+ let mut arguments = command_words.iter().map(|(_, word)| {+ word.as_ref()+ .map(|word| String::from_utf8_lossy(word).into_owned())+ });+ let mut name = arguments.next().flatten();+ loop {+ match name.take().as_deref() {+ Some(+ name @ ("alias" | "declare" | "typeset" | "local" | "readonly" | "export"),+ ) => {+ break Some(name.to_string());+ }+ Some("noglob" | "-") if shell_type == ShellType::Zsh => {+ name = arguments.next().flatten();+ }+ Some("time") => {+ name = arguments.next().flatten();+ if shell_type == ShellType::Bash && name.as_deref() == Some("-p") {+ name = arguments.next().flatten();+ }+ }+ Some(prefix @ ("builtin" | "command")) => {+ name = arguments.next().flatten();+ if prefix == "command" {+ while name.as_deref().is_some_and(|argument| {+ argument.strip_prefix('-').is_some_and(|options| {+ !options.is_empty() && options.bytes().all(|byte| byte == b'p')+ })+ }) {+ name = arguments.next().flatten();+ }+ }+ if (prefix == "command"+ || prefix == "builtin" && shell_type != ShellType::Zsh)+ && name.as_deref() == Some("--")+ {+ name = arguments.next().flatten();+ }+ }+ _ => break None,+ }+ }+ } else {+ None+ };+ let is_alias = declaration.as_deref() == Some("alias");+ let may_initialize_array = shell_type == ShellType::Bash+ && (node.kind() == "declaration_command" || declaration.is_some() && !is_alias);+ if is_alias || may_initialize_array {+ // Bash can inherit an array's type from an earlier declaration or calling scope.+ // Aliases and quoted compound-array initializers are parsed again by the shell.+ let mut cursor = node.walk();+ for argument in node.named_children(&mut cursor) {+ if command_words.iter().any(|(range, _)| {+ range.start < argument.start_byte() && argument.end_byte() <= range.end+ }) {+ continue;+ }+ let continued = command_words.iter().find(|(range, _)| {+ range.start == argument.start_byte() && range.end > argument.end_byte()+ });+ if let Some(assignment) = continued+ .map_or_else(+ || literal_word_bytes(argument, script, shell_type, quoting),+ |(_, word)| word.clone(),+ )+ .or_else(|| {+ // A dynamic edge prevents full decoding, but not inspection of the+ // static fragments in the rest of the continued argument.+ let end = continued.map_or(argument.end_byte(), |(range, _)| range.end);+ let mut pieces = std::iter::successors(Some(argument), |piece| {+ piece.next_named_sibling()+ })+ .take_while(|piece| piece.end_byte() <= end)+ .collect::<Vec<_>>();+ pieces.reverse();+ let mut word = Vec::new();+ while let Some(piece) = pieces.pop() {+ if let Some(literal) =+ literal_word_bytes(piece, script, shell_type, quoting)+ {+ word.extend(literal);+ } else {+ match piece.kind() {+ "variable_assignment" => {+ word.extend_from_slice(b"_=");+ pieces.push(piece.child_by_field_name("value")?);+ }+ "concatenation" | "string" => pieces.extend(+ (0..piece.named_child_count())+ .rev()+ .filter_map(|index| piece.named_child(index)),+ ),+ "string_content" => {+ let text = piece.utf8_text(script.as_bytes()).ok()?;+ let decoded = shlex::split(&format!("\"{text}\""))?;+ let [literal] = decoded.as_slice() else {+ return None;+ };+ word.extend_from_slice(literal.as_bytes());+ }+ "simple_expansion"+ | "expansion"+ | "command_substitution"+ | "process_substitution"+ | "arithmetic_expansion" => {+ word.extend_from_slice(b"${__codex_snapshot_dynamic}");+ }+ _ => return None,+ }+ }+ }+ Some(word)+ })+ .map(|word| String::from_utf8_lossy(&word).into_owned())+ && let Some((_, body)) = assignment.split_once('=')+ {+ let body = if may_initialize_array {+ let body = body+ .trim_start_matches("${__codex_snapshot_dynamic}")+ .trim_end_matches("${__codex_snapshot_dynamic}");+ if !body.starts_with('(') || !body.ends_with(')') {+ continue;+ }+ format!("_={body}")+ } else {+ body.to_string()+ };+ for "ing in Quoting::deferred_modes(shell_type) {+ if checked_aliases.insert((body.clone(), quoting)) {+ words.extend(literal_words_with_quoting(+ &body,+ shell_type,+ Parsing::Deferred(quoting),+ checked_aliases,+ )?);+ }+ }+ }+ }+ }+ let mut pieces = vec![node];+ if shell_type == ShellType::Zsh+ && node.prev_named_sibling().is_none_or(|previous| {+ !has_continuation_gap(script, previous.end_byte(), node.start_byte())+ })+ {+ // Tree-sitter splits unquoted continuations into sibling words. Decode the+ // pieces separately: removing the gap would change adjacent RC_QUOTES strings.+ let mut previous = node;+ while let Some(next) = previous.next_named_sibling() {+ if !has_continuation_gap(script, previous.end_byte(), next.start_byte()) {+ break;+ }+ pieces.push(next);+ previous = next;+ }+ }+ let continued = pieces.len() > 1;+ if node.kind() == "ansi_c_string" {+ words.push(decode_ansi_c(+ node.utf8_text(script.as_bytes()).ok()?,+ shell_type,+ quoting,+ )?);+ if !continued {+ continue;+ }+ } else if let Some(word) = literal_word(node, script, shell_type, quoting) {+ words.push(word);+ if !continued {+ continue;+ }+ }+ if continued || matches!(node.kind(), "string" | "concatenation") {+ // Join adjacent static pieces, but never join across an expansion.+ pieces.reverse();+ let mut literal = Vec::new();+ let mut raw_string_end = None;+ while let Some(piece) = pieces.pop() {+ if let Some(word) = literal_word_bytes(piece, script, shell_type, quoting) {+ if matches!(quoting, Quoting::ZshRcQuotes)+ && piece.kind() == "raw_string"+ && raw_string_end == Some(piece.start_byte())+ {+ literal.push(b'\'');+ }+ literal.extend(word);+ raw_string_end = (piece.kind() == "raw_string").then_some(piece.end_byte());+ } else if piece.kind() == "variable_assignment" {+ if !literal.is_empty() {+ words.push(String::from_utf8_lossy(&literal).into_owned());+ literal.clear();+ }+ // Only the value can continue into the next word, never the assignment name.+ pieces.extend(piece.child_by_field_name("value"));+ } else if piece.kind() == "string_content" {+ let content = piece.utf8_text(script.as_bytes()).ok()?;+ let decoded = shlex::split(&format!("\"{content}\""))?;+ let [word] = decoded.as_slice() else {+ return None;+ };+ literal.extend_from_slice(word.as_bytes());+ } else if matches!(piece.kind(), "string" | "concatenation" | "command_name") {+ if shell_type == ShellType::Zsh+ && piece.prev_sibling().is_some_and(|previous| {+ previous.kind() == "$" && previous.end_byte() == piece.start_byte()+ })+ {+ literal.push(b'$');+ }+ pieces.extend(+ (0..piece.named_child_count())+ .rev()+ .filter_map(|index| piece.named_child(index)),+ );+ } else if !literal.is_empty() {+ words.push(String::from_utf8_lossy(&literal).into_owned());+ literal.clear();+ }+ }+ if !literal.is_empty() {+ words.push(String::from_utf8_lossy(&literal).into_owned());+ }+ }+ let mut cursor = node.walk();+ pending.extend(+ node.named_children(&mut cursor)+ .map(|child| (child, quoting)),+ );+ }+ Some(words)+}++fn has_continuation_gap(script: &str, left_end: usize, right_start: usize) -> bool {+ let gap = &script[left_end..right_start];+ !gap.is_empty() && gap.as_bytes().chunks(2).all(|pair| pair == b"\\\n")+}++fn literal_word(+ node: Node<'_>,+ script: &str,+ shell_type: ShellType,+ quoting: Quoting,+) -> Option<String> {+ let bytes = literal_word_bytes(node, script, shell_type, quoting)?;+ Some(String::from_utf8_lossy(&bytes).into_owned())+}++pub(super) fn literal_word_bytes(+ node: Node<'_>,+ script: &str,+ shell_type: ShellType,+ quoting: Quoting,+) -> Option<Vec<u8>> {+ let mut word = match node.kind() {+ "command_name" => node+ .named_child(0)+ .and_then(|name| literal_word_bytes(name, script, shell_type, quoting)),+ "concatenation" => {+ let mut cursor = node.walk();+ let mut word = Vec::new();+ let mut raw_string_end = None;+ for child in node.named_children(&mut cursor) {+ // RC_QUOTES treats adjacent single-quoted strings as one quoted apostrophe.+ if matches!(quoting, Quoting::ZshRcQuotes)+ && child.kind() == "raw_string"+ && raw_string_end == Some(child.start_byte())+ {+ word.push(b'\'');+ }+ word.extend(literal_word_bytes(child, script, shell_type, quoting)?);+ raw_string_end = (child.kind() == "raw_string").then_some(child.end_byte());+ }+ Some(word)+ }+ "ansi_c_string" => {+ decode_ansi_c_bytes(node.utf8_text(script.as_bytes()).ok()?, shell_type, quoting)+ }+ "word" | "number" | "string" | "raw_string" => {+ let mut cursor = node.walk();+ if node+ .named_children(&mut cursor)+ .any(|child| child.kind() != "string_content")+ {+ return None;+ }+ let text = node.utf8_text(script.as_bytes()).ok()?;+ let mut context = node.parent();+ while context+ .is_some_and(|parent| matches!(parent.kind(), "expansion" | "concatenation"))+ {+ context = context.and_then(|parent| parent.parent());+ }+ let words = if shell_type == ShellType::Zsh+ && node.kind() == "word"+ && context.is_some_and(|parent| parent.kind() == "string")+ {+ shlex::split(&format!("\"{text}\""))?+ } else {+ shlex::split(text)?+ };+ let [word] = words.as_slice() else {+ return None;+ };+ Some(word.as_bytes().to_vec())+ }+ _ => None,+ }?;+ if shell_type == ShellType::Zsh+ && matches!(node.kind(), "string" | "concatenation")+ && node.prev_sibling().is_some_and(|previous| {+ previous.kind() == "$" && previous.end_byte() == node.start_byte()+ })+ {+ word.insert(0, b'$');+ }+ Some(word)+}++// Decode the literal quoting emitted by Bash and Zsh, never shell expansions.+fn decode_ansi_c(raw: &str, shell_type: ShellType, quoting: Quoting) -> Option<String> {+ let bytes = decode_ansi_c_bytes(raw, shell_type, quoting)?;+ Some(String::from_utf8_lossy(&bytes).into_owned())+}++fn decode_ansi_c_bytes(raw: &str, shell_type: ShellType, quoting: Quoting) -> Option<Vec<u8>> {+ let body = raw.strip_prefix("$'")?;+ let body = body.strip_suffix('\'').or_else(|| {+ // Array-shaped scalar templates may contain incomplete shell syntax.+ (shell_type == ShellType::Bash).then_some(body)+ })?;+ let mut chars = body.chars().peekable();+ let mut decoded = Vec::new();+ let mut modifiers = ZshByteModifiers::default();+ while let Some(character) = chars.next() {+ if character != '\\' {+ let mut bytes = [0; 4];+ let bytes = character.encode_utf8(&mut bytes).as_bytes();+ decoded.push(modifiers.apply(bytes[0]));+ decoded.extend_from_slice(&bytes[1..]);+ continue;+ }+ let Some(escape) = chars.next() else {+ if shell_type == ShellType::Zsh {+ return None;+ }+ decoded.push(b'\\');+ break;+ };+ let byte = match escape {+ 'a' => 7,+ 'b' => 8,+ 'e' | 'E' => 27,+ 'f' => 12,+ 'n' => b'\n',+ 'r' => b'\r',+ 't' => b'\t',+ 'v' => 11,+ '\\' | '\'' | '"' | '?' => escape as u8,+ 'c' if shell_type != ShellType::Zsh => {+ let Some(character) = chars.next() else {+ decoded.push(b'\\');+ if quoting != Quoting::LegacyBash {+ decoded.push(b'c');+ }+ break;+ };+ // Bash 3.2 leaves the second backslash; newer Bash consumes the pair.+ if character == '\\'+ && quoting != Quoting::LegacyBash+ && chars.peek() == Some(&'\\')+ {+ chars.next();+ }+ let mut bytes = [0; 4];+ let bytes = character.encode_utf8(&mut bytes).as_bytes();+ decoded.push(if bytes[0] == b'?' { 127 } else { bytes[0] & 31 });+ decoded.extend_from_slice(&bytes[1..]);+ continue;+ }+ 'C' | 'M' if shell_type == ShellType::Zsh => {+ if chars.peek() == Some(&'-') {+ chars.next();+ }+ if escape == 'C' {+ modifiers.control = true;+ } else {+ modifiers.meta = Some(if modifiers.control {+ MetaOrder::BeforeControl+ } else {+ MetaOrder::AfterControl+ });+ }+ continue;+ }+ '0'..='7' | 'x' | 'u' | 'U' => {+ if matches!(escape, 'u' | 'U') && quoting == Quoting::LegacyBash {+ decoded.extend_from_slice(&[b'\\', escape as u8]);+ continue;+ }+ let (radix, digits) = match escape {+ 'x' => (16, 2),+ 'u' => (16, 4),+ 'U' => (16, 8),+ _ => (8, 2),+ };+ let mut value = escape.to_digit(8).unwrap_or(0);+ let mut found = escape.is_ascii_digit();+ for _ in 0..digits {+ let Some(digit) = chars.peek().and_then(|next| next.to_digit(radix)) else {+ break;+ };+ chars.next();+ value = value.checked_mul(radix)?.checked_add(digit)?;+ found = true;+ }+ if !found {+ if shell_type == ShellType::Zsh {+ return None;+ }+ decoded.extend_from_slice(&[b'\\', escape as u8]);+ continue;+ }+ if matches!(escape, 'u' | 'U') {+ let Some(character) = char::from_u32(value) else {+ if shell_type == ShellType::Zsh {+ return None;+ }+ // Bash emits extended UTF-8, including surrogate and 5/6-byte values.+ let length = match value {+ 0..=0xffff => 3,+ 0x10000..=0x1fffff => 4,+ 0x200000..=0x3ffffff => 5,+ 0x4000000..=0x7fffffff => 6,+ _ => continue,+ };+ let mut bytes = [0; 6];+ for index in (1..length).rev() {+ bytes[index] = 0x80 | (value & 0x3f) as u8;+ value >>= 6;+ }+ bytes[0] = (0xff << (8 - length)) | value as u8;+ decoded.extend_from_slice(&bytes[..length]);+ continue;+ };+ // Zsh leaves byte modifiers pending across Unicode escapes.+ let mut bytes = [0; 4];+ decoded.extend_from_slice(character.encode_utf8(&mut bytes).as_bytes());+ continue;+ }+ value as u8+ }+ _ => {+ if shell_type != ShellType::Zsh {+ decoded.push(b'\\');+ }+ let mut bytes = [0; 4];+ let bytes = escape.encode_utf8(&mut bytes).as_bytes();+ decoded.push(modifiers.apply(bytes[0]));+ decoded.extend_from_slice(&bytes[1..]);+ continue;+ }+ };+ decoded.push(modifiers.apply(byte));+ }+ Some(decoded)+}++enum MetaOrder {+ BeforeControl,+ AfterControl,+}++#[derive(Default)]+struct ZshByteModifiers {+ control: bool,+ meta: Option<MetaOrder>,+}++impl ZshByteModifiers {+ fn apply(&mut self, mut byte: u8) -> u8 {+ // Escape order matters for control-? and bytes whose high bit is already set.+ let meta = self.meta.take();+ if matches!(meta, Some(MetaOrder::BeforeControl)) {+ byte |= 0x80;+ }+ if std::mem::take(&mut self.control) {+ byte = if byte == b'?' { 0x7f } else { byte & 0x9f };+ }+ if matches!(meta, Some(MetaOrder::AfterControl)) {+ byte |= 0x80;+ }+ byte+ }+}diff --git a/codex-rs/shell-command/src/shell_snapshot_render.rs b/codex-rs/shell-command/src/shell_snapshot_render.rsindex 1881988bdf..ead034d38c 100644--- a/codex-rs/shell-command/src/shell_snapshot_render.rs+++ b/codex-rs/shell-command/src/shell_snapshot_render.rs@@ -32,8 +32,20 @@ pub(super) enum ValuePart {pub(super) enum Export<'a> {Captured(&'a str),- Alias { key: &'a str, value: Value },- Assignment { declaration: &'a str, value: Value },+ Assignment {+ declaration: &'a str,+ value: Value,+ },+ Array {+ prefix: &'a str,+ elements: Vec<Value>,+ suffix: &'a str,+ },+ ArrayBinding {+ key: &'a str,+ declaration: &'a str,+ suffix: &'a str,+ },}impl Value {@@ -64,12 +76,30 @@ pub(super) fn render(state: &str, aliases: &str, exports: &[Export<'_>]) -> Optifor export in exports {match export {Export::Captured(source) => output.push_str(source),- Export::Alias { key, value } => {- output.push_str(&format!("export {key}={}\n", value.render()?));- }Export::Assignment { declaration, value } => {output.push_str(&format!("{declaration}={}\n", value.render()?));}+ Export::Array {+ prefix,+ elements,+ suffix,+ } => {+ let elements = elements+ .iter()+ .map(Value::render)+ .collect::<Option<Vec<_>>>()?;+ output.push_str(&format!("{prefix}({}){suffix}", elements.join(" ")));+ }+ Export::ArrayBinding {+ key,+ declaration,+ suffix,+ } => {+ output.push_str(&format!(+ "if [ \"${{{key}+x}}\" = x ]; then\n{declaration}{}\nfi\n",+ suffix.trim_end()+ ));+ }}}Some(output)diff --git a/codex-rs/shell-command/src/shell_snapshot_tests.rs b/codex-rs/shell-command/src/shell_snapshot_tests.rsindex bd68bd34c5..c1d39964ba 100644--- a/codex-rs/shell-command/src/shell_snapshot_tests.rs+++ b/codex-rs/shell-command/src/shell_snapshot_tests.rs@@ -10,15 +10,38 @@ use anyhow::Context;use anyhow::Result;use pretty_assertions::assert_eq;use std::collections::HashMap;+use std::os::unix::process::CommandExt;use std::process::Command;use tempfile::tempdir;+fn empty_snapshot_credentials<'a>(+ empty: &'a HashMap<String, String>,+ is_allowed_unset: &'a dyn Fn(&str) -> bool,+) -> SnapshotCredentialEnvironment<'a> {+ SnapshotCredentialEnvironment {+ original: empty,+ restored: empty,+ configured: empty,+ discovered: empty,+ allowed: empty,+ is_allowed_unset,+ brokered_keys: &[],+ brokered_alias_keys: &[],+ allowed_brokered_keys: &[],+ }+}+const CAPTURE_ALL: SnapshotCaptureOptions = SnapshotCaptureOptions {startup: SnapshotStartup::Interactive,declarations: true,environment: true,};+const CAPTURE_NON_INTERACTIVE: SnapshotCaptureOptions = SnapshotCaptureOptions {+ startup: SnapshotStartup::NonInteractive,+ ..CAPTURE_ALL+};+fn snapshot_script(shell_type: ShellType) -> Option<String> {snapshot_capture_script(shell_type, CAPTURE_ALL)}@@ -493,6 +516,1308 @@ fn brokered_snapshots_filter_complete_multiline_exports() -> Result<()> {Ok(())}+#[test]+fn brokered_zsh_snapshot_preserves_tied_credential_aliases() -> Result<()> {+ if !std::path::Path::new("/bin/zsh").exists() {+ return Ok(());+ }+ let dir = tempdir()?;+ let real = "password$abcdefghijklmno";+ let dummy = "dummy-0123456789abcdef";+ let last = "ordinary'quote\nnext";+ let brokered_keys = vec!["VENDOR_PASSWORD".to_string()];+ for separator in [":", "|", "'", "\t", "$", "_", "x"] {+ let appended = format!("ordinary{separator}other");+ for rcquotes in [false, true] {+ let script = snapshot_capture_script(ShellType::Zsh, CAPTURE_NON_INTERACTIVE).unwrap();+ let setup = format!(+ "{}\nexport -UT SERVICE_URLS service_urls=( \"https://user:[email protected]/path\" '' {} ) {}\nservice_urls+=({})\n{script}",+ if rcquotes {+ "setopt rcquotes rcexpandparam"+ } else {+ ":"+ },+ shlex::try_quote(last)?,+ shlex::try_quote(separator)?,+ shlex::try_quote(&appended)?,+ );+ let original = HashMap::from([+ ("VENDOR_PASSWORD".to_string(), real.to_string()),+ (+ "SERVICE_URLS".to_string(),+ [+ format!("https://user:{real}@example.invalid/path"),+ String::new(),+ last.to_string(),+ appended.clone(),+ ]+ .join(separator),+ ),+ ]);+ let captured = Command::new("/bin/zsh")+ .args(["-fc", &setup])+ .env_clear()+ .env("VENDOR_PASSWORD", real)+ .env("PATH", "/usr/bin:/bin")+ .output()?;+ assert!(captured.status.success(), "{captured:?}");+ let mut snapshot = String::from_utf8(captured.stdout)?;+ let allowed = original+ .iter()+ .map(|(key, value)| (key.clone(), value.replace(real, dummy)))+ .collect::<HashMap<_, _>>();+ let rewritten = rewrite_snapshot_credentials(+ ShellType::Zsh,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &HashMap::new(),+ discovered: &allowed,+ allowed: &allowed,+ is_allowed_unset: &|_| true,+ brokered_keys: &brokered_keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: &brokered_keys,+ },+ |text| {+ *text = text.replace(real, dummy);+ true+ },+ )+ .expect("tied export can be brokered");+ assert_eq!(+ rewritten.aliases,+ HashMap::from([("SERVICE_URLS".to_string(), allowed["SERVICE_URLS"].clone())])+ );+ assert!(!snapshot.contains(real));+ let path = dir.path().join("snapshot.sh");+ std::fs::write(&path, &snapshot)?;+ for live in [dummy, real] {+ let replayed = Command::new("/bin/zsh")+ .args(["-fc", "set -e; . \"$1\"; printf '%s\\0' \"$SERVICE_URLS\" \"${service_urls[@]}\" \"$options[rcquotes]\"", "snapshot"])+ .arg(&path)+ .env_clear()+ .env("VENDOR_PASSWORD", live)+ .output()?;+ assert!(replayed.status.success(), "{replayed:?}");+ let scalar = original["SERVICE_URLS"].replace(real, live);+ let mut array = vec![+ format!("https://user:{live}@example.invalid/path"),+ String::new(),+ last.to_string(),+ ];+ array.push(appended.clone());+ assert_eq!(+ replayed.stdout,+ format!(+ "{scalar}\0{}\0{}\0",+ array.join("\0"),+ if rcquotes { "on" } else { "off" }+ )+ .into_bytes()+ );+ }+ }+ }+ for unique in [false, true] {+ for separator in [":", "|", "'", "\t"] {+ let flags = if unique { "-UT" } else { "-T" };+ let separator = shlex::try_quote(separator)?;+ let binding = format!("export {flags} SERVICE_URLS service_urls {separator}");+ let script = snapshot_capture_script(ShellType::Zsh, CAPTURE_NON_INTERACTIVE).unwrap();+ let captured = Command::new("/bin/zsh")+ .args([+ "-fc",+ &format!(+ "export {flags} SERVICE_URLS service_urls=( '' \"$VENDOR_PASSWORD\" '' plain plain '' ) {separator}\nunset VENDOR_PASSWORD\n{script}"+ ),+ ])+ .env_clear()+ .env("VENDOR_PASSWORD", real)+ .env("PATH", "/usr/bin:/bin")+ .output()?;+ assert!(captured.status.success(), "{captured:?}");+ let mut snapshot = String::from_utf8(captured.stdout)?;+ let original = CapturedSnapshot::parse(ShellType::Zsh, snapshot.as_bytes())+ .unwrap()+ .environment+ .split(|byte| *byte == 0)+ .filter_map(|entry| std::str::from_utf8(entry).ok()?.split_once('='))+ .map(|(key, value)| (key.to_string(), value.to_string()))+ .collect::<HashMap<_, _>>();+ assert!(!original.contains_key("VENDOR_PASSWORD"));+ let allowed = original+ .iter()+ .map(|(key, value)| (key.clone(), value.replace(real, dummy)))+ .collect::<HashMap<_, _>>();+ let alias_keys = vec!["SERVICE_URLS".to_string()];+ let rewritten = rewrite_snapshot_credentials(+ ShellType::Zsh,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &HashMap::new(),+ discovered: &allowed,+ allowed: &allowed,+ is_allowed_unset: &|_| true,+ brokered_keys: &[],+ brokered_alias_keys: &alias_keys,+ allowed_brokered_keys: &[],+ },+ |text| {+ *text = text.replace(real, dummy);+ true+ },+ )+ .expect("source-less tied alias can be brokered");+ assert_eq!(rewritten.aliases, HashMap::new());+ assert!(!snapshot.contains(real));+ assert!(!snapshot.contains(dummy));+ let path = dir.path().join("source-less-snapshot.sh");+ std::fs::write(&path, &snapshot)?;+ let inspect = "printf '%s\\0' \"${SERVICE_URLS-unset}\" \"${service_urls[@]}\" \"${(t)service_urls}\" \"${VENDOR_PASSWORD-unset}\"; if [ -n \"${SERVICE_URLS+x}\" ]; then SERVICE_URLS=$UPDATE; printf '%s\\0' \"$SERVICE_URLS\" \"${service_urls[@]}\"; unset SERVICE_URLS; fi; printf '%s:%s' \"${+SERVICE_URLS}\" \"${+service_urls}\"";+ for live in [Some(allowed["SERVICE_URLS"].as_str()), Some(""), None] {+ for source in [None, Some("different-live-source")] {+ let mut outputs = Vec::new();+ for script in [+ format!("set -e; . \"$1\"; {inspect}"),+ format!(+ "set -e; if [ -n \"${{SERVICE_URLS+x}}\" ]; then {binding}; fi; {inspect}"+ ),+ ] {+ let mut command = Command::new("/bin/zsh");+ command+ .args(["-fc", &script, "snapshot"])+ .arg(&path)+ .env_clear()+ .env(+ "UPDATE",+ allowed["SERVICE_URLS"].replace(dummy, "new-live-dummy"),+ );+ if let Some(live) = live {+ command.env("SERVICE_URLS", live);+ }+ if let Some(source) = source {+ command.env("VENDOR_PASSWORD", source);+ }+ let output = command.output()?;+ assert!(output.status.success(), "{script}: {output:?}");+ outputs.push(String::from_utf8(output.stdout)?);+ }+ assert_eq!(outputs[0], outputs[1], "{binding}, {live:?}, {source:?}");+ }+ }+ }+ }+ Ok(())+}++#[test]+fn brokered_snapshot_rejects_credentials_crossing_array_elements() {+ let real = "password$abcdefghijklmno";+ let dummy = "dummy-0123456789abcdef";+ let keys = vec!["VENDOR_PASSWORD".to_string()];+ let restored = HashMap::from([(keys[0].clone(), real.to_string())]);+ for (captured_value, allowed_value) in [(real, dummy), (real, real), (dummy, dummy)] {+ let original = HashMap::from([+ (keys[0].clone(), captured_value.to_string()),+ ("AUTH_HEADER".to_string(), captured_value.to_string()),+ ]);+ let allowed = HashMap::from([+ (keys[0].clone(), allowed_value.to_string()),+ ("AUTH_HEADER".to_string(), allowed_value.to_string()),+ ]);+ let (first, last) = captured_value.split_at(/*mid*/ 10);+ let data = format!(+ "# Snapshot file\n\0\0AUTH_HEADER\0typeset -xT AUTH_HEADER header=( '{first}' '{last}' ) ''\n\0\0"+ );+ let capture = CapturedSnapshot::parse(ShellType::Zsh, data.as_bytes()).unwrap();+ let prepared = prepare_snapshot_credentials(+ &capture,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &restored,+ configured: &HashMap::new(),+ discovered: &allowed,+ allowed: &allowed,+ is_allowed_unset: &|_| true,+ brokered_keys: &keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: &keys,+ },+ |text| {+ *text = text.replace(real, allowed_value);+ true+ },+ );+ assert!(prepared.is_none(), "{captured_value}, {allowed_value}");+ }+}++#[test]+fn zsh_literal_bytes_match_native_modifiers() -> Result<()> {+ if !std::path::Path::new("/bin/zsh").exists() {+ return Ok(());+ }+ for word in [+ r"$'\M-C\M-)'",+ r"$'\xC3'$'\M-)'",+ r"$'\M-\C-?'",+ r"$'\C-\M-?'",+ r"$'\C-\xC3'",+ r"$'\M\x41'",+ r"$'\M-\u0041X'",+ r"$'\M-\q'",+ ] {+ let script = format!("printf '%s' {word}");+ let native = Command::new("/bin/zsh")+ .args(["-fc", &script])+ .env_clear()+ .output()?;+ assert!(native.status.success(), "{word}: {native:?}");+ let tree = crate::bash::try_parse_shell(&script).unwrap();+ let node = tree.root_node().named_child(0).unwrap();+ let mut cursor = node.walk();+ let argument = node+ .children_by_field_name("argument", &mut cursor)+ .last()+ .unwrap();+ let decoded = super::literals::literal_word_bytes(+ argument,+ &script,+ ShellType::Zsh,+ super::literals::Quoting::Posix,+ )+ .unwrap();+ assert_eq!(decoded, native.stdout, "{word}");+ }+ Ok(())+}++#[test]+fn brokered_snapshots_check_complete_alias_literals() -> Result<()> {+ let real = "token_ab'cdefghijklmnopqrstuvwx";+ let original = HashMap::from([("VENDOR_PASSWORD".to_string(), real.to_string())]);+ let allowed = HashMap::from([(+ "VENDOR_PASSWORD".to_string(),+ "token_dummy_abcdefghijklmnopqr".to_string(),+ )]);+ let brokered_keys = vec!["VENDOR_PASSWORD".to_string()];+ let controls = (1u8..=31)+ .map(char::from)+ .chain(['\u{7f}', '\u{e9}'])+ .collect::<String>();+ for (shell, aliases) in [("/bin/bash", "alias -p"), ("/bin/zsh", "alias -L")] {+ let shell_type = crate::shell_detect::detect_shell_type(shell).unwrap();+ if !std::path::Path::new(shell).exists() {+ continue;+ }+ for (value, accepted) in [+ (format!("printf '%s' \"{real}\""), false),+ (format!("printf '%s' \"{real}\"\n:"), false),+ (+ "printf %s token_ab\\'cdefghijklmnopqrstuvwx\n:".to_string(),+ false,+ ),+ (+ "printf %s 'token_ab'\\''cdefghijklmnopqrstuvwx'\n:".to_string(),+ false,+ ),+ (+ "printf '%s' \"ordinary'quoted\"\n# tab\tbell\u{7}escape\u{1b}backslash\\\n:"+ .to_string(),+ true,+ ),+ (format!("printf '%s' \"{controls}\""), true),+ ] {+ let output = Command::new(shell)+ .args(["-c", &format!("alias helper=\"$ALIAS_VALUE\"; {aliases}")])+ .env_clear()+ .env("ALIAS_VALUE", &value)+ .output()?;+ assert!(output.status.success(), "{shell}: {output:?}");+ let mut snapshot = format!(+ "# aliases\n{}\n# exports 0\n",+ String::from_utf8(output.stdout)?+ );+ let before = snapshot.clone();+ let rewritten = rewrite_snapshot_credentials(+ shell_type,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &HashMap::new(),+ discovered: &allowed,+ allowed: &allowed,+ is_allowed_unset: &|_| false,+ brokered_keys: &brokered_keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: &brokered_keys,+ },+ |text| {+ *text = text.replace(real, &allowed["VENDOR_PASSWORD"]);+ true+ },+ );+ assert_eq!(rewritten.is_some(), accepted, "{shell}: {before}");+ if accepted {+ assert_eq!(snapshot, before);+ let expected = if shell_type == ShellType::Zsh {+ let replay = Command::new(shell)+ .args(["-fc", &format!("{snapshot}\nprint -rn -- $aliases[helper]")])+ .env_clear()+ .output()?;+ assert!(replay.status.success(), "{replay:?}");+ String::from_utf8(replay.stdout)?+ } else {+ value.clone()+ };+ assert!(+ super::literals::literal_words(&snapshot, shell_type)+ .unwrap()+ .contains(&format!("helper={expected}")),+ "{shell}: {value:?}; {snapshot}"+ );+ }+ }+ }+ Ok(())+}++#[test]+fn brokered_snapshots_check_prefixed_alias_declarations() -> Result<()> {+ let empty = HashMap::new();+ let real = "token_ab'cd\"efghijklmnopqrstuvwx";+ let body = format!("printf '%s' {}", shlex::try_quote(real)?);+ for (shell, shell_type, setup) in [+ ("/bin/bash", ShellType::Bash, "shopt -s expand_aliases"),+ ("/bin/zsh", ShellType::Zsh, "setopt posixbuiltins"),+ ] {+ if !std::path::Path::new(shell).exists() {+ continue;+ }+ for (prefix, creates_alias, name) in [+ ("alias", true),+ ("builtin alias", true),+ ("builtin builtin alias", true),+ ("time builtin alias", true),+ ("command alias", true),+ ("command -p -- alias", true),+ ("command -pp alias", true),+ ("command builtin alias", true),+ ("builtin command -p alias", true),+ ("command -v alias", false),+ ("command -pV alias", false),+ ]+ .into_iter()+ .chain((shell_type == ShellType::Bash).then_some(("builtin -- alias", true)))+ .chain((shell_type == ShellType::Bash).then_some(("time -p builtin alias", true)))+ .chain(+ (shell_type == ShellType::Zsh)+ .then_some([+ ("noglob builtin alias", true),+ ("builtin - alias", true),+ ("- builtin alias", true),+ ])+ .into_iter()+ .flatten(),+ )+ .flat_map(|(prefix, creates_alias)| {+ ["captured", "\"$name\""].map(|name| (prefix, creates_alias, name))+ }) {+ let capture = format!(+ "helper() {{ local name=captured; {prefix} {name}={}; }}\ntypeset -f helper",+ shlex::try_quote(&body)?+ );+ let output = Command::new(shell)+ .args(["-fc", &capture])+ .env_clear()+ .output()?;+ assert!(output.status.success(), "{shell}: {output:?}");+ let original = String::from_utf8(output.stdout)?;+ assert!(!original.contains(real), "{shell}: {original}");+ for contains_credential in [false, true] {+ let mut snapshot = original.clone();+ let result = rewrite_snapshot_credentials(+ shell_type,+ &mut snapshot,+ empty_snapshot_credentials(&empty, &|_| false),+ |text| {+ if contains_credential {+ *text = text.replace(real, "dummy");+ }+ true+ },+ );+ assert_eq!(+ result.is_some(),+ !contains_credential || !creates_alias,+ "{shell}, {prefix}: {snapshot}"+ );+ assert_eq!(snapshot, original);+ if !contains_credential && creates_alias {+ let replay = Command::new(shell)+ .args([+ "-fc",+ &format!("{setup}\n{snapshot}\nhelper\neval captured"),+ ])+ .env_clear()+ .output()?;+ assert!(replay.status.success(), "{shell}, {prefix}: {replay:?}");+ assert_eq!(String::from_utf8(replay.stdout)?, real);+ }+ }+ }+ }+ Ok(())+}++#[test]+fn brokered_snapshots_check_array_initializers_and_binary_literals() {+ let empty = HashMap::new();+ let real = "password$abcdefghijklmno";+ for (shell_type, original, has_credential) in [+ (+ ShellType::Bash,+ r#"declare -ax API_HEADERS='([0]="Bearer password\$abcdefghijklmno")'"#,+ ),+ (+ ShellType::Bash,+ r#"builtin declare -ax API_HEADERS='([0]="Bearer password\$abcdefghijklmno")'"#,+ ),+ (+ ShellType::Bash,+ r#"command -p typeset -ax API_HEADERS='([0]="Bearer password\$abcdefghijklmno")'"#,+ ),+ (+ ShellType::Bash,+ r#"declare -Ax API_HEADERS=([auth]="Bearer password\$abcdefghijklmno")"#,+ ),+ (+ ShellType::Bash,+ r#"helper() { local -a headers; local headers='([0]="Bearer password\$abcdefghijklmno")'; }"#,+ ),+ (+ ShellType::Bash,+ r#"declare -a headers; builtin declare headers='([0]="Bearer password\$abcdefghijklmno")'"#,+ ),+ (+ ShellType::Bash,+ r#"declare -a headers; command -p typeset headers='([0]="Bearer password\$abcdefghijklmno")'"#,+ ),+ (+ ShellType::Bash,+ r#"declare SCALAR_TEMPLATE='([0]="Bearer password\$abcdefghijklmno")'"#,+ ),+ (+ ShellType::Bash,+ r#"helper() { local name=headers; local -a headers; local "${name}"='([0]="Bearer password\$abcdefghijklmno")'; }"#,+ ),+ (+ ShellType::Bash,+ r#"helper() { local -a headers; local headers='([0]="Bearer password\$abcdefghijklmno" [1]="'"$OTHER"'")'; }"#,+ ),+ (+ ShellType::Bash,+ r#"helper() { local -a headers; local headers=$PREFIX'([0]="Bearer password\$abcdefghijklmno")'$SUFFIX; }"#,+ ),+ (+ ShellType::Zsh,+ r#"helper() { printf '%s' $'\x89password\x24abcdefghijklmno\xff'; }"#,+ ),+ ]+ .into_iter()+ .map(|(shell_type, original)| (shell_type, original, true))+ .chain(+ [+ r#"local TEMPLATE="(\$'\\xZZ')""#,+ r#"local TEMPLATE="(\$'\\uD800')""#,+ r#"local TEMPLATE="(\$'\\UFFFFFFFF')""#,+ r#"local TEMPLATE="(\$'\\c')""#,+ r#"local TEMPLATE="(\$'\\')""#,+ "local TEMPLATE=\"(\\$'\\\\c\u{e9}')\"",+ r#"local TEMPLATE="(\$'incomplete)""#,+ r#"local -a headers; local headers='([0]="Bearer '$CREDENTIAL'")'"#,+ ]+ .map(|original| (ShellType::Bash, original, false)),+ ) {+ for contains_credential in [false, true] {+ let mut snapshot = original.to_string();+ let result = rewrite_snapshot_credentials(+ shell_type,+ &mut snapshot,+ empty_snapshot_credentials(&empty, &|_| true),+ |text| {+ if contains_credential {+ *text = text.replace(real, "dummy");+ }+ true+ },+ );+ assert_eq!(+ result.is_some(),+ !contains_credential || !has_credential,+ "{original}"+ );+ assert_eq!(snapshot, original);+ }+ }+}++#[test]+fn brokered_sh_snapshots_inspect_the_captured_shell_dialect() -> Result<()> {+ let empty = HashMap::new();+ let real = "password$abcdefghijklmno";+ let script = snapshot_capture_script(ShellType::Sh, CAPTURE_NON_INTERACTIVE).unwrap();+ for (shell, bash_backed) in [("/bin/bash", true), ("/bin/dash", false)] {+ if !std::path::Path::new(shell).exists() {+ continue;+ }+ for (setup, contains_credential) in [+ (+ r#"helper() { local -a headers; local headers='([0]="Bearer password\$abcdefghijklmno")'; }"#,+ true,+ ),+ (+ r#"helper() { time -p builtin alias captured='printf "%s" "password\$abcdefghijklmno"'; }"#,+ true,+ ),+ (+ r#"helper() { local name=captured; alias "$name"='printf "%s" "password\$abcdefghijklmno"'; }"#,+ true,+ ),+ (+ r#"export TEMPLATE='([0]="Bearer password\$abcdefghijklmno")'"#,+ true,+ ),+ (r#"export TEMPLATE="(\$'incomplete)""#, false),+ (+ r#"helper() { local -a headers; local headers='([0]="ordinary\$value")'; }; export TEMPLATE=ordinary"#,+ false,+ ),+ ] {+ let capture = Command::new(shell)+ .arg0("sh")+ .args(["-c", &format!("{setup}\n{script}")])+ .env_clear()+ .env("PATH", "/usr/bin:/bin")+ .output()?;+ assert!(capture.status.success(), "{shell}: {capture:?}");+ let original = String::from_utf8(capture.stdout)?;+ assert_eq!(+ original.starts_with(super::BASH_SH_SNAPSHOT_HEADER),+ bash_backed+ );+ let mut snapshot = original.clone();+ let result = rewrite_snapshot_credentials(+ ShellType::Sh,+ &mut snapshot,+ empty_snapshot_credentials(&empty, &|_| true),+ |text| {+ *text = text.replace(real, "dummy");+ true+ },+ );+ assert_eq!(+ result.is_some(),+ !bash_backed || !contains_credential,+ "{shell}: {setup}"+ );+ assert_eq!(+ snapshot,+ if result.is_some() {+ captured_script(ShellType::Sh, &original)?+ } else {+ original+ }+ );+ if result.is_some() {+ let replay = Command::new(shell)+ .arg0("sh")+ .args(["-c", &format!("{snapshot}\nprintf '%s' \"${{TEMPLATE-}}\"")])+ .env_clear()+ .output()?;+ let control = Command::new(shell)+ .arg0("sh")+ .args(["-c", &format!("{setup}\nprintf '%s' \"${{TEMPLATE-}}\"")])+ .env_clear()+ .output()?;+ assert!(replay.status.success(), "{shell}: {replay:?}");+ assert!(control.status.success(), "{shell}: {control:?}");+ assert_eq!(replay.stdout, control.stdout);+ }+ }+ }+ Ok(())+}++#[test]+fn brokered_snapshots_check_native_quoting() -> Result<()> {+ let empty = HashMap::new();+ for (shell, shell_type, aliases) in [+ ("/bin/bash", ShellType::Bash, "alias -p"),+ ("/bin/zsh", ShellType::Zsh, "alias -L"),+ ] {+ if !std::path::Path::new(shell).exists() {+ continue;+ }+ let mut expressions = vec![+ r#""`printf '%s' 'password\$abcdefghijklmno'`""#,+ r#"`printf '%s' 'password\$abcdefghijklmno'`"#,+ r#""`printf '%s' \`printf '%s' 'password\\\$abcdefghijklmno'\``""#,+ r#""${EMPTY-`printf '%s' 'password\"abcdefghijklmno'`}""#,+ r#"$"token_ab'cdefghijklmnopqrstuvwx""#,+ r#"prefix$"token_ab'cdefghijklmnopqrstuvwx""#,+ r#"$"token_ab'cdefghijklmnopqrstuvwx""${EMPTY-}""#,+ r#"$'token_\c\\abcdefghijklmnopqrstuvwx'"#,+ r#""$(printf '%s' $'token_\c\\abcdefghijklmnopqrstuvwx')""#,+ r#"$'token_\C-Aabcdefghijklmnopqrstuvwx'"#,+ r#"$'token_\C-\x41abcdefghijklmnopqrstuvwx'"#,+ r#"$'token_\C-\101abcdefghijklmnopqrstuvwx'"#,+ r#"$'token_\C-\u0041abcdefghijklmnopqrstuvwx'"#,+ r#"$'token_\C\101abcdefghijklmnopqrstuvwx'"#,+ ];+ let mut array_expressions = Vec::new();+ if shell_type == ShellType::Bash {+ expressions.extend([+ r#""$(array_value() { local -a headers; local headers='([0]="password\$abcdefghijklmno")'; printf '%s' "${headers[0]}"; }; array_value)""#,+ r#""$(declare -a headers; builtin declare headers='([0]="password\$abcdefghijklmno")'; printf '%s' "${headers[0]}")""#,+ r#""$(declare -a headers; command -p typeset headers='([0]="password\$abcdefghijklmno")'; printf '%s' "${headers[0]}")""#,+ r#""$(array_value() { local name=headers; local -a headers; local "${name}"='([0]="password\$abcdefghijklmno")'; printf '%s' "${headers[0]}"; }; array_value)""#,+ r#""$(array_value() { local -a headers; local headers='([0]="password\$abcdefghijklmno" [1]="'"$OTHER"'")'; printf '%s' "${headers[0]}"; }; array_value)""#,+ r#""$(array_value() { local -a headers; local headers=$PREFIX'([0]="password\$abcdefghijklmno")'$SUFFIX; printf '%s' "${headers[0]}"; }; array_value)""#,+ ]);+ for escape in [r"\xZZ", r"\uD800", r"\UFFFFFFFF", r"\c"] {+ let initializer = format!(r#"([0]=$'{escape}' [1]="password\$abcdefghijklmno")"#);+ let initializer = shlex::try_quote(&initializer)?;+ array_expressions.push(format!(+ "\"$(declare -a headers; declare headers={initializer}; printf '%s' \"${{headers[1]}}\")\""+ ));+ }+ } else if shell_type == ShellType::Zsh {+ expressions.extend([+ "password_a$'\\xc3'$'\\xa9'bcdefghijklmno\"${EMPTY-}\"",+ "password_a$'\\M-C'$'\\M-)'bcdefghijklmno\"${EMPTY-}\"",+ "password_a$'\\xc3'\\\n$'\\xa9'bcdefghijklmno\"${EMPTY-}\"",+ "password\\\n\\$abcdefghijklmno",+ "pass\\\nword\\\n\\\n\\$abcdefghijklmno",+ "'password'\\\n'$abcdefghijklmno'",+ "\"password\"\\\n'$abcdefghijklmno'",+ "$'pass'\"word\"\\\n'$abcdefghijklmno'",+ ]);+ }+ for expression in expressions+ .into_iter()+ .map(str::to_string)+ .chain(array_expressions)+ {+ let body = format!("printf '%s' {expression}");+ let native = Command::new(shell)+ .args(["-fc", &body])+ .env_clear()+ .output()?;+ assert!(native.status.success(), "{shell}, {expression}: {native:?}");+ let real = String::from_utf8(native.stdout)?;+ assert!(real.len() >= 16, "{shell}, {expression}: {real:?}");+ let mut captures = vec![+ format!("helper() {{ {body}; }}\ntypeset -f helper"),+ format!("alias helper=\"$ALIAS_VALUE\"\n{aliases}"),+ ];+ if shell_type == ShellType::Zsh {+ captures.push(format!("alias -g helper=\"$ALIAS_VALUE\"\n{aliases}"));+ let script = snapshot_capture_script(shell_type, CAPTURE_NON_INTERACTIVE)+ .expect("zsh supports snapshots");+ captures.push(format!(+ "quoted() {{ cat <<'EOF'\n\" ${{(@f)EMPTY:-password\\$abcdefghijklmno}}\nEOF\n}}\nhelper() {{ {body}; }}\n{script}"+ ));+ }+ for capture in captures {+ let output = Command::new(shell)+ .args(["-fc", &capture])+ .env_clear()+ .env("ALIAS_VALUE", &body)+ .output()?;+ assert!(output.status.success(), "{shell}: {output:?}");+ let captured = String::from_utf8(output.stdout)?;+ let original = if captured.contains('\0') {+ let capture = CapturedSnapshot::parse(shell_type, captured.as_bytes()).unwrap();+ format!("{}{}", capture.state, capture.aliases)+ } else {+ captured+ };+ for contains_credential in [false, true] {+ let mut snapshot = original.clone();+ let result = rewrite_snapshot_credentials(+ shell_type,+ &mut snapshot,+ empty_snapshot_credentials(&empty, &|_| false),+ |text| {+ if contains_credential {+ *text = text.replace(&real, "dummy");+ }+ true+ },+ );+ assert_eq!(+ result.is_some(),+ !contains_credential,+ "{shell}, {expression}: {snapshot}"+ );+ assert_eq!(snapshot, original);+ if !contains_credential {+ let setup = if shell_type == ShellType::Bash {+ "shopt -s expand_aliases\n"+ } else {+ ""+ };+ let replay = Command::new(shell)+ .args(["-fc", &format!("{setup}{snapshot}\neval helper")])+ .env_clear()+ .output()?;+ assert!(+ replay.status.success(),+ "{shell}, {expression}: {snapshot}\n{replay:?}"+ );+ assert_eq!(String::from_utf8(replay.stdout)?, real);+ }+ }+ }+ }+ }+ Ok(())+}++#[test]+fn zsh_snapshot_checks_functions_before_restoring_quote_options() -> Result<()> {+ if !std::path::Path::new("/bin/zsh").exists() {+ return Ok(());+ }+ let dir = tempdir()?;+ let real = "ghp_abcdefghijklmnopqrstuvwxyz0123456789";+ let original = HashMap::from([("GH_TOKEN".to_string(), real.to_string())]);+ let allowed = HashMap::from([("GH_TOKEN".to_string(), "dummy-github-token".to_string())]);+ let keys = vec!["GH_TOKEN".to_string()];+ let script = snapshot_capture_script(ShellType::Zsh, CAPTURE_NON_INTERACTIVE)+ .expect("zsh supports snapshots");+ for option in ["setopt rcquotes", "unsetopt rcquotes"] {+ for (value, accepted) in [(real, false), ("ordinaryvalue", true)] {+ let (first, second) = value.split_at(value.len() / 2);+ let startup = dir.path().join("startup.sh");+ std::fs::write(+ &startup,+ format!("helper() {{ printf '%s' '{first}''{second}'; }}\n{option}\n"),+ )?;+ let output = Command::new("/bin/zsh")+ .args(["-fc", &format!(". \"$1\"\n{script}"), "snapshot"])+ .arg(startup)+ .env_clear()+ .envs(&original)+ .env("HOME", dir.path())+ .output()?;+ assert!(output.status.success(), "{output:?}");+ let mut snapshot = String::from_utf8(output.stdout)?;+ let rewritten = rewrite_snapshot_credentials(+ ShellType::Zsh,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &HashMap::new(),+ discovered: &allowed,+ allowed: &allowed,+ is_allowed_unset: &|_| false,+ brokered_keys: &keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: &keys,+ },+ |text| {+ *text = text.replace(real, &allowed["GH_TOKEN"]);+ true+ },+ );+ assert_eq!(rewritten.is_some(), accepted, "{option}: {snapshot}");+ if accepted {+ let path = dir.path().join("snapshot.sh");+ std::fs::write(&path, &snapshot)?;+ let replay = Command::new("/bin/zsh")+ .args(["-fc", ". \"$1\"; helper", "snapshot"])+ .arg(path)+ .env_clear()+ .envs(&allowed)+ .output()?;+ assert!(replay.status.success(), "{replay:?}");+ assert_eq!(String::from_utf8(replay.stdout)?, value);+ }+ }+ }+ Ok(())+}++#[test]+fn zsh_snapshot_checks_deferred_quote_modes() -> Result<()> {+ if !std::path::Path::new("/bin/zsh").exists() {+ return Ok(());+ }+ let dir = tempdir()?;+ let script = snapshot_capture_script(ShellType::Zsh, CAPTURE_NON_INTERACTIVE)+ .expect("zsh supports snapshots");+ for (real, startup) in [+ (+ "token_ab'cdefghijklmnopqrstuvwx",+ "helper() { printf '%s' \"$(printf '%s' 'token_ab''cdefghijklmnopqrstuvwx')\"; }\nsetopt rcquotes\n",+ ),+ (+ "ghp_abcdefghijklmnopqrstuvwxyz0123456789",+ "alias helper=\"setopt rcquotes; printf '%s' 'ghp_abcdefghijklmno''pqrstuvwxyz0123456789'\"\n",+ ),+ (+ "ghp_abcdefghijklmnopqrstuvwxyz0123456789",+ "alias helper=\"printf '%s' 'ghp_abcdefghijkl'\\\\\n'mnopqrstuvwxyz0123456789'\"\nsetopt rcquotes\n",+ ),+ ] {+ let startup_path = dir.path().join("startup.sh");+ std::fs::write(&startup_path, startup)?;+ let output = Command::new("/bin/zsh")+ .args(["-fc", &format!(". \"$1\"\n{script}"), "snapshot"])+ .arg(startup_path)+ .env_clear()+ .env("HOME", dir.path())+ .output()?;+ assert!(output.status.success(), "{output:?}");+ let snapshot = captured_script(ShellType::Zsh, &String::from_utf8(output.stdout)?)?;+ let path = dir.path().join("snapshot.sh");+ std::fs::write(&path, &snapshot)?;+ let replay = Command::new("/bin/zsh")+ .args(["-fc", ". \"$1\"; eval helper", "snapshot"])+ .arg(path)+ .env_clear()+ .output()?;+ assert!(replay.status.success(), "{replay:?}");+ assert_eq!(String::from_utf8(replay.stdout)?, real);+ assert!(+ super::literals::literal_words(&snapshot, ShellType::Zsh)+ .expect("valid snapshot")+ .contains(&real.to_string()),+ "runtime literal was not checked: {snapshot}"+ );+ }+ Ok(())+}++#[test]+fn zsh_snapshot_checks_rcquotes_without_changing_alias_behavior() -> Result<()> {+ if !std::path::Path::new("/bin/zsh").exists() {+ return Ok(());+ }+ let dir = tempdir()?;+ let real = "token_ab'cdefghijklmnopqrstuvwx";+ let original = HashMap::from([("VENDOR_PASSWORD".to_string(), real.to_string())]);+ let allowed = HashMap::from([(+ "VENDOR_PASSWORD".to_string(),+ "token_dummy_abcdefghijklmnopqr".to_string(),+ )]);+ let brokered_keys = vec!["VENDOR_PASSWORD".to_string()];+ let script = snapshot_capture_script(ShellType::Zsh, CAPTURE_NON_INTERACTIVE)+ .expect("zsh supports snapshots");+ for (option, option_value) in [("setopt rcquotes", "on"), ("unsetopt rcquotes", "off")] {+ for (value, accepted) in [(real, false), ("ordinary'quoted", true)] {+ for alias in [+ r#"alias helper="printf '%s' \"$ALIAS_VALUE\"""#,+ r#"alias helper="printf '%s' ${(qq)ALIAS_VALUE}""#,+ r#"alias helper="printf '%s' ${(qq)ALIAS_VALUE}\"\${EMPTY-}\"""#,+ ] {+ let output = Command::new("/bin/zsh")+ .args([+ "-fc",+ &format!("{option}\n{alias}\nunset ALIAS_VALUE\n{script}"),+ ])+ .env_clear()+ .envs(&original)+ .env("HOME", dir.path())+ .env("ALIAS_VALUE", value)+ .output()?;+ assert!(output.status.success(), "{output:?}");+ let mut snapshot = String::from_utf8(output.stdout)?;+ let rewritten = rewrite_snapshot_credentials(+ ShellType::Zsh,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &HashMap::new(),+ discovered: &allowed,+ allowed: &allowed,+ is_allowed_unset: &|_| false,+ brokered_keys: &brokered_keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: &brokered_keys,+ },+ |text| {+ *text = text.replace(real, &allowed["VENDOR_PASSWORD"]);+ true+ },+ );+ assert_eq!(+ rewritten.is_some(),+ accepted,+ "{option}, {alias}: {snapshot}"+ );+ if accepted {+ let path = dir.path().join("snapshot.sh");+ std::fs::write(&path, &snapshot)?;+ let replay = Command::new("/bin/zsh")+ .args([+ "-fc",+ ". \"$1\"; eval helper; printf '\\n%s\\n' $options[rcquotes]",+ "snapshot",+ ])+ .arg(path)+ .env_clear()+ .envs(&allowed)+ .output()?;+ assert!(replay.status.success(), "{replay:?}");+ assert_eq!(+ String::from_utf8(replay.stdout)?,+ format!("{value}\n{option_value}\n")+ );+ }+ }+ }+ }+ Ok(())+}++#[test]+fn brokered_snapshots_check_static_fragments_next_to_expansions() -> Result<()> {+ let real = "password$abcdefghijklmno";+ let dir = tempdir()?;+ let invocation = dir.path().join("invoke.sh");+ std::fs::write(&invocation, "helper\n")?;+ let inner_invocation = dir.path().join("inner-invoke.sh");+ std::fs::write(&inner_invocation, "inner\n")?;+ for (shell, aliases) in [("/bin/bash", "alias -p"), ("/bin/zsh", "alias -L")] {+ if !std::path::Path::new(shell).exists() {+ continue;+ }+ for (body, accepted) in [+ (r#"printf '%s' "${USER}:password\$abcdefghijklmno""#, false),+ (r#"printf '%s' "${USER}:pass"'word$abcdefghijklmno'"#, false),+ (r#"printf '%s' "password\$abcdefghijklmno:${USER}""#, false),+ (+ r#"printf '%s' "${USER}:"$'password\x24abcdefghijklmno'"#,+ false,+ ),+ (r#"printf '%s' "${USER}:$VENDOR_PASSWORD""#, true),+ (r#"printf '%s' "${USER}:ordinary\$value""#, true),+ (+ "cat <<EOF\nAuthorization: password\\$abcdefghijklmno\nEOF\n",+ false,+ ),+ (+ "cat <<EOF\nAuthorization: pass\\\nword\\$abcdefghijklmno\nEOF\n",+ false,+ ),+ (+ "cat <<EOF\n${USER}:password\\$abcdefghijklmno\nEOF\n",+ false,+ ),+ ("cat <<-EOF\n\tpassword\\$abcdefghijklmno\n\tEOF\n", false),+ ("cat <<'EOF'\npassword\\$abcdefghijklmno\nEOF\n", true),+ ("cat <<EOF\n${USER}:$VENDOR_PASSWORD\nEOF\n", true),+ ("cat <<EOF\nordinary\\$value\nEOF\n", true),+ ]+ .into_iter()+ .chain(+ (shell == "/bin/zsh")+ .then_some([+ (+ "export GH_COPY=password\\\n\\$abcdefghijklmno; printf '%s' \"$GH_COPY\"",+ false,+ ),+ (+ "GH_COPY=password\\\n\\$abcdefghijklmno; printf '%s' \"$GH_COPY\"",+ false,+ ),+ (+ "password=''\\\n'$abcdefghijklmno'; printf '%s' \"$password\"",+ true,+ ),+ (+ "ali\\\nas inner='printf \"%s\" \"password\\$abcdefghijklmno\"'",+ false,+ ),+ (+ "builtin ali\\\nas inner='printf \"%s\" \"password\\$abcdefghijklmno\"'",+ false,+ ),+ (+ "alias inner='printf \"%s\" \"password'\\\n'\\$abcdefghijklmno\"'",+ false,+ ),+ (+ "alias inner='printf \"%s\" \"password'\\\n'\\$abcdefghijklmno\"'\"${EMPTY}\"",+ false,+ ),+ (+ "alias inner=\"${EMPTY}\"'printf \"%s\" \"password'\\\n'\\$abcdefghijklmno\"'",+ false,+ ),+ (+ "alias inner='printf \"%s\" \"password'\"${EMPTY}\"\\\n'\\$abcdefghijklmno\"'",+ true,+ ),+ (+ "alias inner='printf \"%s\" \"ordinary'\\\n'value\"'\"${EMPTY}\"",+ true,+ ),+ (+ "printf '%s' '${USER}:pass'\\\n'word$abcdefghijklmno'",+ false,+ ),+ (+ "printf '%s' \"${USER}:pass\"\\\n'word$abcdefghijklmno'",+ false,+ ),+ (+ "printf '%s' 'password'\\\n\"${USER}\\$abcdefghijklmno\"",+ true,+ ),+ ("printf '%s' 'password\n$abcdefghijklmno'", true),+ ("printf '%s' 'password\\\n$abcdefghijklmno'", true),+ ("printf '%s' \"password\n\\$abcdefghijklmno\"", true),+ ("printf '%s' password\\\\\\\n\\$abcdefghijklmno", true),+ ("printf '%s ' password \\\n\\$abcdefghijklmno", true),+ ("printf '%s ' password\\\n \\$abcdefghijklmno", true),+ ])+ .into_iter()+ .flatten(),+ ) {+ for script in [+ format!("helper() {{\n{body}\n}}; typeset -f helper"),+ format!("alias helper=\"$ALIAS_VALUE\"; {aliases}"),+ ] {+ let output = Command::new(shell)+ .args(["-c", &script])+ .env_clear()+ .env("ALIAS_VALUE", body)+ .output()?;+ assert!(output.status.success(), "{shell}: {output:?}");+ let mut snapshot = String::from_utf8(output.stdout)?;+ let original = snapshot.clone();+ let result = rewrite_snapshot_credentials(+ crate::shell_detect::detect_shell_type(shell).unwrap(),+ &mut snapshot,+ empty_snapshot_credentials(&HashMap::new(), &|_| false),+ |text| {+ *text = text.replace(real, "dummy");+ true+ },+ );+ assert_eq!(result.is_some(), accepted, "{shell}: {original}");+ assert_eq!(snapshot, original);+ let invokes_inner = body.contains("inner=");+ if shell == "/bin/zsh" && (accepted || invokes_inner) {+ let path = dir.path().join("snapshot.sh");+ std::fs::write(&path, &snapshot)?;+ // Source each invocation after its alias has been defined, without eval.+ let replay_command = if invokes_inner {+ ". \"$1\"; . \"$2\"; . \"$3\""+ } else {+ ". \"$1\"; . \"$2\""+ };+ let replay = Command::new(shell)+ .args(["-c", replay_command, "snapshot"])+ .args([&path, &invocation, &inner_invocation])+ .env_clear()+ .output()?;+ let native_command = if invokes_inner {+ format!("{body}\n. \"$1\"")+ } else {+ body.to_string()+ };+ let native = Command::new(shell)+ .args(["-c", &native_command, "native"])+ .arg(&inner_invocation)+ .env_clear()+ .output()?;+ assert!(replay.status.success(), "{shell}: {replay:?}");+ assert!(native.status.success(), "{shell}: {native:?}");+ assert_eq!(replay.stdout, native.stdout, "{shell}: {body}");+ if !accepted && invokes_inner {+ assert_eq!(native.stdout, real.as_bytes(), "{body}");+ }+ }+ }+ }+ }+ Ok(())+}++#[test]+fn brokered_bash_snapshot_does_not_rewrite_function_syntax() -> Result<()> {+ let dir = tempdir()?;+ let startup = dir.path().join("startup.sh");+ let real = "ghp_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGH";+ let dummy = "ghp_brokered_dummy_abcdefghijklmnopqrstuvwxyz0123";+ let credential_shaped_function = "ghp_0123456789abcdefghijklmnopqrstuvwxyzABCD";+ std::fs::write(+ &startup,+ format!(+ "helper() {{\n cat <<'EOF'\nexport LEGACY_SETTING=production\nAuthorization: {real}\nEOF\n}}\n{credential_shaped_function}() {{ printf UNEXPECTED_EXECUTION; }}\nexport -f helper\nexport GH_TOKEN='{real}'\n"+ ),+ )?;+ let output = Command::new("/bin/bash")+ .arg("-c")+ .arg(+ snapshot_capture_script(ShellType::Bash, CAPTURE_ALL).expect("bash supports snapshots"),+ )+ .env_clear()+ .env("HOME", dir.path())+ .env("PATH", "/usr/bin:/bin")+ .env("BASH_ENV", &startup)+ .output()?;+ assert!(output.status.success());++ let mut snapshot = String::from_utf8(output.stdout)?;+ let original = HashMap::from([("GH_TOKEN".to_string(), real.to_string())]);+ let discovered = HashMap::from([("GH_TOKEN".to_string(), dummy.to_string())]);+ let brokered_keys = vec!["GH_TOKEN".to_string()];+ let snapshot_is_safe = rewrite_snapshot_credentials(+ ShellType::Bash,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &HashMap::new(),+ discovered: &discovered,+ allowed: &discovered,+ is_allowed_unset: &|_| false,+ brokered_keys: &brokered_keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: &brokered_keys,+ },+ |text| {+ if text.contains(credential_shaped_function) {+ *text = text.replace(credential_shaped_function, "");+ return false;+ }+ *text = text.replace(real, dummy);+ true+ },+ );+ assert!(snapshot_is_safe.is_none());+ assert!(snapshot.contains(real));+ assert!(snapshot.contains(credential_shaped_function));++ Ok(())+}++#[test]+fn brokered_zsh_tied_alias_respects_policy_override() -> Result<()> {+ if !std::path::Path::new("/bin/zsh").exists() {+ return Ok(());+ }+ let real = "ghp_abcdefghijklmnopqrstuvwxyz0123456789";+ let dummy = "ghp_dummy_abcdefghijklmnopqrstuvwxyz0123";+ let keys = vec!["GH_TOKEN".to_string()];+ let script = snapshot_capture_script(ShellType::Zsh, CAPTURE_NON_INTERACTIVE).unwrap();+ for (replacement, source_present, source_allowed) in ["", "replacement|plain|replacement"]+ .into_iter()+ .flat_map(|replacement| {+ [+ (replacement, true, true),+ (replacement, true, false),+ (replacement, false, false),+ ]+ })+ {+ let unset_source = if source_present { "" } else { "unset GH_TOKEN" };+ let output = Command::new("/bin/zsh")+ .args([+ "-fc",+ &format!(+ "export -UT AUTH_HEADER auth_header=(\"Bearer $GH_TOKEN\" plain) '|'\n{unset_source}\n{script}"+ ),+ ])+ .env_clear()+ .env("GH_TOKEN", real)+ .output()?;+ assert!(output.status.success(), "{output:?}");+ let mut snapshot = String::from_utf8(output.stdout)?;+ let mut original = HashMap::from([+ ("GH_TOKEN".to_string(), real.to_string()),+ ("AUTH_HEADER".to_string(), format!("Bearer {real}|plain")),+ ]);+ let brokered_keys = if source_present {+ keys.as_slice()+ } else {+ original.remove("GH_TOKEN");+ &[]+ };+ let discovered = original+ .iter()+ .map(|(key, value)| (key.clone(), value.replace(real, dummy)))+ .collect::<HashMap<_, _>>();+ let configured = HashMap::from([("AUTH_HEADER".to_string(), replacement.to_string())]);+ let mut allowed = discovered.clone();+ allowed.extend(configured.clone());+ let allowed_keys = if source_allowed {+ keys.as_slice()+ } else {+ allowed.remove("GH_TOKEN");+ &[]+ };+ let prepared = rewrite_snapshot_credentials(+ ShellType::Zsh,+ &mut snapshot,+ SnapshotCredentialEnvironment {+ original: &original,+ restored: &original,+ configured: &configured,+ discovered: &discovered,+ allowed: &allowed,+ is_allowed_unset: &|_| true,+ brokered_keys,+ brokered_alias_keys: &[],+ allowed_brokered_keys: allowed_keys,+ },+ |value| {+ if !source_allowed && (value.contains(real) || value.contains(dummy)) {+ return false;+ }+ *value = value.replace(real, dummy);+ true+ },+ )+ .expect("policy override keeps the tied alias usable");+ assert_eq!(+ prepared.aliases,+ if source_present {+ configured+ } else {+ HashMap::new()+ }+ );+ assert!(!snapshot.contains(real));+ let inspect = "printf '%s\\0' \"$AUTH_HEADER\" \"${auth_header[@]}\"; AUTH_HEADER='next|next|last'; printf '%s\\0' \"$AUTH_HEADER\" \"${auth_header[@]}\"";+ let mut outputs = Vec::new();+ for setup in [snapshot.as_str(), "export -UT AUTH_HEADER auth_header '|'"] {+ let output = Command::new("/bin/zsh")+ .args(["-fc", &format!("set -e; {setup}\n{inspect}")])+ .env_clear()+ .env("AUTH_HEADER", replacement)+ .output()?;+ assert!(output.status.success(), "{output:?}");+ outputs.push(output.stdout);+ }+ assert_eq!(outputs[0], outputs[1]);+ }+ Ok(())+}+#[test]fn brokered_snapshot_alias_values_follow_allowed_credential_overrides() {let real = "ghp_abcdefghijklmnopqrstuvwxyz0123456789";@@ -570,6 +1895,30 @@ fn brokered_snapshot_alias_values_follow_allowed_credential_overrides() {}}+#[test]+fn brokered_snapshot_rejects_shell_escaped_credentials() {+ let real = "token_ab'cdefgh";+ let dummy = "token_xy'zabcde";+ let mut snapshot = format!(+ "# Snapshot file\n# aliases 1\nalias helper='tool {escaped}'\n# exports 0\n",+ escaped = real.replace('\'', r#"'\''"#),+ );+ let original = snapshot.clone();++ let snapshot_is_safe = rewrite_snapshot_credentials(+ ShellType::Bash,+ &mut snapshot,+ empty_snapshot_credentials(&HashMap::new(), &|_| false),+ |text| {+ *text = text.replace(real, dummy);+ true+ },+ );++ assert!(snapshot_is_safe.is_none());+ assert_eq!(snapshot, original);+}+#[cfg(target_os = "macos")]#[test]fn zsh_snapshot_restores_tied_path() -> Result<()> {@@ -698,85 +2047,3 @@ fn captured_script(shell_type: ShellType, source: &str) -> Result<String> {CapturedSnapshot::parse(shell_type, source.as_bytes()).context("invalid native capture")?;Ok(captured.render_script())}--#[test]-fn brokered_bash_snapshot_preserves_exported_functions_and_redacts_heredocs() -> Result<()> {- let dir = tempdir()?;- let startup = dir.path().join("startup.sh");- let real = "ghp_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGH";- let dummy = "ghp_brokered_dummy_abcdefghijklmnopqrstuvwxyz0123";- let credential_shaped_function = "ghp_0123456789abcdefghijklmnopqrstuvwxyzABCD";- std::fs::write(- &startup,- format!(- "helper() {{\n cat <<'EOF'\nexport LEGACY_SETTING=production\nAuthorization: {real}\nEOF\n}}\n{credential_shaped_function}() {{ printf UNEXPECTED_EXECUTION; }}\nexport -f helper\nexport GH_TOKEN='{real}'\n"- ),- )?;- let output = Command::new("/bin/bash")- .arg("-c")- .arg(- snapshot_capture_script(- ShellType::Bash,- SnapshotCaptureOptions {- startup: SnapshotStartup::NonInteractive,- ..CAPTURE_ALL- },- )- .expect("bash supports snapshots"),- )- .env_clear()- .env("HOME", dir.path())- .env("PATH", "/usr/bin:/bin")- .env("BASH_ENV", &startup)- .output()?;- assert!(output.status.success());-- let mut snapshot = String::from_utf8(output.stdout)?;- let original = HashMap::from([("GH_TOKEN".to_string(), real.to_string())]);- let discovered = HashMap::from([("GH_TOKEN".to_string(), dummy.to_string())]);- let brokered_keys = vec!["GH_TOKEN".to_string()];- rewrite_snapshot_credentials(- ShellType::Bash,- &mut snapshot,- SnapshotCredentialEnvironment {- original: &original,- restored: &original,- configured: &HashMap::new(),- discovered: &discovered,- allowed: &discovered,- is_allowed_unset: &|_| false,- brokered_keys: &brokered_keys,- brokered_alias_keys: &[],- allowed_brokered_keys: &brokered_keys,- },- |text| {- if text.contains(credential_shaped_function) {- *text = text.replace(credential_shaped_function, "");- return false;- }- *text = text.replace(real, dummy);- true- },- );- assert!(!snapshot.contains(real));- assert!(snapshot.contains(credential_shaped_function));- let path = dir.path().join("snapshot.sh");- std::fs::write(&path, snapshot)?;-- let restored = Command::new("/bin/bash")- .arg("-c")- .arg(". \"$1\"; exec /bin/bash -c helper")- .arg("snapshot")- .arg(&path)- .env_clear()- .env("PATH", "/usr/bin:/bin")- .env("GH_TOKEN", dummy)- .output()?;- assert!(restored.status.success());- assert_eq!(- String::from_utf8(restored.stdout)?,- format!("export LEGACY_SETTING=production\nAuthorization: {dummy}\n")- );-- Ok(())-}diff --git a/codex-rs/shell-escalation/src/unix/escalate_server.rs b/codex-rs/shell-escalation/src/unix/escalate_server.rsindex f45c4317e6..139450dc3d 100644--- a/codex-rs/shell-escalation/src/unix/escalate_server.rs+++ b/codex-rs/shell-escalation/src/unix/escalate_server.rs@@ -336,6 +336,7 @@ async fn handle_escalate_session_with_policy(command.args(args).arg0(arg0.unwrap_or_else(|| program.clone()))+ .env_clear().envs(&env).current_dir(&cwd).stdin(Stdio::null())