//! Negative acceptance tests. Run explicitly on a Linux host with working //! user namespaces, Bubblewrap and a systemd user manager. Only disposable //! fixture files in the repository and /tmp are created. use phoebus_executor::agent_jail::{prepare_jail, AgentJailConfig}; use std::process::Command; #[test] #[ignore = "requires real Bubblewrap user namespaces"] fn developer_jail_denies_private_files_environment_processes_and_network() { let temp = tempfile::tempdir().unwrap(); let home = temp.path().join("home"); let workspace = home.join("workspace"); std::fs::create_dir_all(home.join(".ssh")).unwrap(); std::fs::create_dir(&workspace).unwrap(); std::fs::write(home.join("private"), "synthetic credential").unwrap(); std::fs::write(home.join(".ssh/key"), "synthetic key").unwrap(); let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); let port = listener.local_addr().unwrap().port(); let script = format!( r#" import os, socket home = {home:?} ws = {workspace:?} assert 'PHOEBUS_SYNTHETIC_CREDENTIAL' not in os.environ for path in [home+'/private', home+'/.ssh/key', '/proc/{pid}/environ']: try: open(path).read() except (FileNotFoundError, PermissionError): pass else: raise AssertionError('private path readable: '+path) assert os.statvfs('/etc').f_flag & os.ST_RDONLY with open(ws+'/allowed', 'w') as f: f.write('workspace allowed') s = socket.socket() s.settimeout(1) try: s.connect(('127.0.0.1', {port})) except OSError: pass else: raise AssertionError('host network reachable') print('denials passed') "#, home = home.to_string_lossy(), workspace = workspace.to_string_lossy(), pid = std::process::id() ); let config = AgentJailConfig { workspace: workspace.clone(), allow_network: false, allow_nix_store: false, extra_masked_subdirs: vec![], }; let jail = prepare_jail(&config, &home, "/usr/bin/python3", &["-c".into(), script]).unwrap(); // Replace the reviewed pathname after preparation. The jail must bind the // original directory, never the credential directory behind the new link. let original = home.join("original-workspace"); std::fs::rename(&workspace, &original).unwrap(); std::os::unix::fs::symlink(home.join(".ssh"), &workspace).unwrap(); let out = jail .spawn_with( Command::new(phoebus_executor::agent_jail::BWRAP_PATH) .args(&jail.argv) .env("PHOEBUS_SYNTHETIC_CREDENTIAL", "synthetic") .stdout(std::process::Stdio::piped()) .stderr(std::process::Stdio::piped()), ) .unwrap() .wait_with_output() .unwrap(); assert!( out.status.success(), "{}\n{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr) ); assert_eq!( std::fs::read_to_string(original.join("allowed")).unwrap(), "workspace allowed" ); assert_eq!( std::fs::read_to_string(home.join("private")).unwrap(), "synthetic credential" ); } #[test] #[ignore = "requires real systemd user namespace hardening"] fn model_unit_denies_home_environment_processes_and_writes() { // This location is beneath the account's home in the development checkout, // so ProtectHome must hide it. No account credential is read by the probe. let root = std::env::var_os("PHOEBUS_ISOLATION_FIXTURE_ROOT") .map(std::path::PathBuf::from) .unwrap_or_else(|| { std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .ancestors() .nth(3) .unwrap() .to_path_buf() }); let fixture = tempfile::Builder::new() .prefix(".isolation-fixture-") .tempdir_in(&root) .unwrap(); let private = fixture.path().join("private"); std::fs::write(&private, "synthetic").unwrap(); let home = phoebus_executor::personal::home_for_uid(phoebus_executor::personal::effective_uid()) .unwrap(); assert!( private.starts_with(home), "acceptance fixture must be under the account home" ); let script = format!( r#" import os assert 'PHOEBUS_SYNTHETIC_CREDENTIAL' not in os.environ for path in [{private:?}, '/proc/{pid}/environ']: try: open(path).read() except (FileNotFoundError, PermissionError): pass else: raise AssertionError('private path readable: '+path) assert os.statvfs('/etc').f_flag & os.ST_RDONLY print('denials passed') "#, private = private.to_string_lossy(), pid = std::process::id() ); let args = phoebus_executor::sandbox::user_argv("/usr/bin/python3", &["-c".into(), script]); let out = Command::new("systemd-run") .args(args) .env("PHOEBUS_SYNTHETIC_CREDENTIAL", "synthetic") .output() .unwrap(); assert!( out.status.success(), "{}\n{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr) ); assert!(String::from_utf8_lossy(&out.stdout).contains("denials passed")); } #[test] #[ignore = "requires root and a real systemd system manager"] fn model_system_unit_denies_root_home_environment_and_writes() { assert_eq!( phoebus_executor::personal::effective_uid(), 0, "run this probe only as root in a disposable VM" ); let fixture = tempfile::Builder::new() .prefix(".phoebus-isolation-") .tempdir_in("/root") .unwrap(); let private = fixture.path().join("private"); std::fs::write(&private, "synthetic").unwrap(); let script = format!( r#" import os assert 'PHOEBUS_SYNTHETIC_CREDENTIAL' not in os.environ assert os.geteuid() != 0 try: open({private:?}).read() except (FileNotFoundError, PermissionError): pass else: raise AssertionError('root home readable') assert os.statvfs('/etc').f_flag & os.ST_RDONLY print('denials passed') "#, private = private.to_string_lossy() ); let args = phoebus_executor::sandbox::argv("/usr/bin/python3", &["-c".into(), script]); let out = Command::new("systemd-run") .args(args) .env("PHOEBUS_SYNTHETIC_CREDENTIAL", "synthetic") .output() .unwrap(); assert!( out.status.success(), "{}\n{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr) ); assert!(String::from_utf8_lossy(&out.stdout).contains("denials passed")); }