Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add bounded environment transport for MXC launch requests (#44626)

iceweasel-oai4150a2c2054a
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index 5394382df2..e62e1713b6 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -4076,6 +4076,8 @@ dependencies = [
"codex-windows-sandbox",
"learning_mode_windows",
"pretty_assertions",
+ "serde",
+ "serde_json",
"tempfile",
"thiserror 2.0.18",
"tracelogging",
diff --git a/codex-rs/mxc-sandbox/Cargo.toml b/codex-rs/mxc-sandbox/Cargo.toml
index 7623d17a45..01c04cd1dc 100644
--- a/codex-rs/mxc-sandbox/Cargo.toml
+++ b/codex-rs/mxc-sandbox/Cargo.toml
@@ -20,6 +20,8 @@ codex-protocol = { workspace = true }
codex-utils-absolute-path = { workspace = true }
codex-utils-path-uri = { workspace = true }
codex-windows-sandbox = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
thiserror = { workspace = true }
wxc_common = { workspace = true }
diff --git a/codex-rs/mxc-sandbox/src/lib.rs b/codex-rs/mxc-sandbox/src/lib.rs
index cbf7123d64..a4b101c970 100644
--- a/codex-rs/mxc-sandbox/src/lib.rs
+++ b/codex-rs/mxc-sandbox/src/lib.rs
@@ -7,6 +7,11 @@ use codex_protocol::models::PermissionProfile;
use std::path::PathBuf;
/// Typed inputs for the native policy adapter.
+pub mod transport;
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Serialize, Deserialize)]
pub struct MxcCommand {
pub permissions: PermissionProfile,
pub sandbox_policy_cwd: PathBuf,
diff --git a/codex-rs/mxc-sandbox/src/transport.rs b/codex-rs/mxc-sandbox/src/transport.rs
new file mode 100644
index 0000000000..65e9191f91
--- /dev/null
+++ b/codex-rs/mxc-sandbox/src/transport.rs
@@ -0,0 +1,118 @@
+//! Bounded launcher-only environment transport for policies too large for
+//! Windows command lines. Every transport variable is removed before spawn.
+
+use std::collections::HashMap;
+
+#[cfg(any(windows, test))]
+use anyhow::Context;
+use anyhow::Result;
+use anyhow::ensure;
+
+use crate::MxcCommand;
+
+const PREFIX: &str = "CODEX_MXC_LAUNCH_";
+const COUNT: &str = "CODEX_MXC_LAUNCH_COUNT";
+const LENGTH: &str = "CODEX_MXC_LAUNCH_BYTES";
+const CHUNK_BYTES: usize = 4096;
+const MAX_CHUNKS: usize = 256;
+const MAX_BYTES: usize = 1_000_000;
+
+fn is_transport_key(key: &str) -> bool {
+ key.as_bytes()
+ .get(..PREFIX.len())
+ .is_some_and(|start| start.eq_ignore_ascii_case(PREFIX.as_bytes()))
+}
+
+pub fn encode(command: &MxcCommand, env: &mut HashMap<String, String>) -> Result<()> {
+ let payload = serde_json::to_string(command)?;
+ ensure!(
+ payload.len() <= MAX_BYTES,
+ "MXC launcher payload exceeds {MAX_BYTES} bytes"
+ );
+ let mut chunks = Vec::new();
+ let mut start = 0;
+ while start < payload.len() {
+ let mut end = (start + CHUNK_BYTES).min(payload.len());
+ while !payload.is_char_boundary(end) {
+ end -= 1;
+ }
+ chunks.push(payload[start..end].to_owned());
+ start = end;
+ }
+ ensure!(
+ chunks.len() <= MAX_CHUNKS,
+ "MXC launcher payload has too many chunks"
+ );
+ env.retain(|key, _| !is_transport_key(key));
+ env.insert(COUNT.to_owned(), chunks.len().to_string());
+ env.insert(LENGTH.to_owned(), payload.len().to_string());
+ for (index, chunk) in chunks.into_iter().enumerate() {
+ env.insert(format!("{PREFIX}{index}"), chunk);
+ }
+ Ok(())
+}
+
+#[cfg(any(windows, test))]
+pub fn decode(env: &mut HashMap<String, String>) -> Result<MxcCommand> {
+ let mut encoded = HashMap::new();
+ let mut duplicate = false;
+ let mut oversized = false;
+ env.retain(|key, value| {
+ if !is_transport_key(key) {
+ return true;
+ }
+ if encoded.len() >= MAX_CHUNKS + 2
+ || key.len() > PREFIX.len() + 32
+ || value.len() > CHUNK_BYTES
+ {
+ oversized = true;
+ return false;
+ }
+ duplicate |= encoded
+ .insert(key.to_ascii_uppercase(), std::mem::take(value))
+ .is_some();
+ false
+ });
+ ensure!(!oversized, "oversized MXC launcher environment");
+ ensure!(!duplicate, "duplicate MXC launcher environment variables");
+ let count: usize = encoded
+ .get(COUNT)
+ .context("missing MXC launcher chunk count")?
+ .parse()?;
+ let length: usize = encoded
+ .get(LENGTH)
+ .context("missing MXC launcher payload length")?
+ .parse()?;
+ ensure!(
+ (1..=MAX_CHUNKS).contains(&count) && length <= MAX_BYTES,
+ "invalid MXC launcher payload size"
+ );
+ ensure!(
+ encoded.len() == count + 2,
+ "unexpected MXC launcher environment variables"
+ );
+ let mut payload = String::with_capacity(length);
+ for index in 0..count {
+ let chunk = encoded
+ .get(&format!("{PREFIX}{index}"))
+ .context("missing MXC launcher chunk")?;
+ ensure!(
+ !chunk.is_empty() && chunk.len() <= CHUNK_BYTES,
+ "invalid MXC launcher chunk size"
+ );
+ ensure!(
+ payload.len() + chunk.len() <= length,
+ "MXC launcher payload length mismatch"
+ );
+ payload.push_str(chunk);
+ }
+ ensure!(
+ payload.len() == length,
+ "MXC launcher payload length mismatch"
+ );
+ serde_json::from_str(&payload).context("invalid MXC launcher request")
+}
+
+#[cfg(test)]
+#[path = "transport_tests.rs"]
+mod tests;
diff --git a/codex-rs/mxc-sandbox/src/transport_tests.rs b/codex-rs/mxc-sandbox/src/transport_tests.rs
new file mode 100644
index 0000000000..1009292fb3
--- /dev/null
+++ b/codex-rs/mxc-sandbox/src/transport_tests.rs
@@ -0,0 +1,81 @@
+//! Verify bounded transport, Unicode roundtrips, and child-environment cleanup.
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use codex_protocol::models::PermissionProfile;
+use pretty_assertions::assert_eq;
+
+use crate::MxcCommand;
+
+use super::CHUNK_BYTES;
+use super::COUNT;
+use super::LENGTH;
+use super::MAX_BYTES;
+use super::PREFIX;
+use super::decode;
+use super::encode;
+
+fn command(args: Vec<String>) -> MxcCommand {
+ MxcCommand {
+ permissions: PermissionProfile::read_only(),
+ sandbox_policy_cwd: PathBuf::from("workspace"),
+ command: args,
+ }
+}
+
+#[test]
+fn large_unicode_launch_roundtrips_and_never_reaches_child_environment() -> Result<()> {
+ let args = vec![
+ "codex-windows-mxc".to_owned(),
+ "🧊".repeat(20_000),
+ "a\"\\b".to_owned(),
+ ];
+ let expected_env = HashMap::from([("CUSTOM".to_owned(), "value".to_owned())]);
+ let mut env = expected_env.clone();
+ env.insert("codex_mxc_launch_999".to_owned(), "spoofed".to_owned());
+ let request = command(args);
+ encode(&request, &mut env)?;
+ assert!(!env.contains_key("codex_mxc_launch_999"));
+ assert!(
+ env.values()
+ .all(|value| value.encode_utf16().count() < 8192)
+ );
+ assert_eq!(
+ serde_json::to_value(decode(&mut env)?)?,
+ serde_json::to_value(request)?
+ );
+ assert_eq!(env, expected_env);
+ Ok(())
+}
+
+#[test]
+fn malformed_transport_is_rejected_and_removed() -> Result<()> {
+ let expected_env = HashMap::from([("CUSTOM".to_owned(), "value".to_owned())]);
+ let mut valid = expected_env.clone();
+ encode(&command(vec!["program.exe".to_owned()]), &mut valid)?;
+ for (key, value) in [
+ (COUNT.to_owned(), "257".to_owned()),
+ (LENGTH.to_owned(), "0".to_owned()),
+ (format!("{PREFIX}0"), "x".repeat(CHUNK_BYTES + 1)),
+ (COUNT.to_ascii_lowercase(), "1".to_owned()),
+ ] {
+ let mut env = valid.clone();
+ env.insert(key, value);
+ assert!(decode(&mut env).is_err());
+ assert_eq!(env, expected_env);
+ }
+ valid.remove(&format!("{PREFIX}0"));
+ assert!(decode(&mut valid).is_err());
+ assert_eq!(valid, expected_env);
+ Ok(())
+}
+
+#[test]
+fn oversized_payload_fails_before_modifying_launcher_environment() {
+ let expected = HashMap::from([("CUSTOM".to_owned(), "value".to_owned())]);
+ let mut env = expected.clone();
+ assert!(encode(&command(vec!["x".repeat(MAX_BYTES)]), &mut env).is_err());
+ assert_eq!(env, expected);
+}