Files
rust-discovery/crates/privileged-helper/src/tests.rs
T
2026-11-16 15:44:48 +01:00

507 lines
19 KiB
Rust

use super::*;
use openssl::sign::Signer;
use rmm_domain::jobs::{Action, encode};
#[test]
fn startup_lock_waits_only_for_original_executor_and_times_out_without_effects() {
use std::io::{BufRead, Write};
use std::os::unix::fs::PermissionsExt;
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
const TEST: &str =
"tests::startup_lock_waits_only_for_original_executor_and_times_out_without_effects";
let uid = unsafe { libc::geteuid() };
if let Ok(path) = std::env::var("RMM_STARTUP_LOCK_CONTRACT_PATH") {
let mode = std::env::var("RMM_STARTUP_LOCK_CONTRACT_MODE").unwrap();
println!("STARTUP_LOCK_CHILD_ATTEMPT");
std::io::stdout().flush().unwrap();
let started = Instant::now();
let result = startup_lock_state(Path::new(&path), uid);
match mode.as_str() {
"release" => {
let held = result.unwrap();
assert!(started.elapsed() >= Duration::from_millis(150));
assert!(started.elapsed() < Duration::from_secs(5));
assert_eq!(
held.metadata().unwrap().ino(),
fs::symlink_metadata(Path::new(&path).join("executor.lock"))
.unwrap()
.ino()
);
}
"timeout" => {
assert_eq!(
result.unwrap_err().to_string(),
"HELPER_STARTUP_EXECUTOR_LOCK_TIMEOUT"
);
assert!(started.elapsed() >= Duration::from_secs(5));
assert!(started.elapsed() < Duration::from_secs(7));
}
_ => panic!("closed contract mode"),
}
return;
}
let path = std::env::temp_dir().join(format!("rmm-startup-lock-contract-{}", Uuid::new_v4()));
fs::create_dir(&path).unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o700)).unwrap();
for mode in ["release", "timeout"] {
let original = lock_state(&path, uid).unwrap();
let metadata = original.metadata().unwrap();
let mut child = Command::new(std::env::current_exe().unwrap())
.args(["--exact", TEST, "--nocapture", "--test-threads=1"])
.env("RMM_STARTUP_LOCK_CONTRACT_PATH", &path)
.env("RMM_STARTUP_LOCK_CONTRACT_MODE", mode)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.unwrap();
let mut reader = std::io::BufReader::new(child.stdout.take().unwrap());
loop {
let mut line = String::new();
assert!(reader.read_line(&mut line).unwrap() > 0);
if line.contains("STARTUP_LOCK_CHILD_ATTEMPT") {
break;
}
}
std::thread::sleep(Duration::from_millis(200));
if mode == "release" {
drop(original);
}
let result = child.wait_with_output().unwrap();
assert!(
result.status.success(),
"native child contract failed: {}",
String::from_utf8_lossy(&result.stderr)
);
let after = fs::symlink_metadata(path.join("executor.lock")).unwrap();
assert_eq!(
(after.dev(), after.ino(), after.len()),
(metadata.dev(), metadata.ino(), 0)
);
assert_eq!(fs::read_dir(&path).unwrap().count(), 1);
}
fs::remove_file(path.join("executor.lock")).unwrap();
fs::remove_dir(path).unwrap();
}
fn fixture() -> (
Binding,
Request,
openssl::pkey::PKey<openssl::pkey::Private>,
DateTime<Utc>,
) {
let key = PKey::generate_ed25519().unwrap();
let public = key.raw_public_key().unwrap();
let now = DateTime::from_timestamp(1_800_000_000, 0).unwrap();
let binding = Binding {
tenant_id: Uuid::new_v4(),
asset_id: Uuid::new_v4(),
agent_id: Uuid::new_v4(),
enrollment_generation: 1,
assignment_version: 3,
public_key_hex: hex::encode(&public),
};
let job = JobPayload {
schema_version: 1,
tenant_id: binding.tenant_id,
asset_id: binding.asset_id,
agent_id: binding.agent_id,
enrollment_generation: 1,
assignment_version: 3,
job_id: Uuid::new_v4(),
attempt_id: Uuid::new_v4(),
action: Action::RunScript {
interpreter: "posix_sh".into(),
script_utf8: "printf 'Hello World\\n'".into(),
arguments: vec![],
expected_stdout: Some("Hello World\n".into()),
windows_execution_profile: None,
privileged_script_profile: None,
},
execution_identity: "agent_service".into(),
not_before: now - chrono::Duration::seconds(60),
start_before: now + chrono::Duration::seconds(300),
max_runtime_seconds: 2,
max_output_bytes: 4096,
};
let bytes = encode(&job).unwrap();
let permit = ExecutionPermitPayload {
agent_update_plan_id: None,
domain: "rmm.execution-permit".into(),
schema_version: 1,
grant_id: Uuid::new_v4(),
authorization_id: Uuid::new_v4(),
tenant_id: job.tenant_id,
asset_id: job.asset_id,
agent_id: job.agent_id,
enrollment_generation: job.enrollment_generation,
assignment_version: job.assignment_version,
job_id: job.job_id,
attempt_id: job.attempt_id,
plan_hash: hash(b"immutable approved plan"),
job_payload_hash: hash(&bytes),
action: "run_script".into(),
execution_identity: job.execution_identity.clone(),
not_before: now - chrono::Duration::seconds(1),
start_before: now + chrono::Duration::seconds(59),
max_runtime_seconds: 2,
key_id: hash(&public),
};
let mut request = Request {
job_bytes: bytes,
permit_bytes: encode(&permit).unwrap(),
signature: vec![],
plan_hash: permit.plan_hash.clone(),
authorization_id: permit.authorization_id,
};
sign(&mut request, &key);
(binding, request, key, now)
}
fn sign(request: &mut Request, key: &openssl::pkey::PKey<openssl::pkey::Private>) {
request.signature = Signer::new_without_digest(key)
.unwrap()
.sign_oneshot_to_vec(&request.permit_bytes)
.unwrap();
}
fn directory() -> std::path::PathBuf {
use std::os::unix::fs::DirBuilderExt;
let path = std::env::temp_dir().join(format!("rmm-ledger-test-{}", Uuid::new_v4()));
fs::DirBuilder::new().mode(0o700).create(&path).unwrap();
path
}
#[test]
fn journal_capacity_is_finite_and_retains_original_consumption_on_reopen() {
let dir = directory();
let uid = unsafe { libc::geteuid() };
let mut db = open_ledger(&dir, uid).unwrap();
let (binding, request, _, now) = fixture();
let (_, permit) = binding.verify(&request, now).unwrap();
consume(&mut db, &permit).unwrap();
save_start(&db, &permit, &request).unwrap();
let original: Vec<u8> = db
.query_row("SELECT start FROM execution_evidence", [], |r| r.get(0))
.unwrap();
db.execute_batch("PRAGMA max_page_count=65536").unwrap();
drop(db);
let mut db = open_ledger(&dir, uid).unwrap();
assert_eq!(
db.query_row("PRAGMA page_size", [], |r| r.get::<_, u32>(0))
.unwrap(),
4096
);
assert_eq!(
db.query_row("PRAGMA max_page_count", [], |r| r.get::<_, u32>(0))
.unwrap(),
262144
);
let preserved: (String, Option<Vec<u8>>, Vec<u8>) = db.query_row("SELECT c.grant_id,c.result,e.start FROM consumed c JOIN execution_evidence e USING(grant_id)", [], |r|Ok((r.get(0)?,r.get(1)?,r.get(2)?))).unwrap();
assert_eq!(preserved, (permit.grant_id.to_string(), None, original));
assert!(consume(&mut db, &permit).is_err());
drop(db);
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn journal_capacity_rejects_unexpected_page_size_without_rewriting_history() {
let dir = directory();
let db = rusqlite::Connection::open(dir.join("odd.sqlite")).unwrap();
db.execute_batch("PRAGMA page_size=8192;CREATE TABLE witness(value TEXT);INSERT INTO witness VALUES('retained');").unwrap();
assert!(bounded_journal_capacity(&db).is_err());
assert_eq!(
db.query_row("PRAGMA page_size", [], |r| r.get::<_, u32>(0))
.unwrap(),
8192
);
assert_eq!(
db.query_row("SELECT value FROM witness", [], |r| r.get::<_, String>(0))
.unwrap(),
"retained"
);
drop(db);
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn exact_signature_and_every_permit_binding() {
let (binding, request, key, now) = fixture();
assert!(binding.verify(&request, now).is_ok());
let original: serde_json::Value = serde_json::from_slice(&request.permit_bytes).unwrap();
for (field, replacement) in [
("domain", serde_json::json!("other")),
("schema_version", serde_json::json!(2)),
("grant_id", serde_json::json!(Uuid::nil())),
("authorization_id", serde_json::json!(Uuid::new_v4())),
("tenant_id", serde_json::json!(Uuid::new_v4())),
("asset_id", serde_json::json!(Uuid::new_v4())),
("agent_id", serde_json::json!(Uuid::new_v4())),
("enrollment_generation", serde_json::json!(2)),
("assignment_version", serde_json::json!(4)),
("job_id", serde_json::json!(Uuid::new_v4())),
("attempt_id", serde_json::json!(Uuid::new_v4())),
("plan_hash", serde_json::json!(hash(b"other"))),
("job_payload_hash", serde_json::json!(hash(b"other"))),
("action", serde_json::json!("reboot")),
("execution_identity", serde_json::json!("root")),
("max_runtime_seconds", serde_json::json!(3)),
("key_id", serde_json::json!(hash(b"other"))),
(
"not_before",
serde_json::json!(now + chrono::Duration::seconds(1)),
),
(
"start_before",
serde_json::json!(now + chrono::Duration::seconds(61)),
),
] {
let mut modified = original.clone();
modified[field] = replacement;
let mut candidate = request.clone();
candidate.permit_bytes = serde_json::to_vec(&modified).unwrap();
sign(&mut candidate, &key);
assert!(
binding.verify(&candidate, now).is_err(),
"missing binding: {field}"
);
}
let mut forged = request.clone();
forged.signature[0] ^= 1;
assert!(binding.verify(&forged, now).is_err());
let mut tampered = request.clone();
tampered.job_bytes.push(b' ');
assert!(binding.verify(&tampered, now).is_err());
let mut bad_parameters = request.clone();
let mut job: JobPayload = serde_json::from_slice(&bad_parameters.job_bytes).unwrap();
job.action = Action::Reboot {
reason: "different effect".into(),
reconnect_timeout_seconds: 60,
dependency_group: "test".into(),
};
bad_parameters.job_bytes = encode(&job).unwrap();
assert!(binding.verify(&bad_parameters, now).is_err());
assert!(
binding
.verify(&request, now + chrono::Duration::seconds(59))
.is_err()
);
assert!(
binding
.verify(&request, now - chrono::Duration::seconds(2))
.is_err()
);
let mut wrong_trust = binding.clone();
wrong_trust.public_key_hex =
hex::encode(PKey::generate_ed25519().unwrap().raw_public_key().unwrap());
assert!(wrong_trust.verify(&request, now).is_err());
}
#[test]
fn independent_identity_binding_all_fields() {
let (binding, request, _, now) = fixture();
for field in [
"tenant_id",
"asset_id",
"agent_id",
"enrollment_generation",
"assignment_version",
] {
let mut value = serde_json::to_value(&binding).unwrap();
value[field] = if field.ends_with("id") {
serde_json::json!(Uuid::new_v4())
} else {
serde_json::json!(99)
};
let wrong: Binding = serde_json::from_value(value).unwrap();
assert!(wrong.verify(&request, now).is_err(), "{field}");
}
}
#[test]
fn reopen_consumption_duplicate_grant_attempt_unknown_and_resource_lock() {
let (binding, request, _, now) = fixture();
let (_, permit) = binding.verify(&request, now).unwrap();
let path = directory();
// SAFETY: geteuid has no preconditions.
let uid = unsafe { libc::geteuid() };
let lock = lock_state(&path, uid).unwrap();
assert!(lock_state(&path, uid).is_err());
let mut db = open_ledger(&path, uid).unwrap();
begin_execution(&mut db, &permit, &request).unwrap();
drop(db);
let mut db = open_ledger(&path, uid).unwrap();
assert!(consume(&mut db, &permit).is_err());
let mut replacement = permit.clone();
replacement.grant_id = Uuid::new_v4();
assert!(consume(&mut db, &replacement).is_err());
finish(&db, &permit, &Outcome::unknown("crash_after_effect")).unwrap();
replacement.job_id = Uuid::new_v4();
replacement.attempt_id = Uuid::new_v4();
assert!(consume(&mut db, &replacement).is_err());
// A contradictory completion cannot overwrite original unknown evidence.
let mut definitive = Outcome::unknown("");
definitive.state = "succeeded".into();
assert!(finish(&db, &permit, &definitive).is_err());
assert!(consume(&mut db, &permit).is_err());
replacement.job_id = permit.job_id;
replacement.attempt_id = permit.attempt_id;
assert!(consume(&mut db, &replacement).is_err());
replacement.job_id = Uuid::new_v4();
replacement.attempt_id = Uuid::new_v4();
assert!(consume(&mut db, &replacement).is_err());
assert_eq!(
db.query_row::<u32, _, _>(
"SELECT count(*) FROM consumed WHERE result IS NULL",
[],
|r| r.get(0)
)
.unwrap(),
1
);
drop(db);
drop(lock);
fs::remove_dir_all(path).unwrap();
}
#[test]
fn harmless_exact_script_with_bound_output() {
let (binding, request, _, now) = fixture();
let (job, _) = binding.verify(&request, now).unwrap();
let result = script(&job).unwrap();
assert_eq!(result.state, "succeeded");
assert_eq!(result.stdout, b"Hello World\n");
assert_eq!(result.exit_code, Some(0));
}
#[test]
fn unsafe_paths_and_corrupt_ledger_fail_closed() {
use std::os::unix::fs::{PermissionsExt, symlink};
let path = directory();
let uid = unsafe { libc::geteuid() };
let db = open_ledger(&path, uid).unwrap();
drop(db);
fs::write(path.join("consumption.sqlite"), b"corrupt db").unwrap();
assert!(open_ledger(&path, uid).is_err());
fs::remove_file(path.join("consumption.sqlite")).unwrap();
symlink("/dev/null", path.join("consumption.sqlite")).unwrap();
assert!(open_ledger(&path, uid).is_err());
fs::set_permissions(&path, fs::Permissions::from_mode(0o777)).unwrap();
assert!(lock_state(&path, uid).is_err());
fs::remove_dir_all(path).unwrap();
}
#[test]
fn wall_clock_jump_is_not_mistaken_for_a_fresh_online_grant() {
let clock = TrustedClock {
wall: Utc::now() + chrono::Duration::minutes(1),
monotonic: std::time::Instant::now(),
};
assert!(!clock.trusted());
let clock = TrustedClock {
wall: Utc::now() - chrono::Duration::minutes(1),
monotonic: std::time::Instant::now(),
};
assert!(!clock.trusted());
}
#[test]
fn two_helper_connections_share_exact_lock_and_sqlite_consumption() {
let (binding, request, _, now) = fixture();
let (_, permit) = binding.verify(&request, now).unwrap();
let path = directory();
// SAFETY: geteuid has no preconditions.
let uid = unsafe { libc::geteuid() };
let first = lock_state(&path, uid).unwrap();
let inode = (
first.metadata().unwrap().dev(),
first.metadata().unwrap().ino(),
);
assert!(lock_state(&path, uid).is_err());
drop(first);
let second = lock_state(&path, uid).unwrap();
assert_eq!(
inode,
(
second.metadata().unwrap().dev(),
second.metadata().unwrap().ino()
)
);
let mut general = open_ledger(&path, uid).unwrap();
let mut apt = open_ledger(&path, uid).unwrap();
begin_execution(&mut general, &permit, &request).unwrap();
assert!(consume(&mut apt, &permit).is_err());
let mut other = permit.clone();
other.grant_id = Uuid::new_v4();
other.job_id = Uuid::new_v4();
other.attempt_id = Uuid::new_v4();
assert!(consume(&mut apt, &other).is_err());
finish(
&general,
&permit,
&Outcome::unknown("shared unknown effect"),
)
.unwrap();
assert!(consume(&mut apt, &other).is_err());
let filename: String = apt
.query_row(
"SELECT file FROM pragma_database_list WHERE name='main'",
[],
|r| r.get(0),
)
.unwrap();
assert_eq!(
fs::metadata(filename).unwrap().ino(),
fs::metadata(path.join("consumption.sqlite")).unwrap().ino()
);
drop(general);
drop(apt);
drop(second);
fs::remove_dir_all(path).unwrap();
}
#[test]
fn awaiting_reboot_preserves_original_boot_and_outcome_across_reopen() {
let (binding, mut request, key, now) = fixture();
let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap();
job.action = Action::Reboot {
reason: "mock reboot; no native effect".into(),
reconnect_timeout_seconds: 60,
dependency_group: "test".into(),
};
request.job_bytes = encode(&job).unwrap();
let mut payload: ExecutionPermitPayload =
serde_json::from_slice(&request.permit_bytes).unwrap();
payload.action = "reboot".into();
payload.job_payload_hash = hash(&request.job_bytes);
request.permit_bytes = encode(&payload).unwrap();
sign(&mut request, &key);
let (_, permit) = binding.verify(&request, now).unwrap();
let path = directory();
let uid = unsafe { libc::geteuid() };
let mut db = open_ledger(&path, uid).unwrap();
consume(&mut db, &permit).unwrap();
save_start(&db, &permit, &request).unwrap();
let mut outcome = Outcome::unknown("REAUTHENTICATION_REQUIRED");
outcome.state = "awaiting_reboot".into();
finish(&db, &permit, &outcome).unwrap();
drop(db);
let mut db = open_ledger(&path, uid).unwrap();
let (start, outcome): (Vec<u8>, Vec<u8>) = db
.query_row(
"SELECT start,outcome FROM execution_evidence WHERE grant_id=?1",
[permit.grant_id.to_string()],
|r| Ok((r.get(0)?, r.get(1)?)),
)
.unwrap();
let start: serde_json::Value = serde_json::from_slice(&start).unwrap();
assert_eq!(
start["previous_boot_id"],
rmm_agent_linux::boot_id().unwrap()
);
assert_eq!(start["reauthentication_required"], true);
assert!(start["reconnect_deadline"].is_string());
assert_eq!(
serde_json::from_slice::<Outcome>(&outcome).unwrap().state,
"awaiting_reboot"
);
let mut other = permit.clone();
other.grant_id = Uuid::new_v4();
other.job_id = Uuid::new_v4();
assert!(consume(&mut db, &other).is_err());
drop(db);
fs::remove_dir_all(path).unwrap();
}