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,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();
|
||||
}
|
||||
Reference in New Issue
Block a user