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, DateTime, ) { 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) { 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 = 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) = 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::( "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, Vec) = 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).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(); }