Add gated agent update planning, preserved handoff and Linux worker ports
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -0,0 +1,158 @@
|
||||
//! Real OS adverse cases, confined to a new /run unit fixture and owned sleep
|
||||
//! child. Never calls systemctl, real install paths, RMM ledger or networking.
|
||||
use crate::{
|
||||
Budget, digest,
|
||||
files::{Directory, FileProof},
|
||||
process::HeldProcess,
|
||||
};
|
||||
use std::{
|
||||
ffi::OsStr,
|
||||
fs::{self, OpenOptions},
|
||||
io::Write,
|
||||
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt, symlink},
|
||||
path::PathBuf,
|
||||
process::{Command, Stdio},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use uuid::Uuid;
|
||||
|
||||
struct Fixture(PathBuf);
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
assert_eq!(
|
||||
unsafe { libc::geteuid() },
|
||||
0,
|
||||
"Run OS contract tests in the isolated root-owned test container, never as a host daemon"
|
||||
);
|
||||
let path = PathBuf::from(format!("/run/rmm-updater-os-unit-{}", Uuid::new_v4()));
|
||||
fs::create_dir(&path).unwrap();
|
||||
fs::set_permissions(&path, fs::Permissions::from_mode(0o700)).unwrap();
|
||||
Self(path)
|
||||
}
|
||||
fn dir(&self) -> Directory {
|
||||
Directory::open(&self.0, 0, true).unwrap()
|
||||
}
|
||||
fn file(&self, name: &str, bytes: &[u8]) {
|
||||
let mut file = OpenOptions::new()
|
||||
.create_new(true)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(self.0.join(name))
|
||||
.unwrap();
|
||||
file.write_all(bytes).unwrap();
|
||||
file.sync_all().unwrap();
|
||||
}
|
||||
}
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
fs::remove_dir_all(&self.0).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn held_file_rejects_symlink_and_replaced_name_but_preserves_bound_hardlinks() {
|
||||
let f = Fixture::new();
|
||||
f.file("original", b"original-public-fixture");
|
||||
fs::hard_link(f.0.join("original"), f.0.join("historical-alias")).unwrap();
|
||||
let dir = f.dir();
|
||||
let mut held = dir.inspect(OsStr::new("original"), 0, 1024).unwrap();
|
||||
assert_eq!(held.proof().identity.links, 2);
|
||||
let proof: FileProof = held.proof().clone();
|
||||
assert_eq!(held.bytes(1024).unwrap(), b"original-public-fixture");
|
||||
symlink("original", f.0.join("symlink")).unwrap();
|
||||
assert!(dir.inspect(OsStr::new("symlink"), 0, 1024).is_err());
|
||||
fs::rename(f.0.join("original"), f.0.join("retained")).unwrap();
|
||||
f.file("original", b"replacement");
|
||||
assert!(dir.file(OsStr::new("original"), &proof, 1024).is_err());
|
||||
assert_eq!(held.bytes(1024).unwrap(), b"original-public-fixture");
|
||||
assert_eq!(
|
||||
fs::metadata(f.0.join("retained")).unwrap().ino(),
|
||||
proof.identity.inode
|
||||
);
|
||||
assert_eq!(
|
||||
fs::read(f.0.join("historical-alias")).unwrap(),
|
||||
b"original-public-fixture"
|
||||
);
|
||||
fs::set_permissions(f.0.join("original"), fs::Permissions::from_mode(0o622)).unwrap();
|
||||
assert!(dir.inspect(OsStr::new("original"), 0, 1024).is_err());
|
||||
assert!(Directory::open(&f.0.join("symlink"), 0, true).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pidfd_image_birth_account_and_exit_are_independently_observed() {
|
||||
let image = fs::read("/usr/bin/sleep").unwrap();
|
||||
let sha = digest(&image);
|
||||
let mut child = Command::new("/usr/bin/sleep").arg("60").spawn().unwrap();
|
||||
let process = HeldProcess::open(child.id(), 0, 0, &sha).unwrap();
|
||||
process.verify().unwrap();
|
||||
assert!(!process.exited().unwrap());
|
||||
assert!(HeldProcess::open(child.id(), 1, 0, &sha).is_err());
|
||||
assert!(HeldProcess::open(child.id(), 0, 0, &"0".repeat(64)).is_err());
|
||||
let before = process.proof().clone();
|
||||
child.kill().unwrap();
|
||||
child.wait().unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
while !process.exited().unwrap() {
|
||||
assert!(Instant::now() < deadline);
|
||||
std::thread::yield_now();
|
||||
}
|
||||
assert!(process.verify().is_err());
|
||||
assert_eq!(process.proof(), &before);
|
||||
let boot = fs::read_to_string("/proc/sys/kernel/random/boot_id")
|
||||
.unwrap()
|
||||
.trim()
|
||||
.parse()
|
||||
.unwrap();
|
||||
assert!(Budget::new(Uuid::nil(), Duration::from_secs(1)).is_err());
|
||||
assert!(Budget::new(boot, Duration::from_secs(601)).is_err());
|
||||
let budget = Budget::new(boot, Duration::from_millis(100)).unwrap();
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
assert!(budget.check().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn same_pid_exec_rejects_changed_image_despite_retained_pidfd_birth_and_credentials() {
|
||||
struct ChildCleanup(std::process::Child);
|
||||
impl Drop for ChildCleanup {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.0.kill();
|
||||
let _ = self.0.wait();
|
||||
}
|
||||
}
|
||||
let old_image = fs::read("/usr/bin/bash").unwrap();
|
||||
let new_image = fs::read("/usr/bin/sleep").unwrap();
|
||||
let mut child = ChildCleanup(
|
||||
Command::new("/usr/bin/bash")
|
||||
.env_clear()
|
||||
.args(["-c", "read -r token; exec /usr/bin/sleep 60"])
|
||||
.stdin(Stdio::piped())
|
||||
.spawn()
|
||||
.unwrap(),
|
||||
);
|
||||
let held = HeldProcess::open(child.0.id(), 0, 0, &digest(&old_image)).unwrap();
|
||||
let before = held.proof().clone();
|
||||
held.verify().unwrap();
|
||||
child.0.stdin.take().unwrap().write_all(b"go\n").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(3);
|
||||
let fresh = loop {
|
||||
assert!(
|
||||
Instant::now() < deadline,
|
||||
"owned fixture child never completed exec"
|
||||
);
|
||||
match HeldProcess::open(child.0.id(), 0, 0, &digest(&new_image)) {
|
||||
Ok(process) => break process,
|
||||
Err(_) => std::thread::yield_now(),
|
||||
}
|
||||
};
|
||||
assert_eq!(fresh.proof().pid, before.pid);
|
||||
assert_eq!(fresh.proof().birth, before.birth);
|
||||
assert_eq!(
|
||||
(fresh.proof().uid, fresh.proof().gid),
|
||||
(before.uid, before.gid)
|
||||
);
|
||||
assert_ne!(fresh.proof().image_sha256, before.image_sha256);
|
||||
assert!(!held.exited().unwrap());
|
||||
assert!(held.verify().is_err());
|
||||
child.0.kill().unwrap();
|
||||
child.0.wait().unwrap();
|
||||
}
|
||||
Reference in New Issue
Block a user