425 lines
16 KiB
Rust
425 lines
16 KiB
Rust
use super::*;
|
|
use openssl::sign::Signer;
|
|
use rmm_domain::jobs::{Action, encode};
|
|
|
|
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();
|
|
}
|