use super::*; use openssl::{pkey::PKey, sign::Signer}; use rmm_domain::jobs::{Action, encode}; use uuid::Uuid; #[test] fn configure_only_is_explicit_native_recovery_and_never_install_acceptance() { let (config, mut m) = manifest(true); m.schema_version = 4; m.native_recovery = Some(rmm_domain::apt_transaction::AptNativeRecovery { schema_version: 1, previous_grant_id: Uuid::new_v4(), previous_attempt_id: Uuid::new_v4(), partial_proof_sha256: hash(b"partial"), }); m.resolved_apt_transaction.schema_version = 2; m.resolved_apt_transaction.operation = Some(rmm_domain::apt_transaction::AptTransactionOperation::ConfigureOnly); m.resolved_apt_transaction.packages[0].old_version = Some("1.0".into()); m.transaction_bytes = serde_json::to_vec(&m.resolved_apt_transaction).unwrap(); m.transaction_sha256 = hash(&m.transaction_bytes); validate_manifest(&m, "apt_native_acceptance", &config).unwrap(); assert!(validate_manifest(&m, "ensure_package", &config).is_err()); let mut evidence = serde_json::json!({"test_acceptance":true,"noProductionEvidence":true,"native_recovery":true,"recovery_record_sha256":hash(b"recovery record"),"partial_proof_sha256":hash(b"partial"),"test_result_id":m.test_result_id,"effect_armed_ledger_id":"ledger","packages":[{"name":"rmm-mvp-test","architecture":"all","version":"1.0"}],"snapshot_sha256":hash(b"snapshot"),"fixture_payload_sha256":hash(b"1.0\n"),"reboot_required":false,"host_reboot_required_before":false,"host_reboot_required_after":false,"reboot_required_introduced":false,"host_reboot_before_sha256":"e".repeat(64)}); let encode_result = |e: &serde_json::Value| { serde_json::to_vec(&serde_json::json!({"effect_state":"verified","code":"POSTCONDITIONS_VERIFIED","evidence":e})).unwrap() }; assert_eq!( map_driver_result(&encode_result(&evidence), Some(0), true, &m, "ledger") .unwrap() .state, "succeeded" ); evidence["native_record_sha256"] = serde_json::json!(hash(b"fake install acceptance")); assert!(map_driver_result(&encode_result(&evidence), Some(0), true, &m, "ledger").is_err()); evidence .as_object_mut() .unwrap() .remove("native_record_sha256"); evidence["partial_proof_sha256"] = serde_json::json!(hash(b"other")); assert!(map_driver_result(&encode_result(&evidence), Some(0), true, &m, "ledger").is_err()); m.schema_version = 2; assert!(validate_manifest(&m, "apt_native_acceptance", &config).is_err()); } #[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 retry_schema_requires_an_explicit_native_reference_and_preserves_legacy_bytes() { let (config, mut m) = manifest(true); assert!( serde_json::to_value(&m) .unwrap() .get("native_retry") .is_none() ); m.schema_version = 3; assert!(validate_manifest(&m, "apt_native_acceptance", &config).is_err()); m.native_retry = Some(rmm_domain::apt_transaction::AptNativeRetry { schema_version: 1, previous_grant_id: Uuid::new_v4(), previous_attempt_id: Uuid::new_v4(), bootstrap_marker_sha256: hash(b"original"), }); validate_manifest(&m, "apt_native_acceptance", &config).unwrap(); m.schema_version = 2; assert!(validate_manifest(&m, "apt_native_acceptance", &config).is_err()); m.schema_version = 3; m.action = "apt-execute".into(); assert!(validate_manifest(&m, "ensure_package", &config).is_err()); m.action = "apt-native-acceptance".into(); m.native_retry.as_mut().unwrap().bootstrap_marker_sha256 = "invalid".into(); assert!(validate_manifest(&m, "apt_native_acceptance", &config).is_err()); } fn resign( request: &mut Request, job: &JobPayload, permit: &mut ExecutionPermitPayload, key: &PKey, ) { request.job_bytes = encode(job).unwrap(); 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(); request.authorization_id = permit.authorization_id; request.plan_hash = permit.plan_hash.clone(); } fn retry_fixture() -> ( PreparedApt, RetryEvidence, rusqlite::Connection, PathBuf, ExecutionPermitPayload, ) { let (binding, mut request, key, now) = signed_request(); let (mut job, mut permit) = binding.verify(&request, now).unwrap(); let (_, manifest) = manifest(true); job.action = Action::AptNativeAcceptance { recipe_id: INSTALL_RECIPE.into(), recipe_version: "1".into(), apt_manifest: serde_json::from_value(serde_json::to_value(&manifest).unwrap()).unwrap(), }; permit.action = "apt_native_acceptance".into(); resign(&mut request, &job, &mut permit, &key); binding.verify(&request, now).unwrap(); let dir = temporary(); // SAFETY: geteuid has no pointers or 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(); let ledger = format!("apt-{}-1", permit.grant_id); let outcome = Outcome { state: "failed".into(), evidence: serde_json::json!({"postconditions_passed":false,"apt":{ "test_acceptance":true,"noProductionEvidence":true}, "effect_armed_ledger_id":ledger,"test_acceptance":true,"noProductionEvidence":true}), ..Outcome::unknown("HOOK_NOT_HANDED_OFF") }; crate::finish(&db, &permit, &outcome).unwrap(); let marker = serde_json::to_vec(&serde_json::json!({ "transaction_sha256":manifest.transaction_sha256, "job_payload_sha256":hash(&request.job_bytes), "grant_id":permit.grant_id,"attempt_id":job.attempt_id, })) .unwrap(); let evidence = RetryEvidence { marker: marker.clone(), context: serde_json::to_vec(&serde_json::json!({ "schema_version":2,"transaction_sha256":manifest.transaction_sha256, "job_payload_sha256":hash(&request.job_bytes),"action":"apt-native-acceptance", "execution_profile":"dev-test","effect_armed_ledger_id":ledger, "grant_id":permit.grant_id,"job_id":job.job_id,"attempt_id":job.attempt_id, "authorization_id":permit.authorization_id,"plan_sha256":permit.plan_hash, "not_before_ms":permit.not_before.timestamp_millis(), "start_before_ms":permit.start_before.timestamp_millis(), "boot_id":"prior-boot","monotonic_start_before_ns":123, })).unwrap(), signed_action: request.job_bytes.clone(), expectation: manifest.transaction_bytes.clone(), baseline: b"{}".to_vec(), launch: serde_json::to_vec(&serde_json::json!({ "transaction_sha256":manifest.transaction_sha256,"effect_armed_ledger_id":ledger, })).unwrap(), sandbox_result: serde_json::to_vec(&serde_json::json!({ "transaction_sha256":manifest.transaction_sha256,"apt_exit_code":100,"reboot_required":false, })).unwrap(), }; let previous_permit = permit.clone(); let mut new_manifest = manifest; new_manifest.schema_version = 3; new_manifest.native_retry = Some(rmm_domain::apt_transaction::AptNativeRetry { schema_version: 1, previous_grant_id: permit.grant_id, previous_attempt_id: job.attempt_id, bootstrap_marker_sha256: hash(&marker), }); job.job_id = Uuid::new_v4(); job.attempt_id = Uuid::new_v4(); job.not_before = permit.start_before + chrono::Duration::seconds(1); job.start_before = job.not_before + chrono::Duration::seconds(59); job.action = Action::AptNativeAcceptance { recipe_id: INSTALL_RECIPE.into(), recipe_version: "1".into(), apt_manifest: serde_json::from_value(serde_json::to_value(&new_manifest).unwrap()).unwrap(), }; permit.grant_id = Uuid::new_v4(); permit.authorization_id = Uuid::new_v4(); permit.plan_hash = hash(b"new fixed UI approved retry plan"); permit.job_id = job.job_id; permit.attempt_id = job.attempt_id; permit.not_before = job.not_before; permit.start_before = job.start_before; resign(&mut request, &job, &mut permit, &key); binding.verify(&request, permit.not_before).unwrap(); ( PreparedApt { binding, job, permit, request, manifest: new_manifest, }, evidence, db, dir, previous_permit, ) } #[test] fn native_retry_requires_original_signed_known_failure_and_unchanged_baseline() { let (mut prepared, mut evidence, db, dir, previous) = retry_fixture(); prepared.verify_retry_evidence(&db, &evidence).unwrap(); let baseline = evidence.baseline.clone(); evidence.baseline.push(b' '); assert!(prepared.verify_retry_evidence(&db, &evidence).is_err()); evidence.baseline = baseline; let marker = evidence.marker.clone(); evidence.marker.push(b' '); assert!(prepared.verify_retry_evidence(&db, &evidence).is_err()); evidence.marker = marker; let old_attempt = prepared.job.attempt_id; prepared.job.attempt_id = previous.attempt_id; assert!(prepared.verify_retry_evidence(&db, &evidence).is_err()); prepared.job.attempt_id = old_attempt; let old_signature: Vec = db .query_row( "SELECT start FROM execution_evidence WHERE grant_id=?1", [previous.grant_id.to_string()], |r| r.get(0), ) .unwrap(); let mut start: serde_json::Value = serde_json::from_slice(&old_signature).unwrap(); let signature = start["request"]["signature"][0].as_u64().unwrap(); start["request"]["signature"][0] = serde_json::json!(signature ^ 1); db.execute( "UPDATE execution_evidence SET start=?2 WHERE grant_id=?1", rusqlite::params![ previous.grant_id.to_string(), serde_json::to_vec(&start).unwrap() ], ) .unwrap(); assert!(prepared.verify_retry_evidence(&db, &evidence).is_err()); db.execute( "UPDATE execution_evidence SET start=?2 WHERE grant_id=?1", rusqlite::params![previous.grant_id.to_string(), old_signature], ) .unwrap(); prepared.verify_retry_evidence(&db, &evidence).unwrap(); db.execute( "UPDATE consumed SET result=NULL WHERE grant_id=?1", [previous.grant_id.to_string()], ) .unwrap(); assert!(prepared.verify_retry_evidence(&db, &evidence).is_err()); drop(db); fs::remove_dir_all(dir).unwrap(); } #[test] fn native_retry_rejects_wrong_result_context_and_any_possible_effect() { let (prepared, evidence, db, dir, previous) = retry_fixture(); let mut value: serde_json::Value = serde_json::from_slice(&evidence.sandbox_result).unwrap(); value["apt_exit_code"] = serde_json::json!(0); let mut bad = RetryEvidence { sandbox_result: serde_json::to_vec(&value).unwrap(), marker: evidence.marker.clone(), context: evidence.context.clone(), signed_action: evidence.signed_action.clone(), expectation: evidence.expectation.clone(), baseline: evidence.baseline.clone(), launch: evidence.launch.clone(), }; assert!(prepared.verify_retry_evidence(&db, &bad).is_err()); bad.sandbox_result = evidence.sandbox_result.clone(); let mut context: serde_json::Value = serde_json::from_slice(&bad.context).unwrap(); context["authorization_id"] = serde_json::json!(Uuid::new_v4()); bad.context = serde_json::to_vec(&context).unwrap(); assert!(prepared.verify_retry_evidence(&db, &bad).is_err()); let result: Vec = db .query_row( "SELECT result FROM consumed WHERE grant_id=?1", [previous.grant_id.to_string()], |r| r.get(0), ) .unwrap(); for state in ["unknown", "succeeded"] { let mut changed: Outcome = serde_json::from_slice(&result).unwrap(); changed.state = state.into(); let changed = serde_json::to_vec(&changed).unwrap(); db.execute( "UPDATE consumed SET result=?2 WHERE grant_id=?1", rusqlite::params![previous.grant_id.to_string(), &changed], ) .unwrap(); db.execute( "UPDATE execution_evidence SET outcome=?2 WHERE grant_id=?1", rusqlite::params![previous.grant_id.to_string(), &changed], ) .unwrap(); assert!(prepared.verify_retry_evidence(&db, &evidence).is_err()); } let path = dir.join("hook-armed.json"); std::os::unix::fs::symlink(dir.join("missing-target"), &path).unwrap(); assert!(!absent_nofollow(&path).unwrap()); drop(db); fs::remove_dir_all(dir).unwrap(); } #[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::(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 { binding, 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, operation: None, 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(), native_retry: None, native_recovery: None, }; (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, DateTime, ) { 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, windows_execution_profile: None, privileged_script_profile: 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::(raw).is_err()); let mut m = serde_json::to_value(manifest(false).1).unwrap(); m["parameters"] = serde_json::json!({}); assert!(serde_json::from_value::(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, "host_reboot_required_before":false,"host_reboot_required_after":false,"reboot_required_introduced":false,"host_reboot_before_sha256":"e".repeat(64), "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 mut ambient = result.clone(); ambient["evidence"]["host_reboot_required_before"] = serde_json::json!(true); ambient["evidence"]["host_reboot_required_after"] = serde_json::json!(true); ambient["evidence"]["reboot_required"] = serde_json::json!(true); let mapped = map_driver_result( &serde_json::to_vec(&ambient).unwrap(), Some(0), true, &m, ledger, ) .unwrap(); assert_eq!(mapped.state, "succeeded"); assert!(mapped.reboot_required); ambient["evidence"]["host_reboot_required_before"] = serde_json::json!(false); assert!( map_driver_result( &serde_json::to_vec(&ambient).unwrap(), Some(0), true, &m, ledger ) .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(); }