//! One historical configure-only fixture whose effect completed but whose old //! acceptance rejected an ambient host reboot flag. Read-only proof, FAILED //! acceptance, and ordinary signed Sync only; never retry or retroactive success. use super::*; use rmm_domain::apt_transaction::{AptNativeRecovery, AptTransactionOperation}; const TARGET_GRANT: &str = "33775478-15b0-46ec-b059-44f500dbb0b6"; const PRIOR_GRANT: &str = "31ef5e5e-5dbd-4428-a9a1-cbd15de2f5a0"; const OLD_PROVIDER: &str = "5ff260f75cb2959678f6be729d3a806a4ea29febd5ae4003317fed41afc25327"; const OLD_RUNTIME: &str = "706c74d72592db990b47869b06ebc8668dffe029d01b13df52d7ef4f22b758fe"; const CLASSIFIED: &str = "APT_RECOVERY_CONFIGURED_ACCEPTANCE_REBOOT_FLAG_VERIFIED"; const ACTIVE_NAMES: [&str; 10] = [ "context.json", "signed-action.json", "expectation.json", "baseline.json", "launch.json", "native-prechecks.json", "sandbox-ready.json", "sandbox-result.json", "hook-armed.json", "partial-proof.json", ]; #[derive(Clone, Serialize, Deserialize)] #[serde(deny_unknown_fields)] struct Proof { schema_version: u32, #[serde(rename = "type")] kind: String, transaction_sha256: String, job_payload_sha256: String, effect_armed_ledger_id: String, grant_id: Uuid, job_id: Uuid, attempt_id: Uuid, authorization_id: Uuid, plan_sha256: String, original_evidence_sha256: String, partial_proof_sha256: String, original_baseline_sha256: String, observed_snapshot_sha256: String, status_fingerprint: String, fixture_payload_sha256: String, snapshot: BTreeMap, checked_at_ms: i64, effect_complete: bool, partial_effect: bool, postconditions_passed: bool, reboot_required: bool, host_reboot_required: bool, host_reboot_marker_sha256: String, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Output { effect_state: String, code: String, proof: Proof, } fn eligible(binding: &Binding, row: &LedgerRow) -> Result> { if row.grant != TARGET_GRANT { return Ok(None); } ensure!( row.start.len() <= 512 * 1024 && row.outcome.len() <= 512 * 1024, "APT_CONFIGURED_RECORD_LIMIT" ); let old: Outcome = serde_json::from_slice(&row.outcome)?; if old.state != "unknown" || old.error_code != "FIXTURE_UNEXPECTED_REBOOT_REQUIRED" { return Ok(None); } let start: SavedStart = serde_json::from_slice(&row.start)?; let permit: ExecutionPermitPayload = serde_json::from_slice(&start.request.permit_bytes)?; let (job, permit) = binding.verify(&start.request, permit.not_before)?; ensure!( !start.previous_boot_id.is_nil() && start.reauthentication_required && !start.postconditions_passed && start.reconnect_deadline.is_none() && start.reserved_at <= permit.start_before && row.agent == binding.agent_id.to_string() && row.generation == binding.enrollment_generation && row.grant == permit.grant_id.to_string() && row.job == job.job_id.to_string() && row.attempt == job.attempt_id.to_string() && job.execution_identity == "root", "APT_CONFIGURED_ORIGINAL_BINDING" ); let Action::AptNativeAcceptance { recipe_id, recipe_version, apt_manifest: m, } = &job.action else { return Ok(None); }; let Some(reference) = &m.native_recovery else { return Ok(None); }; ensure!( recipe_id == apt::INSTALL_RECIPE && recipe_version == "1" && m.validate() && m.schema_version == 4 && m.native_retry.is_none() && reference.previous_grant_id.to_string() == PRIOR_GRANT && m.provider_sha256 == OLD_PROVIDER && m.runtime_sha256 == OLD_RUNTIME && m.resolved_apt_transaction.operation == Some(AptTransactionOperation::ConfigureOnly) && m.action == "apt-native-acceptance" && m.execution_profile == "dev-test", "APT_CONFIGURED_FIXED_HISTORICAL_ACTION" ); let ledger = format!("apt-{}-{}", permit.grant_id, row.rowid); ensure!( old.exit_code == Some(0) && old.stdout.is_empty() && old.stderr.is_empty() && !old.output_truncated && !old.reboot_required && old.evidence["postconditions_passed"] == false && old.evidence["test_acceptance"] == true && old.evidence["noProductionEvidence"] == true && old.evidence["effect_armed_ledger_id"] == ledger, "APT_CONFIGURED_EXPECTED_UNKNOWN" ); Ok(Some(Candidate { request: start.request.clone(), permit: permit.clone(), manifest: m.clone(), probe: ProbeRequest { transaction_sha256: m.transaction_sha256.clone(), job_payload_sha256: hash(&start.request.job_bytes), 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.clone(), }, original_boot_id: start.previous_boot_id, original_outcome: row.outcome.clone(), })) } fn names(reference: &AptNativeRecovery) -> Vec { ACTIVE_NAMES .into_iter() .map(str::to_owned) .chain([ "bootstrap-attempt-rmm-apt-fixture-install-1.0.json".into(), "bootstrap-retry-rmm-apt-fixture-install-1.0.json".into(), format!("recovery-attempt-{}.json", reference.previous_grant_id), ]) .collect() } fn configure_protocol_sha256() -> String { hash(&serde_json::to_vec(&json!([{"name":"rmm-mvp-test","old_version":"1.0","old_arch":"all","old_multiarch":"none", "direction":"=","new_version":"1.0","new_arch":"all","new_multiarch":"none","action":"**CONFIGURE**"}])).expect("fixed protocol object")) } fn read_current(reference: &AptNativeRecovery) -> Result>> { let base = Path::new(BASE); crate::private_path(base, 0, true)?; crate::private_path(&base.join("active"), 0, true)?; ensure!( matches!(fs::symlink_metadata(base.join("active/host-reboot-before.json")),Err(e) if e.kind()==std::io::ErrorKind::NotFound), "APT_CONFIGURED_HISTORICAL_BEFORE_MUST_BE_ABSENT" ); for name in [ "acceptance-rmm-apt-fixture-install-1.0.json".into(), "pending-acceptance-rmm-apt-fixture-install-1.0.json".into(), format!("recovery-{}.json", reference.previous_grant_id), format!("pending-recovery-{}.json", reference.previous_grant_id), ] { ensure!( matches!(fs::symlink_metadata(base.join(name)),Err(e) if e.kind()==std::io::ErrorKind::NotFound), "APT_CONFIGURED_ACCEPTANCE_MUST_NOT_EXIST" ); } let mut files = BTreeMap::new(); for name in names(reference).into_iter().chain(["apt.conf".into()]) { let root = if ACTIVE_NAMES.contains(&name.as_str()) || name == "apt.conf" { base.join("active") } else { base.into() }; files.insert(name.clone(), sealed(&root.join(name), 1024 * 1024)?); } Ok(files) } fn previous_files(reference: &AptNativeRecovery) -> Result>> { let root = Path::new(BASE) .join("history") .join(reference.previous_grant_id.to_string()); crate::private_path(&root, 0, true)?; let mut files = BTreeMap::new(); for name in EVIDENCE_NAMES.into_iter().chain(["apt.conf"]) { let path = if name.starts_with("bootstrap-") { Path::new(BASE).join(name) } else { root.join(name) }; files.insert(name.into(), sealed(&path, 1024 * 1024)?); } Ok(files) } fn current_evidence( c: &Candidate, prior: &ClosedPartial, files: &BTreeMap>, ) -> Result> { let read = |name: &str| files.get(name).context("APT_CONFIGURED_EVIDENCE_MISSING"); let reference = c .manifest .native_recovery .as_ref() .context("APT_CONFIGURED_REFERENCE")?; ensure!( prior.reference == *reference && read("partial-proof.json")? == &prior.proof && hash(&prior.proof) == reference.partial_proof_sha256 && prior.baseline_sha256 == c.manifest.resolved_apt_transaction.baseline_sha256 && prior.status_fingerprint == c.manifest.resolved_apt_transaction.status_fingerprint && prior.previous_start_before <= c.permit.not_before && prior.job_id != c.probe.job_id && prior.authorization_id != c.probe.authorization_id && prior.plan_sha256 != c.probe.plan_sha256, "APT_CONFIGURED_PRIOR_CLOSED_PROOF_BINDING" ); ensure!( read("signed-action.json")? == &c.request.job_bytes && read("expectation.json")? == &c.manifest.transaction_bytes && hash(read("baseline.json")?) == c.manifest.resolved_apt_transaction.baseline_sha256 && hash(read("apt.conf")?) == c.manifest.apt_config_sha256, "APT_CONFIGURED_HISTORICAL_FILE_HASH" ); let context: ContextRecord = serde_json::from_slice(read("context.json")?)?; ensure!( context.schema_version == 2 && context.action == "apt-native-acceptance" && context.execution_profile == "dev-test" && context.transaction_sha256 == c.probe.transaction_sha256 && context.job_payload_sha256 == c.probe.job_payload_sha256 && context.effect_armed_ledger_id == c.probe.effect_armed_ledger_id && context.grant_id == c.probe.grant_id && context.job_id == c.probe.job_id && context.attempt_id == c.probe.attempt_id && context.authorization_id == c.probe.authorization_id && context.plan_sha256 == c.probe.plan_sha256 && context.boot_id == c.original_boot_id && context.not_before_ms == c.permit.not_before.timestamp_millis() && context.start_before_ms == c.permit.start_before.timestamp_millis() && context.monotonic_start_before_ns > 0, "APT_CONFIGURED_ORIGINAL_CONTEXT" ); let value = |name: &str| -> Result { Ok(serde_json::from_slice(read(name)?)?) }; ensure!( value("launch.json")? == json!({"transaction_sha256":c.probe.transaction_sha256,"effect_armed_ledger_id":c.probe.effect_armed_ledger_id}) && value("sandbox-ready.json")? == json!({"transaction_sha256":c.probe.transaction_sha256,"sandbox_version":1}) && value("sandbox-result.json")? == json!({"transaction_sha256":c.probe.transaction_sha256,"apt_exit_code":0,"reboot_required":false}) && value("native-prechecks.json")? == native_prechecks(c), "APT_CONFIGURED_NATIVE_CHILD_RESULT" ); let hook = value("hook-armed.json")?; ensure!( hook["transaction_sha256"] == c.probe.transaction_sha256 && hook["grant_id"] == c.probe.grant_id.to_string() && hook["effect_armed_ledger_id"] == c.probe.effect_armed_ledger_id && hook["protocol_sha256"] == configure_protocol_sha256() && hook["armed_at_ms"] .as_i64() .is_some_and(|t| t >= context.not_before_ms && t < context.start_before_ms), "APT_CONFIGURED_ARMED_HOOK" ); ensure!( value(&format!( "recovery-attempt-{}.json", reference.previous_grant_id ))? == json!({ "transaction_sha256":c.probe.transaction_sha256,"job_payload_sha256":c.probe.job_payload_sha256, "grant_id":c.probe.grant_id,"attempt_id":c.probe.attempt_id,"native_recovery":reference}), "APT_CONFIGURED_ONCE_MARKER" ); let baseline: BTreeMap = serde_json::from_slice(read("baseline.json")?)?; ensure!( baseline.get("rmm-mvp-test:all") == Some(&PackageState { version: "1.0".into(), status: "install ok unpacked".into() }), "APT_CONFIGURED_ORIGINAL_UNPACKED_BASELINE" ); Ok(baseline) } fn evidence_digest(c: &Candidate, files: &BTreeMap>) -> Result { let reference = c .manifest .native_recovery .as_ref() .context("APT_CONFIGURED_REFERENCE")?; let hashes = names(reference) .into_iter() .map(|name| { let digest = hash( files .get(&name) .context("APT_CONFIGURED_EVIDENCE_MISSING")?, ); Ok((name, digest)) }) .collect::>>()?; Ok(hash(&serde_json::to_vec(&hashes)?)) } fn verify( c: &Candidate, prior: &ClosedPartial, files: &BTreeMap>, output: &Output, now: DateTime, ) -> Result<()> { let mut expected = current_evidence(c, prior, files)?; expected.insert( "rmm-mvp-test:all".into(), PackageState { version: "1.0".into(), status: "install ok installed".into(), }, ); let p = &output.proof; let actual = ProbeRequest { transaction_sha256: p.transaction_sha256.clone(), job_payload_sha256: p.job_payload_sha256.clone(), effect_armed_ledger_id: p.effect_armed_ledger_id.clone(), grant_id: p.grant_id, job_id: p.job_id, attempt_id: p.attempt_id, authorization_id: p.authorization_id, plan_sha256: p.plan_sha256.clone(), }; ensure!( output.effect_state == "known_failed" && output.code == CLASSIFIED && p.schema_version == 1 && p.kind == "rmm.apt.configured-recovery-reconciliation" && actual == c.probe && p.effect_complete && !p.partial_effect && !p.postconditions_passed && p.reboot_required && p.host_reboot_required && digest(&p.host_reboot_marker_sha256) && p.original_evidence_sha256 == evidence_digest(c, files)? && p.partial_proof_sha256 == prior.reference.partial_proof_sha256 && p.original_baseline_sha256 == c.manifest.resolved_apt_transaction.baseline_sha256 && p.snapshot == expected && p.observed_snapshot_sha256 == hash(&serde_json::to_vec(&serde_json::to_value(&p.snapshot)?)?) && p.fixture_payload_sha256 == hash(b"1.0\n") && digest(&p.status_fingerprint) && p.checked_at_ms >= now.timestamp_millis() - 1000 && p.checked_at_ms <= Utc::now().timestamp_millis() + 1000, "APT_CONFIGURED_READONLY_PROOF_BINDING" ); Ok(()) } fn persist(db: &mut Connection, c: &Candidate, p: &Proof) -> Result<()> { let proof = serde_json::to_vec(&serde_json::to_value(p)?)?; let proof_sha = hash(&proof); let outcome = Outcome { state: "failed".into(), stdout: vec![], stderr: vec![], exit_code: Some(0), output_truncated: false, reboot_required: true, evidence: json!({"postconditions_passed":false,"effect_complete":true,"partial_effect":false,"reconciled_postconditions":true, "effect_armed_ledger_id":c.probe.effect_armed_ledger_id,"test_acceptance":true,"noProductionEvidence":true, "apt":{"test_acceptance":true,"noProductionEvidence":true,"effect_complete":true,"partial_effect":false, "fixture_status":"install ok installed","fixture_version":"1.0","fixture_payload_sha256":p.fixture_payload_sha256, "snapshot_sha256":p.observed_snapshot_sha256,"status_fingerprint":p.status_fingerprint, "host_reboot_required":true,"host_reboot_marker_sha256":p.host_reboot_marker_sha256, "host_reboot_required_before":null,"acceptance_reboot_baseline_missing":true,"reconciliation_proof_sha256":proof_sha}}), error_code: CLASSIFIED.into(), }; let classified = serde_json::to_vec(&outcome)?; let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; // Lazy, append-only local evidence. Existing partial-proof rows are intact; // ordinary open_ledger/probe never creates this table or changes history. tx.execute_batch("CREATE TABLE IF NOT EXISTS apt_effect_reconciliations(grant_id TEXT PRIMARY KEY, original_request_sha256 TEXT NOT NULL,previous_outcome_sha256 TEXT NOT NULL,previous_outcome BLOB NOT NULL, proof_sha256 TEXT NOT NULL,proof BLOB NOT NULL,classified_outcome BLOB NOT NULL,checked_at_ms INTEGER NOT NULL);")?; let current:(Option>,Option>)=tx.query_row("SELECT c.result,e.outcome FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE grant_id=?1", [c.probe.grant_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; ensure!( current.0.is_none() && current.1.as_deref() == Some(c.original_outcome.as_slice()), "APT_CONFIGURED_OUTCOME_CHANGED" ); tx.execute( "INSERT INTO apt_effect_reconciliations VALUES(?1,?2,?3,?4,?5,?6,?7,?8)", params![ c.probe.grant_id.to_string(), hash(&serde_json::to_vec(&c.request)?), hash(&c.original_outcome), c.original_outcome, proof_sha, proof, classified, p.checked_at_ms ], )?; ensure!( tx.execute( "UPDATE execution_evidence SET outcome=?2 WHERE grant_id=?1 AND outcome=?3", params![c.probe.grant_id.to_string(), classified, c.original_outcome] )? == 1, "APT_CONFIGURED_OUTCOME_CHANGED" ); // No consumed.result update. Only normal signed RootSync closes the lock. tx.commit()?; Ok(()) } pub(super) fn refresh( db: &mut Connection, binding: &Binding, row: &LedgerRow, now: DateTime, ) -> Result { let Some(c) = eligible(binding, row)? else { return Ok(false); }; let reference = c .manifest .native_recovery .as_ref() .context("APT_CONFIGURED_REFERENCE")?; let Ok(historical) = previous_files(reference) else { return Ok(false); }; let Ok(prior) = closed_partial_from(db, binding, Some(reference), || Ok(historical.clone())) else { return Ok(false); }; let Ok(files) = read_current(reference) else { return Ok(false); }; if current_evidence(&c, &prior, &files).is_err() { return Ok(false); } let Ok(raw) = probe_mode(&c, "verify-configured-recovery") else { return Ok(false); }; let Ok(output) = serde_json::from_slice::(&raw) else { return Ok(false); }; if verify(&c, &prior, &files, &output, now).is_err() { return Ok(false); } // Re-read every sealed historical witness after the independent live probe. if read_current(reference)? != files || previous_files(reference)? != historical || hash(&sealed(Path::new("/run/reboot-required"), 4096)?) != output.proof.host_reboot_marker_sha256 { return Ok(false); } persist(db, &c, &output.proof)?; Ok(true) } #[cfg(test)] mod tests { use super::*; use openssl::{pkey::PKey, sign::Signer}; struct Fixture { binding: Binding, row: LedgerRow, prior: ClosedPartial, files: BTreeMap>, now: DateTime, } fn fixture() -> Fixture { let now = Utc::now(); let key = PKey::generate_ed25519().unwrap(); 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(key.raw_public_key().unwrap()), }; let baseline = json!({"base-files:amd64":{"version":"1","status":"install ok installed"},"rmm-mvp-test:all":{"version":"1.0","status":"install ok unpacked"}}); // A trusted prior object is supplied to this unit boundary. The // independent closed_partial_from signature/history checks have their // existing integration guards; this fixture does not assert native proof. let proof = serde_json::to_vec( &json!({"isolated_verified_prior_fixture":true,"snapshot":baseline}), ) .unwrap(); let reference = AptNativeRecovery { schema_version: 1, previous_grant_id: PRIOR_GRANT.parse().unwrap(), previous_attempt_id: Uuid::new_v4(), partial_proof_sha256: hash(&proof), }; let baseline_sha = hash(&serde_json::to_vec(&baseline).unwrap()); let tx = json!({"schema_version":2,"operation":"configure_only","recipe_id":apt::INSTALL_RECIPE,"recipe_version":"1","platform":"ubuntu-24.04-amd64", "resolver_config_version":"rmm-apt-local-v1","no_reboot":true,"status_fingerprint":"a".repeat(64),"baseline_sha256":baseline_sha, "packages":[{"name":"rmm-mvp-test","architecture":"all","old_version":"1.0","new_version":"1.0","origin":"rmm-test", "sha256":"74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867","size":20672, "archive_path":"/var/lib/rmm-apt-transaction/archives/74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867.deb"}]}); let txbytes = serde_json::to_vec(&tx).unwrap(); let manifest = json!({"type":"rmm.apt.helper-action","schema_version":4,"action":"apt-native-acceptance","execution_profile":"dev-test", "transaction_sha256":hash(&txbytes),"transaction_bytes":txbytes,"resolved_apt_transaction":tx,"native_recovery":reference, "provider_sha256":OLD_PROVIDER,"hook_sha256":"b".repeat(64),"runtime_sha256":OLD_RUNTIME,"apt_config_sha256":hash(b"historical config"),"test_result_id":"configured-fixture"}); let job:JobPayload=serde_json::from_value(json!({"schema_version":1,"tenant_id":binding.tenant_id,"agent_id":binding.agent_id,"asset_id":binding.asset_id, "enrollment_generation":1,"assignment_version":1,"job_id":Uuid::new_v4(),"attempt_id":Uuid::new_v4(),"execution_identity":"root", "not_before":now,"start_before":now+chrono::Duration::minutes(15),"max_runtime_seconds":300,"max_output_bytes":65536, "action":{"action":"apt_native_acceptance","recipe_id":apt::INSTALL_RECIPE,"recipe_version":"1","apt_manifest":manifest}})).unwrap(); let permit = ExecutionPermitPayload { domain: "rmm.execution-permit".into(), schema_version: 1, grant_id: TARGET_GRANT.parse().unwrap(), 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: "c".repeat(64), job_payload_hash: hash(&encode(&job).unwrap()), action: "apt_native_acceptance".into(), execution_identity: "root".into(), not_before: now, start_before: now + chrono::Duration::seconds(60), max_runtime_seconds: 300, key_id: hash(&key.raw_public_key().unwrap()), }; let bytes = encode(&permit).unwrap(); let request = Request { job_bytes: encode(&job).unwrap(), permit_bytes: bytes.clone(), signature: Signer::new_without_digest(&key) .unwrap() .sign_oneshot_to_vec(&bytes) .unwrap(), plan_hash: permit.plan_hash.clone(), authorization_id: permit.authorization_id, }; let boot = Uuid::new_v4(); let ledger = format!("apt-{}-11", permit.grant_id); let old = Outcome { exit_code: Some(0), evidence: json!({"postconditions_passed":false,"test_acceptance":true,"noProductionEvidence":true,"effect_armed_ledger_id":ledger}), ..Outcome::unknown("FIXTURE_UNEXPECTED_REBOOT_REQUIRED") }; let row=LedgerRow{rowid:11,grant:permit.grant_id.to_string(),agent:binding.agent_id.to_string(),generation:1,job:job.job_id.to_string(),attempt:job.attempt_id.to_string(),outcome:serde_json::to_vec(&old).unwrap(), start:serde_json::to_vec(&json!({"previous_boot_id":boot,"reserved_at":now,"reconnect_deadline":null,"request":request,"reauthentication_required":true,"postconditions_passed":false})).unwrap()}; let prior = ClosedPartial { reference, proof, job_id: Uuid::new_v4(), authorization_id: Uuid::new_v4(), plan_sha256: "d".repeat(64), previous_start_before: now - chrono::Duration::seconds(1), baseline_sha256: baseline_sha, status_fingerprint: "a".repeat(64), }; let c = eligible(&binding, &row).unwrap().unwrap(); let mut files = BTreeMap::from([ ("signed-action.json".into(), c.request.job_bytes.clone()), ( "expectation.json".into(), c.manifest.transaction_bytes.clone(), ), ( "baseline.json".into(), serde_json::to_vec(&baseline).unwrap(), ), ("apt.conf".into(), b"historical config".to_vec()), ("partial-proof.json".into(), prior.proof.clone()), ( "bootstrap-attempt-rmm-apt-fixture-install-1.0.json".into(), b"retained install marker".to_vec(), ), ( "bootstrap-retry-rmm-apt-fixture-install-1.0.json".into(), b"retained retry marker".to_vec(), ), ]); for (name, value) in [ ( "context.json".into(), json!({"schema_version":2,"transaction_sha256":c.probe.transaction_sha256,"job_payload_sha256":c.probe.job_payload_sha256,"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, "action":"apt-native-acceptance","execution_profile":"dev-test","not_before_ms":now.timestamp_millis(),"start_before_ms":permit.start_before.timestamp_millis(),"boot_id":boot,"monotonic_start_before_ns":1}), ), ( "launch.json".into(), json!({"transaction_sha256":c.probe.transaction_sha256,"effect_armed_ledger_id":ledger}), ), ( "sandbox-ready.json".into(), json!({"transaction_sha256":c.probe.transaction_sha256,"sandbox_version":1}), ), ( "sandbox-result.json".into(), json!({"transaction_sha256":c.probe.transaction_sha256,"apt_exit_code":0,"reboot_required":false}), ), ("native-prechecks.json".into(), native_prechecks(&c)), ( "hook-armed.json".into(), json!({"transaction_sha256":c.probe.transaction_sha256,"effect_armed_ledger_id":ledger,"grant_id":permit.grant_id,"protocol_sha256":configure_protocol_sha256(),"armed_at_ms":now.timestamp_millis()}), ), ( format!("recovery-attempt-{PRIOR_GRANT}.json"), json!({"transaction_sha256":c.probe.transaction_sha256,"job_payload_sha256":c.probe.job_payload_sha256,"grant_id":permit.grant_id,"attempt_id":permit.attempt_id,"native_recovery":prior.reference}), ), ] { files.insert(name, serde_json::to_vec(&value).unwrap()); } Fixture { binding, row, prior, files, now, } } fn output(f: &Fixture, c: &Candidate) -> Output { let mut snapshot = current_evidence(c, &f.prior, &f.files).unwrap(); snapshot.get_mut("rmm-mvp-test:all").unwrap().status = "install ok installed".into(); Output { effect_state: "known_failed".into(), code: CLASSIFIED.into(), proof: Proof { schema_version: 1, kind: "rmm.apt.configured-recovery-reconciliation".into(), transaction_sha256: c.probe.transaction_sha256.clone(), job_payload_sha256: c.probe.job_payload_sha256.clone(), effect_armed_ledger_id: c.probe.effect_armed_ledger_id.clone(), grant_id: c.probe.grant_id, job_id: c.probe.job_id, attempt_id: c.probe.attempt_id, authorization_id: c.probe.authorization_id, plan_sha256: c.probe.plan_sha256.clone(), original_evidence_sha256: evidence_digest(c, &f.files).unwrap(), partial_proof_sha256: f.prior.reference.partial_proof_sha256.clone(), original_baseline_sha256: f.prior.baseline_sha256.clone(), observed_snapshot_sha256: hash( &serde_json::to_vec(&serde_json::to_value(&snapshot).unwrap()).unwrap(), ), status_fingerprint: "e".repeat(64), fixture_payload_sha256: hash(b"1.0\n"), snapshot, checked_at_ms: f.now.timestamp_millis(), effect_complete: true, partial_effect: false, postconditions_passed: false, reboot_required: true, host_reboot_required: true, host_reboot_marker_sha256: "f".repeat(64), }, } } #[test] fn configured_exact_signed_candidate_and_full_proof_do_not_invent_before_or_success() { let f = fixture(); let c = eligible(&f.binding, &f.row).unwrap().unwrap(); let out = output(&f, &c); verify(&c, &f.prior, &f.files, &out, f.now).unwrap(); for variant in 0..6 { let mut changed = output(&f, &c); match variant { 0 => changed.proof.postconditions_passed = true, 1 => changed.proof.reboot_required = false, 2 => changed.proof.partial_effect = true, 3 => { changed .proof .snapshot .get_mut("base-files:amd64") .unwrap() .version = "unrelated change".into() } 4 => changed.proof.grant_id = Uuid::new_v4(), _ => changed.proof.checked_at_ms -= 60000, } assert!(verify(&c, &f.prior, &f.files, &changed, f.now).is_err()); } let mut row = f.row.clone(); row.grant = Uuid::new_v4().to_string(); assert!(eligible(&f.binding, &row).unwrap().is_none()); let mut tampered = f.files.clone(); let mut hook: Value = serde_json::from_slice(&tampered["hook-armed.json"]).unwrap(); hook["protocol_sha256"] = json!("0".repeat(64)); tampered.insert("hook-armed.json".into(), serde_json::to_vec(&hook).unwrap()); assert!(current_evidence(&c, &f.prior, &tampered).is_err()); } #[test] fn configured_append_preserves_original_unknown_and_consumed_lock_until_signed_sync() { let f = fixture(); let c = eligible(&f.binding, &f.row).unwrap().unwrap(); let out = output(&f, &c); let mut db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE consumed(grant_id TEXT PRIMARY KEY,result BLOB);CREATE TABLE execution_evidence(grant_id TEXT PRIMARY KEY,outcome BLOB);").unwrap(); db.execute( "INSERT INTO consumed VALUES(?1,NULL)", [&c.probe.grant_id.to_string()], ) .unwrap(); db.execute( "INSERT INTO execution_evidence VALUES(?1,?2)", params![c.probe.grant_id.to_string(), c.original_outcome], ) .unwrap(); persist(&mut db, &c, &out.proof).unwrap(); assert!( db.query_row("SELECT result IS NULL FROM consumed", [], |r| r .get::<_, bool>(0)) .unwrap() ); assert_eq!( db.query_row( "SELECT previous_outcome FROM apt_effect_reconciliations", [], |r| r.get::<_, Vec>(0) ) .unwrap(), c.original_outcome ); let classified: Vec = db .query_row("SELECT outcome FROM execution_evidence", [], |r| r.get(0)) .unwrap(); let value: Outcome = serde_json::from_slice(&classified).unwrap(); assert_eq!(value.state, "failed"); assert_eq!(value.error_code, CLASSIFIED); assert!(value.reboot_required); assert_eq!(value.evidence["effect_complete"], true); assert_eq!(value.evidence["postconditions_passed"], false); assert_eq!( value.evidence["apt"]["host_reboot_required_before"], Value::Null ); assert!(persist(&mut db, &c, &out.proof).is_err()); assert_eq!( db.query_row("SELECT count(*) FROM apt_effect_reconciliations", [], |r| r .get::<_, u64>(0)) .unwrap(), 1 ); } }