mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
Protect .aws directories under sandbox writable roots (#48176)
## Why AWS profiles can select credential helpers that the application executes. Granting write access to a containing directory should therefore keep `.aws` protected by default. ## What changed Add `.aws` to the protected metadata paths alongside `.git`, `.agents`, and `.codex`, including workspace roots and additional writable roots. Preserve explicit user rules that override the default protection. ## Testing Extend policy and sandbox tests to cover `.aws` protection. Add macOS coverage for existing and absent `.aws` directories, deletion and replacement attempts, and symlink targets. Verify that Linux sandbox writes to protected configuration files fail while sibling files remain writable. GitOrigin-RevId: 31ea287bd0dd9b13aff893783fba9ca3aed0c89d
This commit is contained in:
@@ -3730,7 +3730,7 @@ async fn implicit_builtin_workspace_profile_preserves_add_dir_metadata_carveouts
|
||||
let codex_home = TempDir::new()?;
|
||||
let cwd = TempDir::new()?;
|
||||
let extra_root = TempDir::new()?;
|
||||
for subpath in [".git", ".agents", ".codex"] {
|
||||
for subpath in [".git", ".agents", ".codex", ".aws"] {
|
||||
std::fs::create_dir_all(extra_root.path().join(subpath))?;
|
||||
}
|
||||
let project_key = cwd.path().to_string_lossy().to_string();
|
||||
@@ -3763,7 +3763,7 @@ async fn implicit_builtin_workspace_profile_preserves_add_dir_metadata_carveouts
|
||||
policy.can_write_local_path_with_cwd(extra_root.as_path(), cwd.path()),
|
||||
"expected implicit :workspace to preserve additional writable roots, policy: {policy:?}"
|
||||
);
|
||||
for subpath in [".git", ".agents", ".codex"] {
|
||||
for subpath in [".git", ".agents", ".codex", ".aws"] {
|
||||
assert!(
|
||||
!policy.can_write_local_path_with_cwd(&extra_root.join(subpath), cwd.path()),
|
||||
"expected implicit :workspace to preserve legacy metadata carveout for {subpath}, \
|
||||
@@ -4953,7 +4953,7 @@ exclude_slash_tmp = true
|
||||
missing_path_behavior: None,
|
||||
})
|
||||
);
|
||||
for subpath in [".git", ".agents", ".codex"] {
|
||||
for subpath in [".git", ".agents", ".codex", ".aws"] {
|
||||
assert!(
|
||||
file_system_policy
|
||||
.entries
|
||||
|
||||
+1
-1
@@ -30,7 +30,7 @@ Scenario: Resolved local MXC selection preserves workspace-write permissions in
|
||||
<shell><HOST_SHELL></shell>
|
||||
<current_date><CURRENT_DATE></current_date>
|
||||
<timezone><HOST_TIMEZONE></timezone>
|
||||
<filesystem><workspace_roots><root><WORKSPACE_ROOT 1></root></workspace_roots><permission_profile type...ntry></file_system></permission_profile></filesystem> [hash=c88e32494c7023a5]
|
||||
<filesystem><workspace_roots><root><WORKSPACE_ROOT 1></root></workspace_roots><permission_profile type...ntry></file_system></permission_profile></filesystem> [hash=e9b73aecc0d54647]
|
||||
</environment_context>
|
||||
02:message/user:
|
||||
Inspect the sandbox.
|
||||
|
||||
@@ -343,7 +343,7 @@ async fn workspace_roots_allow_file_and_command_writes_in_secondary_root(
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn workspace_roots_allow_patches_but_protect_metadata_directories() -> Result<()> {
|
||||
const PATCH_CONTENTS: &str = "workspace root patch access";
|
||||
const PROTECTED_METADATA_DIRECTORIES: [&str; 3] = [".git", ".agents", ".codex"];
|
||||
const PROTECTED_METADATA_DIRECTORIES: [&str; 4] = [".git", ".agents", ".codex", ".aws"];
|
||||
|
||||
skip_if_wine_exec!(
|
||||
Ok(()),
|
||||
|
||||
@@ -2038,6 +2038,7 @@ mod tests {
|
||||
workspace.join(".git"),
|
||||
workspace.join(".agents"),
|
||||
workspace.join(".codex"),
|
||||
workspace.join(".aws"),
|
||||
]
|
||||
);
|
||||
assert!(
|
||||
@@ -2075,6 +2076,7 @@ mod tests {
|
||||
dot_git.clone(),
|
||||
workspace.join(".agents"),
|
||||
workspace.join(".codex"),
|
||||
workspace.join(".aws"),
|
||||
]
|
||||
);
|
||||
assert!(
|
||||
@@ -2116,7 +2118,12 @@ mod tests {
|
||||
assert_empty_directory_mounted_read_only(&args.args, &workspace.join(".codex"));
|
||||
assert_eq!(
|
||||
synthetic_mount_target_paths(&args),
|
||||
vec![workspace.join(".codex"), dot_git, workspace.join(".agents")],
|
||||
vec![
|
||||
workspace.join(".codex"),
|
||||
dot_git,
|
||||
workspace.join(".agents"),
|
||||
workspace.join(".aws"),
|
||||
],
|
||||
);
|
||||
assert!(
|
||||
protected_create_target_paths(&args).is_empty(),
|
||||
@@ -2153,7 +2160,12 @@ mod tests {
|
||||
assert_empty_directory_mounted_read_only(&args.args, &workspace.join(".codex"));
|
||||
assert_eq!(
|
||||
synthetic_mount_target_paths(&args),
|
||||
vec![workspace.join(".codex"), dot_git, workspace.join(".agents")],
|
||||
vec![
|
||||
workspace.join(".codex"),
|
||||
dot_git,
|
||||
workspace.join(".agents"),
|
||||
workspace.join(".aws"),
|
||||
],
|
||||
);
|
||||
assert!(
|
||||
protected_create_target_paths(&args).is_empty(),
|
||||
@@ -2313,12 +2325,14 @@ mod tests {
|
||||
assert_eq!(
|
||||
synthetic_mount_target_paths(&args),
|
||||
vec![
|
||||
PathBuf::from("/.aws"),
|
||||
PathBuf::from("/.git"),
|
||||
PathBuf::from("/.agents"),
|
||||
PathBuf::from("/.codex"),
|
||||
PathBuf::from("/dev/.git"),
|
||||
PathBuf::from("/dev/.agents"),
|
||||
PathBuf::from("/dev/.codex"),
|
||||
PathBuf::from("/dev/.aws"),
|
||||
]
|
||||
);
|
||||
let dev_mounts = args
|
||||
@@ -2542,7 +2556,7 @@ mod tests {
|
||||
FileSystemSandboxEntry::new(docs.clone().into(), FileSystemAccessMode::Read),
|
||||
FileSystemSandboxEntry::new(docs_public.clone().into(), FileSystemAccessMode::Write),
|
||||
];
|
||||
for name in [".git", ".agents", ".codex"] {
|
||||
for name in [".git", ".agents", ".codex", ".aws"] {
|
||||
entries.push(FileSystemSandboxEntry::skip_missing_path(
|
||||
docs_public.join(name).into(),
|
||||
FileSystemAccessMode::Read,
|
||||
@@ -2572,7 +2586,7 @@ mod tests {
|
||||
"expected read-only parent remount before nested writable bind: {:#?}",
|
||||
args.args
|
||||
);
|
||||
for name in [".git", ".agents", ".codex"] {
|
||||
for name in [".git", ".agents", ".codex", ".aws"] {
|
||||
let metadata_path = path_to_string(docs_public.join(name).as_path());
|
||||
let mount_indices = args
|
||||
.args
|
||||
|
||||
@@ -896,55 +896,50 @@ async fn sandbox_blocks_nc() {
|
||||
assert_network_blocked(&["nc", "-z", "127.0.0.1", "80"]).await;
|
||||
}
|
||||
|
||||
#[test_case::test_case(".git", "config")]
|
||||
#[test_case::test_case(".codex", "config.toml")]
|
||||
#[test_case::test_case(".aws", "config")]
|
||||
#[tokio::test]
|
||||
async fn sandbox_blocks_git_and_codex_writes_inside_writable_root() {
|
||||
async fn sandbox_blocks_metadata_writes_inside_writable_root(name: &str, config: &str) {
|
||||
if should_skip_bwrap_tests().await {
|
||||
eprintln!("skipping bwrap test: bwrap sandbox prerequisites are unavailable");
|
||||
return;
|
||||
}
|
||||
|
||||
let tmpdir = tempfile::tempdir().expect("tempdir");
|
||||
let dot_git = tmpdir.path().join(".git");
|
||||
let dot_codex = tmpdir.path().join(".codex");
|
||||
std::fs::create_dir_all(&dot_git).expect("create .git");
|
||||
std::fs::create_dir_all(&dot_codex).expect("create .codex");
|
||||
|
||||
let git_target = dot_git.join("config");
|
||||
let codex_target = dot_codex.join("config.toml");
|
||||
|
||||
let git_output = expect_denied(
|
||||
run_cmd_result_with_writable_roots(
|
||||
&[
|
||||
"bash",
|
||||
"-lc",
|
||||
&format!("echo denied > {}", git_target.to_string_lossy()),
|
||||
],
|
||||
&[tmpdir.path().to_path_buf()],
|
||||
LONG_TIMEOUT_MS,
|
||||
/*use_legacy_landlock*/ false,
|
||||
/*network_access*/ true,
|
||||
)
|
||||
.await,
|
||||
".git write should be denied under bubblewrap",
|
||||
let home = tempfile::tempdir().expect("tempdir");
|
||||
let metadata = home.path().join(name);
|
||||
std::fs::create_dir(&metadata).expect("create protected directory");
|
||||
let target = metadata.join(config);
|
||||
std::fs::write(&target, "original").expect("write protected config");
|
||||
let output = run_cmd_result_with_writable_roots(
|
||||
&[
|
||||
"/bin/sh",
|
||||
"-c",
|
||||
r#"set -eu
|
||||
writable_home="$1"
|
||||
printf permitted > "$writable_home/allowed"
|
||||
if (printf changed > "$2") 2>/dev/null; then exit 1; fi
|
||||
printf protected"#,
|
||||
"metadata-test",
|
||||
home.path().to_str().expect("UTF-8 home"),
|
||||
target.to_str().expect("UTF-8 config"),
|
||||
],
|
||||
&[home.path().to_path_buf()],
|
||||
LONG_TIMEOUT_MS,
|
||||
/*use_legacy_landlock*/ false,
|
||||
/*network_access*/ true,
|
||||
)
|
||||
.await
|
||||
.expect("sandbox should run with a separate writable home");
|
||||
assert_eq!(
|
||||
(output.exit_code, output.stdout.text, output.stderr.text),
|
||||
(0, "protected".to_string(), String::new())
|
||||
);
|
||||
|
||||
let codex_output = expect_denied(
|
||||
run_cmd_result_with_writable_roots(
|
||||
&[
|
||||
"bash",
|
||||
"-lc",
|
||||
&format!("echo denied > {}", codex_target.to_string_lossy()),
|
||||
],
|
||||
&[tmpdir.path().to_path_buf()],
|
||||
LONG_TIMEOUT_MS,
|
||||
/*use_legacy_landlock*/ false,
|
||||
/*network_access*/ true,
|
||||
)
|
||||
.await,
|
||||
".codex write should be denied under bubblewrap",
|
||||
assert_eq!(std::fs::read_to_string(target).unwrap(), "original");
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(home.path().join("allowed")).unwrap(),
|
||||
"permitted"
|
||||
);
|
||||
assert_ne!(git_output.exit_code, 0);
|
||||
assert_ne!(codex_output.exit_code, 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -61,7 +61,7 @@ async fn sandbox_starts_with_nested_writable_metadata(layout: RootLayout, relati
|
||||
];
|
||||
// Remote clients expand generated workspace metadata rules to concrete
|
||||
// paths, including paths that do not yet exist on the executor.
|
||||
for name in [".git", ".agents", ".codex"] {
|
||||
for name in [".git", ".agents", ".codex", ".aws"] {
|
||||
entries.push(FileSystemSandboxEntry::skip_missing_path(
|
||||
visualization.join(name).into(),
|
||||
FileSystemAccessMode::Read,
|
||||
@@ -86,7 +86,7 @@ fi
|
||||
if (touch "$workspace/.codex/forbidden.txt") 2>/dev/null; then
|
||||
exit 11
|
||||
fi
|
||||
for name in .git .agents .codex; do
|
||||
for name in .git .agents .codex .aws; do
|
||||
test -d "$visualization/$name"
|
||||
if (touch "$visualization/$name/forbidden.txt") 2>/dev/null; then
|
||||
exit 12
|
||||
@@ -125,7 +125,7 @@ printf nested-metadata-protected
|
||||
] {
|
||||
assert_eq!(std::fs::read_to_string(path).expect("read file"), expected);
|
||||
}
|
||||
for name in [".git", ".agents", ".codex"] {
|
||||
for name in [".git", ".agents", ".codex", ".aws"] {
|
||||
assert!(
|
||||
!visualization.join(name).exists(),
|
||||
"temporary {name} mountpoint should be cleaned up"
|
||||
|
||||
@@ -236,10 +236,12 @@ fn native_grants_preserve_denies_and_read_only_carveouts() -> Result<()> {
|
||||
let request = build_request(&command(&profile, root), root, Vec::new(), &[], &[])?;
|
||||
let mut expected_read = [
|
||||
root.join(".agents"),
|
||||
root.join(".aws"),
|
||||
root.join(".codex"),
|
||||
root.join(".git"),
|
||||
readonly,
|
||||
writable_child.join(".agents"),
|
||||
writable_child.join(".aws"),
|
||||
writable_child.join(".codex"),
|
||||
writable_child.join(".git"),
|
||||
];
|
||||
@@ -296,6 +298,7 @@ fn volume_expansion_does_not_turn_read_only_child_writable() -> Result<()> {
|
||||
request.policy.readonly_paths,
|
||||
vec![
|
||||
root.join(".agents").to_str().unwrap(),
|
||||
root.join(".aws").to_str().unwrap(),
|
||||
root.join(".codex").to_str().unwrap(),
|
||||
root.join(".git").to_str().unwrap(),
|
||||
readonly.to_str().unwrap()
|
||||
@@ -609,7 +612,7 @@ fn root_deny_keeps_only_narrow_explicit_grants() -> Result<()> {
|
||||
FileSystemAccessMode::Read => (Vec::new(), allowed),
|
||||
FileSystemAccessMode::Write => (
|
||||
allowed,
|
||||
[".agents", ".codex", ".git"]
|
||||
[".agents", ".aws", ".codex", ".git"]
|
||||
.map(|name| child.join(name).to_str().unwrap().to_owned())
|
||||
.to_vec(),
|
||||
),
|
||||
@@ -782,11 +785,13 @@ fn symbolic_root_preserves_equal_path_precedence_and_denies() -> Result<()> {
|
||||
reads_in_volumes,
|
||||
volumes[..2]
|
||||
.iter()
|
||||
.flat_map(|volume| [".agents", ".codex", ".git"].map(|name| volume
|
||||
.join(name)
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned()))
|
||||
.flat_map(
|
||||
|volume| [".agents", ".aws", ".codex", ".git"].map(|name| volume
|
||||
.join(name)
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned())
|
||||
)
|
||||
.collect::<Vec<_>>()
|
||||
);
|
||||
assert_eq!(
|
||||
|
||||
@@ -136,7 +136,7 @@ fn effective_workspace_intersection_preserves_network_metadata_and_temp() {
|
||||
);
|
||||
assert_eq!(result.network_sandbox_policy(), Restricted);
|
||||
assert!(policy.entries.contains(&special(Tmpdir, Write)));
|
||||
for name in [".git", ".agents", ".codex"] {
|
||||
for name in [".git", ".agents", ".codex", ".aws"] {
|
||||
let protected = project.join(name);
|
||||
assert!(!policy.can_write_local_path_with_cwd(protected.as_path(), root.as_path()));
|
||||
assert!(policy.entries.contains(&skipped(protected.into(), Read)));
|
||||
|
||||
@@ -40,12 +40,14 @@ pub use windows_glob::windows_deny_read_glob_scan;
|
||||
const PROTECTED_METADATA_GIT_PATH_NAME: &str = ".git";
|
||||
const PROTECTED_METADATA_AGENTS_PATH_NAME: &str = ".agents";
|
||||
const PROTECTED_METADATA_CODEX_PATH_NAME: &str = ".codex";
|
||||
const PROTECTED_METADATA_AWS_PATH_NAME: &str = ".aws";
|
||||
|
||||
/// Top-level workspace metadata paths that stay protected under writable roots.
|
||||
pub const PROTECTED_METADATA_PATH_NAMES: &[&str] = &[
|
||||
PROTECTED_METADATA_GIT_PATH_NAME,
|
||||
PROTECTED_METADATA_AGENTS_PATH_NAME,
|
||||
PROTECTED_METADATA_CODEX_PATH_NAME,
|
||||
PROTECTED_METADATA_AWS_PATH_NAME,
|
||||
];
|
||||
|
||||
/// Returns true when a path basename is one of the protected workspace metadata names.
|
||||
@@ -858,6 +860,7 @@ impl FileSystemSandboxPolicy {
|
||||
append_default_read_only_project_root_subpath_if_no_explicit_rule(&mut entries, ".git");
|
||||
append_default_read_only_project_root_subpath_if_no_explicit_rule(&mut entries, ".agents");
|
||||
append_default_read_only_project_root_subpath_if_no_explicit_rule(&mut entries, ".codex");
|
||||
append_default_read_only_project_root_subpath_if_no_explicit_rule(&mut entries, ".aws");
|
||||
for writable_root in writable_roots {
|
||||
for protected_path in default_read_only_subpaths_for_writable_root(
|
||||
writable_root,
|
||||
@@ -2377,6 +2380,12 @@ pub(crate) fn default_read_only_subpaths_for_writable_root(
|
||||
subpaths.push(top_level_codex);
|
||||
}
|
||||
|
||||
// AWS profiles can select credential helpers that the application executes.
|
||||
let top_level_aws = writable_root.join(PROTECTED_METADATA_AWS_PATH_NAME);
|
||||
if top_level_aws.as_path().is_dir() {
|
||||
subpaths.push(top_level_aws);
|
||||
}
|
||||
|
||||
dedup_absolute_paths(subpaths, /*normalize_effective_paths*/ false)
|
||||
}
|
||||
|
||||
@@ -3363,6 +3372,12 @@ mod tests {
|
||||
},
|
||||
FileSystemAccessMode::Read,
|
||||
),
|
||||
FileSystemSandboxEntry::skip_missing_path(
|
||||
FileSystemPath::Special {
|
||||
value: FileSystemSpecialPath::project_roots(Some(".aws".into())),
|
||||
},
|
||||
FileSystemAccessMode::Read,
|
||||
),
|
||||
])
|
||||
);
|
||||
}
|
||||
@@ -3390,52 +3405,55 @@ mod tests {
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn writable_roots_skip_default_dot_codex_when_explicit_user_rule_exists() {
|
||||
let cwd = TempDir::new().expect("tempdir");
|
||||
let expected_root = AbsolutePathBuf::from_absolute_path(
|
||||
cwd.path().canonicalize().expect("canonicalize cwd"),
|
||||
)
|
||||
.expect("absolute canonical root");
|
||||
let explicit_dot_codex = expected_root.join(".codex");
|
||||
fn writable_roots_skip_default_metadata_when_explicit_user_rule_exists() {
|
||||
for name in [".codex", ".aws"] {
|
||||
let cwd = TempDir::new().expect("tempdir");
|
||||
let expected_root = AbsolutePathBuf::from_absolute_path(
|
||||
cwd.path().canonicalize().expect("canonicalize cwd"),
|
||||
)
|
||||
.expect("absolute canonical root");
|
||||
let explicit_metadata = expected_root.join(name);
|
||||
fs::create_dir(&explicit_metadata).expect("create metadata directory");
|
||||
|
||||
let policy = FileSystemSandboxPolicy::restricted(vec![
|
||||
FileSystemSandboxEntry {
|
||||
path: FileSystemPath::Special {
|
||||
value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
|
||||
let policy = FileSystemSandboxPolicy::restricted(vec![
|
||||
FileSystemSandboxEntry {
|
||||
path: FileSystemPath::Special {
|
||||
value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
|
||||
},
|
||||
access: FileSystemAccessMode::Write,
|
||||
missing_path_behavior: None,
|
||||
},
|
||||
access: FileSystemAccessMode::Write,
|
||||
missing_path_behavior: None,
|
||||
},
|
||||
FileSystemSandboxEntry {
|
||||
path: FileSystemPath::Path {
|
||||
path: explicit_dot_codex.clone().into(),
|
||||
FileSystemSandboxEntry {
|
||||
path: FileSystemPath::Path {
|
||||
path: explicit_metadata.clone().into(),
|
||||
},
|
||||
access: FileSystemAccessMode::Write,
|
||||
missing_path_behavior: None,
|
||||
},
|
||||
access: FileSystemAccessMode::Write,
|
||||
missing_path_behavior: None,
|
||||
},
|
||||
]);
|
||||
]);
|
||||
|
||||
let writable_roots = policy.get_writable_roots_with_cwd(cwd.path());
|
||||
let workspace_root = writable_roots
|
||||
.iter()
|
||||
.find(|root| root.root == expected_root)
|
||||
.expect("workspace writable root");
|
||||
assert!(
|
||||
!workspace_root
|
||||
.protected_metadata_names
|
||||
.contains(&".codex".to_string()),
|
||||
"explicit .codex rule should remove the metadata-name protection"
|
||||
);
|
||||
assert!(
|
||||
!workspace_root
|
||||
.read_only_subpaths
|
||||
.contains(&explicit_dot_codex),
|
||||
"explicit .codex rule should win over the default protected carveout"
|
||||
);
|
||||
assert!(policy.can_write_local_path_with_cwd(
|
||||
explicit_dot_codex.join("config.toml").as_path(),
|
||||
cwd.path()
|
||||
));
|
||||
let writable_roots = policy.get_writable_roots_with_cwd(cwd.path());
|
||||
let workspace_root = writable_roots
|
||||
.iter()
|
||||
.find(|root| root.root == expected_root)
|
||||
.expect("workspace writable root");
|
||||
assert!(
|
||||
!workspace_root
|
||||
.protected_metadata_names
|
||||
.contains(&name.to_string()),
|
||||
"explicit {name} rule should remove the metadata-name protection"
|
||||
);
|
||||
assert!(
|
||||
!workspace_root
|
||||
.read_only_subpaths
|
||||
.contains(&explicit_metadata),
|
||||
"explicit {name} rule should win over the default protected carveout"
|
||||
);
|
||||
assert!(policy.can_write_local_path_with_cwd(
|
||||
explicit_metadata.join("config.toml").as_path(),
|
||||
cwd.path()
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -3444,6 +3462,7 @@ mod tests {
|
||||
let dot_git_config = cwd.path().join(".git").join("config");
|
||||
let dot_agents_config = cwd.path().join(".agents").join("config");
|
||||
let dot_codex_config = cwd.path().join(".codex").join("config.toml");
|
||||
let dot_aws_config = cwd.path().join(".aws").join("config");
|
||||
let root = AbsolutePathBuf::from_absolute_path(cwd.path()).expect("absolute cwd");
|
||||
let file_system_policy =
|
||||
FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
|
||||
@@ -3455,6 +3474,7 @@ mod tests {
|
||||
assert!(!file_system_policy.can_write_local_path_with_cwd(&dot_git_config, cwd.path()));
|
||||
assert!(!file_system_policy.can_write_local_path_with_cwd(&dot_agents_config, cwd.path()));
|
||||
assert!(!file_system_policy.can_write_local_path_with_cwd(&dot_codex_config, cwd.path()));
|
||||
assert!(!file_system_policy.can_write_local_path_with_cwd(&dot_aws_config, cwd.path()));
|
||||
|
||||
let writable_roots = file_system_policy.get_writable_roots_with_cwd(cwd.path());
|
||||
assert_eq!(writable_roots.len(), 1);
|
||||
@@ -3464,11 +3484,13 @@ mod tests {
|
||||
".git".to_string(),
|
||||
".agents".to_string(),
|
||||
".codex".to_string(),
|
||||
".aws".to_string(),
|
||||
]
|
||||
);
|
||||
assert!(!writable_roots[0].is_path_writable(&dot_git_config));
|
||||
assert!(!writable_roots[0].is_path_writable(&dot_agents_config));
|
||||
assert!(!writable_roots[0].is_path_writable(&dot_codex_config));
|
||||
assert!(!writable_roots[0].is_path_writable(&dot_aws_config));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1980,6 +1980,13 @@ fn create_seatbelt_args_with_read_only_git_and_codex_subpaths() {
|
||||
.join(".agents")
|
||||
.display()
|
||||
),
|
||||
format!(
|
||||
"-DWRITABLE_ROOT_0_EXCLUDED_3={}",
|
||||
cwd.canonicalize()
|
||||
.expect("canonicalize cwd")
|
||||
.join(".aws")
|
||||
.display()
|
||||
),
|
||||
format!(
|
||||
"-DWRITABLE_ROOT_1={}",
|
||||
vulnerable_root_canonical.to_string_lossy()
|
||||
@@ -2542,53 +2549,145 @@ fn seatbelt_protects_writable_root_created_as_directory() {
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
#[test]
|
||||
fn seatbelt_protects_aws_in_extra_writable_home() {
|
||||
for existing in [true, false] {
|
||||
let tmp = TempDir::new().expect("tempdir");
|
||||
let home = tmp.path().join("home");
|
||||
let workspace = tmp.path().join("workspace");
|
||||
let aws = home.join(".aws");
|
||||
let config = aws.join("config");
|
||||
let probe = home.join("probe");
|
||||
fs::create_dir_all(&home).expect("create home");
|
||||
fs::create_dir_all(&workspace).expect("create workspace");
|
||||
fs::write(home.join("replacement"), "replacement").expect("write replacement");
|
||||
fs::create_dir(home.join("replacement-dir")).expect("create replacement directory");
|
||||
if existing {
|
||||
fs::create_dir(&aws).expect("create .aws");
|
||||
fs::write(&config, "original").expect("write AWS config");
|
||||
}
|
||||
let policy = SandboxPolicy::WorkspaceWrite {
|
||||
writable_roots: vec![home.as_path().try_into().expect("absolute home")],
|
||||
network_access: false,
|
||||
exclude_tmpdir_env_var: true,
|
||||
exclude_slash_tmp: true,
|
||||
};
|
||||
let attempts: &[&str] = if existing {
|
||||
&[
|
||||
r#"printf changed > "$HOME/.aws/config""#,
|
||||
r#"/bin/rm "$HOME/.aws/config""#,
|
||||
r#"/bin/mv "$HOME/.aws/config" "$HOME/renamed-config""#,
|
||||
r#"/bin/mv "$HOME/replacement" "$HOME/.aws/config""#,
|
||||
r#"/bin/mv "$HOME/.aws" "$HOME/renamed-aws""#,
|
||||
]
|
||||
} else {
|
||||
&[
|
||||
r#"/bin/mkdir "$HOME/.aws""#,
|
||||
r#"/bin/mv "$HOME/replacement-dir" "$HOME/.aws""#,
|
||||
r#"/bin/ln -s "$HOME/replacement-dir" "$HOME/.aws""#,
|
||||
]
|
||||
};
|
||||
for attempt in attempts {
|
||||
let args = create_seatbelt_command_args_for_legacy_policy(
|
||||
vec![
|
||||
"/bin/sh".to_string(),
|
||||
"-c".to_string(),
|
||||
format!(r#"printf ran > "$HOME/probe" && {attempt}"#),
|
||||
],
|
||||
&policy,
|
||||
&workspace,
|
||||
/*enforce_managed_network*/ false,
|
||||
/*network*/ None,
|
||||
)
|
||||
.expect("build seatbelt command");
|
||||
let output = Command::new(MACOS_PATH_TO_SEATBELT_EXECUTABLE)
|
||||
.args(args)
|
||||
.env("HOME", &home)
|
||||
.current_dir(&workspace)
|
||||
.output()
|
||||
.expect("execute seatbelt command");
|
||||
assert_eq!(
|
||||
fs::read_to_string(&probe).expect("read sibling probe"),
|
||||
"ran"
|
||||
);
|
||||
fs::remove_file(&probe).expect("reset sibling probe");
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
assert!(
|
||||
!output.status.success() && stderr.contains("Operation not permitted"),
|
||||
"expected Seatbelt denial for {attempt}: {stderr}"
|
||||
);
|
||||
if existing {
|
||||
assert_eq!(
|
||||
fs::read_to_string(&config).expect("read AWS config"),
|
||||
"original"
|
||||
);
|
||||
} else {
|
||||
assert!(
|
||||
fs::symlink_metadata(&aws).is_err(),
|
||||
".aws should remain absent"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
#[test]
|
||||
fn seatbelt_protects_resolved_target_of_symlinked_metadata_directory() {
|
||||
use std::os::unix::fs::symlink;
|
||||
|
||||
let tmp = TempDir::new().expect("tempdir");
|
||||
let writable_root = tmp.path().join("workspace");
|
||||
let actual_config = writable_root.join("actual-config");
|
||||
let dot_codex = writable_root.join(".codex");
|
||||
let config_toml = actual_config.join("config.toml");
|
||||
fs::create_dir_all(&actual_config).expect("create actual config directory");
|
||||
fs::write(&config_toml, "original").expect("write config");
|
||||
symlink(&actual_config, &dot_codex).expect("create .codex symlink");
|
||||
let policy = restricted_write_policy(&[writable_root.as_path()]);
|
||||
let args = create_seatbelt_command_args(CreateSeatbeltCommandArgsParams {
|
||||
command: vec![
|
||||
"/bin/sh".to_string(),
|
||||
"-c".to_string(),
|
||||
"printf escaped > \"$1\"".to_string(),
|
||||
"sh".to_string(),
|
||||
config_toml.display().to_string(),
|
||||
],
|
||||
file_system_sandbox_policy: &policy,
|
||||
network_sandbox_policy: NetworkSandboxPolicy::Restricted,
|
||||
sandbox_policy_cwd: &writable_root,
|
||||
enforce_managed_network: false,
|
||||
managed_network: None,
|
||||
environment_id: None,
|
||||
network: None,
|
||||
extra_allow_unix_sockets: &[],
|
||||
})
|
||||
.expect("build seatbelt command");
|
||||
for (name, config_name) in [(".codex", "config.toml"), (".aws", "config")] {
|
||||
let tmp = TempDir::new().expect("tempdir");
|
||||
let writable_root = tmp.path().join("workspace");
|
||||
let actual_config = writable_root.join("actual-config");
|
||||
let metadata_dir = writable_root.join(name);
|
||||
let config = actual_config.join(config_name);
|
||||
let probe = writable_root.join("probe");
|
||||
fs::create_dir_all(&actual_config).expect("create actual config directory");
|
||||
fs::write(&config, "original").expect("write config");
|
||||
symlink(&actual_config, &metadata_dir).expect("create metadata symlink");
|
||||
let policy = restricted_write_policy(&[writable_root.as_path()]);
|
||||
let args = create_seatbelt_command_args(CreateSeatbeltCommandArgsParams {
|
||||
command: vec![
|
||||
"/bin/sh".to_string(),
|
||||
"-c".to_string(),
|
||||
"printf ran > \"$2\" && printf escaped > \"$1\"".to_string(),
|
||||
"sh".to_string(),
|
||||
config.display().to_string(),
|
||||
probe.display().to_string(),
|
||||
],
|
||||
file_system_sandbox_policy: &policy,
|
||||
network_sandbox_policy: NetworkSandboxPolicy::Restricted,
|
||||
sandbox_policy_cwd: &writable_root,
|
||||
enforce_managed_network: false,
|
||||
managed_network: None,
|
||||
environment_id: None,
|
||||
network: None,
|
||||
extra_allow_unix_sockets: &[],
|
||||
})
|
||||
.expect("build seatbelt command");
|
||||
|
||||
let output = Command::new(MACOS_PATH_TO_SEATBELT_EXECUTABLE)
|
||||
.args(&args)
|
||||
.current_dir(&writable_root)
|
||||
.output()
|
||||
.expect("execute seatbelt command");
|
||||
let output = Command::new(MACOS_PATH_TO_SEATBELT_EXECUTABLE)
|
||||
.args(&args)
|
||||
.current_dir(&writable_root)
|
||||
.output()
|
||||
.expect("execute seatbelt command");
|
||||
|
||||
assert!(
|
||||
!output.status.success(),
|
||||
"resolved .codex target should remain read-only"
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read_to_string(&config_toml).expect("read config"),
|
||||
"original"
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read_to_string(&probe).expect("read sibling probe"),
|
||||
"ran"
|
||||
);
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
assert!(
|
||||
!output.status.success() && stderr.contains("Operation not permitted"),
|
||||
"resolved {name} target should remain read-only: {stderr}"
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read_to_string(&config).expect("read config"),
|
||||
"original"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -317,13 +317,15 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn denies_codex_and_agents_inside_writable_root() {
|
||||
fn denies_codex_agents_and_aws_inside_writable_root() {
|
||||
let tmp = TempDir::new().expect("tempdir");
|
||||
let command_cwd = tmp.path().join("workspace");
|
||||
let codex_dir = command_cwd.join(".codex");
|
||||
let agents_dir = command_cwd.join(".agents");
|
||||
let aws_dir = command_cwd.join(".aws");
|
||||
let _ = fs::create_dir_all(&codex_dir);
|
||||
let _ = fs::create_dir_all(&agents_dir);
|
||||
let _ = fs::create_dir_all(&aws_dir);
|
||||
|
||||
let permission_profile = workspace_write_profile(
|
||||
&[],
|
||||
@@ -344,6 +346,7 @@ mod tests {
|
||||
let expected_deny: HashSet<PathBuf> = [
|
||||
dunce::canonicalize(&codex_dir).unwrap(),
|
||||
dunce::canonicalize(&agents_dir).unwrap(),
|
||||
dunce::canonicalize(&aws_dir).unwrap(),
|
||||
]
|
||||
.into_iter()
|
||||
.collect();
|
||||
|
||||
Reference in New Issue
Block a user