feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s

This commit is contained in:
BuTzZ
2026-11-12 22:06:25 +01:00
commit 6c3203d725
194 changed files with 49234 additions and 0 deletions
+456
View File
@@ -0,0 +1,456 @@
use super::*;
use openssl::{pkey::PKey, sign::Signer};
use rmm_domain::jobs::{Action, encode};
use uuid::Uuid;
#[test]
fn actual_domain_native_action_roundtrips_exact_signed_manifest_to_helper() {
let (binding, mut request, key, now) = signed_request();
let (config, m) = manifest(true);
let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap();
let domain_manifest: rmm_domain::apt_transaction::AptExecutionManifest =
serde_json::from_value(serde_json::to_value(&m).unwrap()).unwrap();
job.action = Action::AptNativeAcceptance {
recipe_id: INSTALL_RECIPE.into(),
recipe_version: "1".into(),
apt_manifest: domain_manifest,
};
assert!(job.action.validate());
request.job_bytes = encode(&job).unwrap();
let mut permit: ExecutionPermitPayload = serde_json::from_slice(&request.permit_bytes).unwrap();
permit.action = "apt_native_acceptance".into();
permit.job_payload_hash = hash(&request.job_bytes);
request.permit_bytes = encode(&permit).unwrap();
request.signature = Signer::new_without_digest(&key)
.unwrap()
.sign_oneshot_to_vec(&request.permit_bytes)
.unwrap();
let (verified, _) = binding.verify(&request, now).unwrap();
policy_header(&verified, &config).unwrap();
let parsed = validate_signed_manifest(&verified, &request.job_bytes, &config).unwrap();
assert_eq!(parsed.transaction_bytes, m.transaction_bytes);
assert_eq!(parsed.transaction_sha256, m.transaction_sha256);
// No unsafe root execution in this test: trusted deployment is absent.
assert!(prepare(&binding, &request, &config, now).is_err());
let mut aliased: serde_json::Value = serde_json::from_slice(&request.job_bytes).unwrap();
aliased["action"]["parameters"] = serde_json::json!({"apt_manifest":m});
request.job_bytes = serde_json::to_vec(&aliased).unwrap();
assert!(binding.verify(&request, now).is_err());
}
#[test]
fn prefetch_receipt_must_precede_grant_and_match_exact_archive() {
let (_, m) = manifest(true);
let package = &m.resolved_apt_transaction.packages[0];
let receipt = PrefetchReceipt {
schema_version: 1,
sha256: package.sha256.clone(),
size: package.size,
sealed_at_ms: 1000,
};
receipt.validate(package, 1000).unwrap();
assert!(receipt.validate(package, 999).is_err());
let changed = PackageArchive {
size: 1,
..package.clone()
};
assert!(receipt.validate(&changed, 1001).is_err());
let changed = PackageArchive {
sha256: "0".repeat(64),
..package.clone()
};
assert!(receipt.validate(&changed, 1001).is_err());
assert!(serde_json::from_slice::<PrefetchReceipt>(br#"{"schema_version":1,"sha256":"x","size":1,"sealed_at_ms":1000,"download_url":"https://untrusted.invalid"}"#).is_err());
}
#[test]
fn consumed_parent_row_and_original_start_request_are_mandatory() {
let (binding, request, _, now) = signed_request();
let (job, permit) = binding.verify(&request, now).unwrap();
// Test-only construction exercises the ledger validator without granting
// access to the root process path or weakening the public constructor.
let prepared = PreparedApt {
job,
permit: permit.clone(),
request: request.clone(),
manifest: manifest(true).1,
};
let dir = temporary();
// SAFETY: geteuid has no preconditions or pointers.
let uid = unsafe { libc::geteuid() };
let mut db = crate::open_ledger(&dir, uid).unwrap();
assert!(prepared.verify_parent_consumption(&db).is_err());
crate::consume(&mut db, &permit).unwrap();
assert!(prepared.verify_parent_consumption(&db).is_err());
crate::save_start(&db, &permit, &request).unwrap();
assert!(
prepared
.verify_parent_consumption(&db)
.unwrap()
.starts_with("apt-")
);
let mut forged = prepared;
forged.request.job_bytes.push(b' ');
assert!(forged.verify_parent_consumption(&db).is_err());
forged.request = request;
let mut outcome = Outcome::unknown("");
outcome.state = "succeeded".into();
crate::finish(&db, &permit, &outcome).unwrap();
assert!(forged.verify_parent_consumption(&db).is_err());
drop(db);
fs::remove_dir_all(dir).unwrap();
}
fn manifest(bootstrap: bool) -> (ProviderConfig, AptExecutionManifest) {
let transaction = ResolvedAptTransaction {
schema_version: 1,
recipe_id: INSTALL_RECIPE.into(),
recipe_version: "1".into(),
platform: "ubuntu-24.04-amd64".into(),
resolver_config_version: "rmm-apt-local-v1".into(),
no_reboot: true,
status_fingerprint: "a".repeat(64),
baseline_sha256: hash(b"{}"),
packages: vec![PackageArchive {
name: "rmm-mvp-test".into(),
architecture: "all".into(),
old_version: None,
new_version: "1.0".into(),
origin: "rmm-test".into(),
sha256: INSTALL_SHA.into(),
size: 20672,
archive_path: format!("{BASE}/archives/{INSTALL_SHA}.deb"),
}],
};
let bytes = serde_json::to_vec(&transaction).unwrap();
let config = ProviderConfig {
schema_version: 1,
execution_profile: "dev-test".into(),
allow_fixture_bootstrap: true,
allowed_recipes: vec![INSTALL_RECIPE.into(), UPDATE_RECIPE.into()],
runtime_sha256: "d".repeat(64),
apt_config_sha256: "e".repeat(64),
};
let manifest = AptExecutionManifest {
kind: "rmm.apt.helper-action".into(),
schema_version: 2,
action: if bootstrap {
"apt-native-acceptance"
} else {
"apt-execute"
}
.into(),
execution_profile: "dev-test".into(),
transaction_sha256: hash(&bytes),
resolved_apt_transaction: transaction,
transaction_bytes: bytes,
provider_sha256: hash(PYTHON),
hook_sha256: hash(HOOK_BYTES),
apt_config_sha256: config.apt_config_sha256.clone(),
runtime_sha256: config.runtime_sha256.clone(),
test_result_id: "fixture-test-1".into(),
};
(config, manifest)
}
fn temporary() -> PathBuf {
let dir = Path::new("/tmp/opencode").join(format!("apt-helper-{}", Uuid::new_v4()));
fs::DirBuilder::new().mode(0o700).create(&dir).unwrap();
dir
}
fn signed_request() -> (
Binding,
Request,
PKey<openssl::pkey::Private>,
DateTime<Utc>,
) {
let key = PKey::generate_ed25519().unwrap();
let raw = key.raw_public_key().unwrap();
let now = Utc::now();
let binding = Binding {
tenant_id: Uuid::new_v4(),
asset_id: Uuid::new_v4(),
agent_id: Uuid::new_v4(),
enrollment_generation: 1,
assignment_version: 1,
public_key_hex: hex::encode(&raw),
};
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: 1,
job_id: Uuid::new_v4(),
attempt_id: Uuid::new_v4(),
// Existing supported typed action supplies a valid cryptographic/ledger
// fixture only. It is never executed and the APT policy rejects it.
action: Action::RunScript {
interpreter: "posix_sh".into(),
script_utf8: "true".into(),
arguments: vec![],
expected_stdout: None,
},
execution_identity: "root".into(),
not_before: now - chrono::Duration::seconds(1),
start_before: now + chrono::Duration::seconds(59),
max_runtime_seconds: 300,
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: 1,
assignment_version: 1,
job_id: job.job_id,
attempt_id: job.attempt_id,
plan_hash: hash(b"approved fixture plan"),
job_payload_hash: hash(&bytes),
action: "run_script".into(),
execution_identity: "root".into(),
not_before: job.not_before,
start_before: job.start_before,
max_runtime_seconds: 300,
key_id: hash(&raw),
};
let permit_bytes = encode(&permit).unwrap();
let signature = Signer::new_without_digest(&key)
.unwrap()
.sign_oneshot_to_vec(&permit_bytes)
.unwrap();
(
binding,
Request {
job_bytes: bytes,
permit_bytes,
signature,
plan_hash: permit.plan_hash,
authorization_id: permit.authorization_id,
},
key,
now,
)
}
#[test]
fn narrow_manifest_exact_bytes_and_code_pins() {
let (config, m) = manifest(true);
validate_manifest(&m, "apt_native_acceptance", &config).unwrap();
for field in [
"provider_sha256",
"hook_sha256",
"runtime_sha256",
"transaction_sha256",
"apt_config_sha256",
] {
let mut v = serde_json::to_value(&m).unwrap();
v[field] = serde_json::json!("0".repeat(64));
let changed: AptExecutionManifest = serde_json::from_value(v).unwrap();
assert!(
validate_manifest(&changed, "apt_native_acceptance", &config).is_err(),
"{field}"
);
}
let mut changed = m.clone();
changed.transaction_bytes.push(b' ');
assert!(validate_manifest(&changed, "apt_native_acceptance", &config).is_err());
changed.transaction_sha256 = hash(&changed.transaction_bytes);
validate_manifest(&changed, "apt_native_acceptance", &config).unwrap(); // exact approved whitespace is retained
changed.resolved_apt_transaction.packages[0].new_version = "1.1".into();
assert!(validate_manifest(&changed, "apt_native_acceptance", &config).is_err());
}
#[test]
fn bootstrap_is_not_normal_script_or_production_and_recipe_is_local_policy() {
let (mut config, m) = manifest(true);
for action in ["run_script", "ensure_package", "apply_updates"] {
assert!(validate_manifest(&m, action, &config).is_err());
}
config.allow_fixture_bootstrap = false;
assert!(validate_manifest(&m, "apt_native_acceptance", &config).is_err());
config.allow_fixture_bootstrap = true;
config.execution_profile = "production".into();
assert!(config.validate().is_err());
config.execution_profile = "dev-test".into();
config.allowed_recipes = vec![UPDATE_RECIPE.into()];
assert!(validate_manifest(&m, "apt_native_acceptance", &config).is_err());
let mut changed = m.clone();
changed
.resolved_apt_transaction
.packages
.push(changed.resolved_apt_transaction.packages[0].clone());
assert!(changed.resolved_apt_transaction.validate_fixture().is_err());
}
#[test]
fn duplicate_fields_aliases_and_unsigned_additions_never_authorize() {
let (binding, request, _, now) = signed_request();
let (config, _) = manifest(false);
let (job, _) = binding.verify(&request, now).unwrap();
assert!(
validate_signed_manifest(&job, &request.job_bytes, &config)
.unwrap_err()
.to_string()
.contains("APT_MANIFEST_NOT_CONFIGURED")
);
let mut forged = request.clone();
forged.signature[0] ^= 1;
assert!(prepare(&binding, &forged, &config, now).is_err());
forged = request.clone();
let mut v: serde_json::Value = serde_json::from_slice(&forged.job_bytes).unwrap();
v["action"]["apt_manifest"] = serde_json::to_value(manifest(false).1).unwrap();
forged.job_bytes = serde_json::to_vec(&v).unwrap();
assert!(prepare(&binding, &forged, &config, now).is_err()); // old signed permit cannot bind any extra field
let raw = br#"{"action":"apply_updates","apt_manifest":null,"apt_manifest":null}"#;
assert!(serde_json::from_slice::<ActionCarrier>(raw).is_err());
let mut m = serde_json::to_value(manifest(false).1).unwrap();
m["parameters"] = serde_json::json!({});
assert!(serde_json::from_value::<AptExecutionManifest>(m).is_err());
}
#[test]
fn create_only_payloads_fsync_and_hostile_files_fail_closed() {
let dir = temporary();
let file = dir.join("payload");
write_once(&file, b"known", 0o600).unwrap();
assert_eq!(fs::read(&file).unwrap(), b"known");
assert!(write_once(&file, b"replacement", 0o600).is_err());
let link = dir.join("link");
std::os::unix::fs::symlink(&file, &link).unwrap();
assert!(write_once(&link, b"replacement", 0o600).is_err());
assert!(read_sealed(&file, 64).is_err()); // never accept this unprivileged /tmp store as root trusted
assert!(verify_installation().is_err()); // no deployment/mutation during tests
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn no_artifact_or_record_is_not_success() {
let (_, m) = manifest(true);
let (binding, request, _, now) = signed_request();
let (_, p) = binding.verify(&request, now).unwrap();
assert!(verify_prefetched(&m, &p).is_err());
assert!(
map_driver_result(
br#"{"effect_state":"verified","code":"POSTCONDITIONS_VERIFIED","evidence":{}}"#,
Some(0),
false,
&m,
"ledger"
)
.is_err()
);
assert!(map_driver_result(b"not-json", Some(0), false, &m, "ledger").is_err());
}
#[test]
fn structured_effect_state_not_process_exit_and_armed_failures_stay_unknown() {
let (_, m) = manifest(true);
let ledger = "ledger-1";
let p = &m.resolved_apt_transaction.packages[0];
let result = serde_json::json!({"effect_state":"verified","code":"POSTCONDITIONS_VERIFIED","evidence":{
"test_acceptance":true,"noProductionEvidence":true,"test_result_id":m.test_result_id,"native_record_sha256":"a".repeat(64),
"snapshot_sha256":"b".repeat(64),"fixture_payload_sha256":hash(b"1.0\n"),"effect_armed_ledger_id":ledger,"reboot_required":false,
"packages":[{"name":p.name,"architecture":p.architecture,"version":p.new_version}]}});
let bytes = serde_json::to_vec(&result).unwrap();
assert_eq!(
map_driver_result(&bytes, Some(0), true, &m, ledger)
.unwrap()
.state,
"succeeded"
);
assert!(map_driver_result(&bytes, Some(1), true, &m, ledger).is_err());
assert!(map_driver_result(&bytes, Some(0), true, &m, "wrong").is_err());
let failed = serde_json::json!({"effect_state":"known_failed","code":"START_DEADLINE","evidence":{"test_acceptance":true,"noProductionEvidence":true}});
let bytes = serde_json::to_vec(&failed).unwrap();
assert_eq!(
map_driver_result(&bytes, Some(0), false, &m, ledger)
.unwrap()
.state,
"failed"
);
assert_eq!(
map_driver_result(&bytes, Some(0), true, &m, ledger)
.unwrap()
.state,
"unknown"
);
}
#[test]
fn mapped_unknown_keeps_parent_resource_reservation() {
let (binding, request, _, now) = signed_request();
let (_, p) = binding.verify(&request, now).unwrap();
let dir = temporary();
let uid = unsafe { libc::geteuid() };
let mut db = crate::open_ledger(&dir, uid).unwrap();
crate::consume(&mut db, &p).unwrap();
crate::save_start(&db, &p, &request).unwrap();
let (_, m) = manifest(false);
let result = map_driver_result(
br#"{"effect_state":"unknown","code":"EFFECT_UNCERTAIN","evidence":{}}"#,
Some(0),
true,
&m,
"ledger",
)
.unwrap();
crate::finish(&db, &p, &result).unwrap();
let mut next = p.clone();
next.grant_id = Uuid::new_v4();
next.job_id = Uuid::new_v4();
assert!(crate::consume(&mut db, &next).is_err());
drop(db);
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn verified_no_change_is_bound_not_bootstrap_and_consumes_attempt_once() {
let (_, m) = manifest(false);
let ledger = "ledger-noop";
let p = &m.resolved_apt_transaction.packages[0];
let result = serde_json::json!({"effect_state":"verified_no_change","code":"POSTCONDITION_ALREADY_MET","evidence":{
"changed":false,"already_desired":true,"postcondition_already_met":true,"transaction_executed":false,
"snapshot_sha256":m.resolved_apt_transaction.baseline_sha256,"effect_armed_ledger_id":ledger,
"fixture_payload_sha256":hash(format!("{}\n",p.new_version).as_bytes()),"reboot_required":false,
"packages":[{"name":p.name,"architecture":p.architecture,"version":p.new_version}]}});
let bytes = serde_json::to_vec(&result).unwrap();
let outcome = map_driver_result(&bytes, Some(0), false, &m, ledger).unwrap();
assert_eq!(outcome.state, "succeeded");
assert_eq!(outcome.evidence["apt"]["changed"], false);
assert!(map_driver_result(&bytes, Some(0), true, &m, ledger).is_err());
assert!(map_driver_result(&bytes, Some(0), false, &m, "other-ledger").is_err());
assert!(map_driver_result(&bytes, Some(0), false, &manifest(true).1, ledger).is_err());
for (field, value) in [
("changed", serde_json::json!(true)),
("transaction_executed", serde_json::json!(true)),
("snapshot_sha256", serde_json::json!("0".repeat(64))),
("packages", serde_json::json!([])),
] {
let mut bad = result.clone();
bad["evidence"][field] = value;
assert!(
map_driver_result(
&serde_json::to_vec(&bad).unwrap(),
Some(0),
false,
&m,
ledger
)
.is_err()
);
}
let (binding, request, _, now) = signed_request();
let (_, permit) = binding.verify(&request, now).unwrap();
let dir = temporary();
// SAFETY: geteuid has no preconditions.
let mut db = crate::open_ledger(&dir, unsafe { libc::geteuid() }).unwrap();
crate::consume(&mut db, &permit).unwrap();
crate::save_start(&db, &permit, &request).unwrap();
crate::finish(&db, &permit, &outcome).unwrap();
assert!(crate::consume(&mut db, &permit).is_err());
let mut another_grant = permit.clone();
another_grant.grant_id = Uuid::new_v4();
assert!(crate::consume(&mut db, &another_grant).is_err());
drop(db);
fs::remove_dir_all(dir).unwrap();
}