feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
@@ -0,0 +1,361 @@
|
||||
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()),
|
||||
},
|
||||
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 {
|
||||
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 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();
|
||||
consume(&mut db, &permit).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());
|
||||
// Only definitive evidence releases the resource, not an ACK or new grant.
|
||||
let mut definitive = Outcome::unknown("");
|
||||
definitive.state = "succeeded".into();
|
||||
finish(&db, &permit, &definitive).unwrap();
|
||||
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();
|
||||
consume(&mut db, &replacement).unwrap();
|
||||
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();
|
||||
consume(&mut general, &permit).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();
|
||||
}
|
||||
Reference in New Issue
Block a user