//! Recheck only the original fixture job's bound postcondition. No executor, //! approval, new grant, package command or consumption unlock exists here. use crate::{Binding, Outcome, Request, apt, reconcile::ExecutorGuard}; use anyhow::{Context, Result, ensure}; use chrono::{DateTime, Utc}; use rmm_domain::{apt_transaction::AptExecutionManifest, jobs::*}; use rusqlite::{Connection, TransactionBehavior, params}; use serde::{Deserialize, Serialize}; use serde_json::{Value, json}; use std::{ collections::BTreeMap, fs::{self, OpenOptions}, io::{Read, Write}, os::unix::fs::{MetadataExt, OpenOptionsExt}, path::Path, process::{Command, Stdio}, }; use uuid::Uuid; const BASE: &str = "/var/lib/rmm-apt-transaction"; const CODE: &str = "APT_PARTIAL_UNCONFIGURED_VERIFIED"; const EVIDENCE_NAMES: [&str; 11] = [ "context.json", "signed-action.json", "expectation.json", "baseline.json", "launch.json", "native-prechecks.json", "sandbox-ready.json", "sandbox-result.json", "hook-armed.json", "bootstrap-attempt-rmm-apt-fixture-install-1.0.json", "bootstrap-retry-rmm-apt-fixture-install-1.0.json", ]; #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct SavedStart { previous_boot_id: Uuid, reserved_at: DateTime, reconnect_deadline: Option>, request: Request, reauthentication_required: bool, postconditions_passed: bool, } #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] struct PackageState { version: String, status: String, } #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] struct ProbeRequest { 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, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct ContextRecord { 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, schema_version: u32, action: String, execution_profile: String, not_before_ms: i64, start_before_ms: i64, boot_id: Uuid, monotonic_start_before_ns: u64, } #[derive(Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] struct PartialProof { 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, original_baseline_sha256: String, observed_snapshot_sha256: String, status_fingerprint: String, fixture_payload_sha256: String, snapshot: BTreeMap, checked_at_ms: i64, partial_effect: bool, postconditions_passed: bool, reboot_required: bool, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct ProbeOutput { effect_state: String, code: String, proof: PartialProof, } struct Candidate { request: Request, permit: ExecutionPermitPayload, manifest: AptExecutionManifest, probe: ProbeRequest, original_boot_id: Uuid, original_outcome: Vec, } #[derive(Clone)] struct LedgerRow { rowid: i64, grant: String, agent: String, generation: u64, job: String, attempt: String, start: Vec, outcome: Vec, } pub struct ClosedPartial { pub reference: rmm_domain::apt_transaction::AptNativeRecovery, pub proof: Vec, pub job_id: Uuid, pub authorization_id: Uuid, pub plan_sha256: String, pub previous_start_before: DateTime, pub baseline_sha256: String, pub status_fingerprint: String, } /// Only a previously classified partial whose exact outcome was closed by /// signed RootSync can seed a new, separately approved configure-only job. pub fn closed_partial( db: &Connection, binding: &Binding, wanted: Option<&rmm_domain::apt_transaction::AptNativeRecovery>, ) -> Result { closed_partial_from(db, binding, wanted, read_evidence) } fn closed_partial_from( db: &Connection, binding: &Binding, wanted: Option<&rmm_domain::apt_transaction::AptNativeRecovery>, read: impl Fn() -> Result>>, ) -> Result { let mut q=db.prepare("SELECT c.rowid,c.grant_id,c.agent,c.generation,c.job,c.attempt,e.start,c.result,e.outcome,p.original_request_sha256,p.previous_outcome_sha256,p.previous_outcome,p.proof_sha256,p.proof,p.classified_outcome,p.checked_at_ms FROM apt_partial_reconciliations p JOIN consumed c USING(grant_id) JOIN execution_evidence e USING(grant_id) ORDER BY c.rowid")?; let rows = q .query_map([], |r| { Ok(( LedgerRow { rowid: r.get(0)?, grant: r.get(1)?, agent: r.get(2)?, generation: r.get(3)?, job: r.get(4)?, attempt: r.get(5)?, start: r.get(6)?, outcome: r.get(11)?, }, r.get::<_, Option>>(7)?, r.get::<_, Option>>(8)?, r.get::<_, String>(9)?, r.get::<_, String>(10)?, r.get::<_, String>(12)?, r.get::<_, Vec>(13)?, r.get::<_, Vec>(14)?, r.get::<_, i64>(15)?, )) })? .collect::>>()?; ensure!(rows.len() <= 256, "APT_RECOVERY_PROOF_LIMIT"); let mut found = None; for (row, result, outcome, request_sha, old_sha, proof_sha, proof, classified, checked) in rows { if wanted.is_some_and(|w| w.previous_grant_id.to_string() != row.grant) { continue; } let Some(c) = eligible(binding, row)? else { continue; }; let reference = rmm_domain::apt_transaction::AptNativeRecovery { schema_version: 1, previous_grant_id: c.probe.grant_id, previous_attempt_id: c.probe.attempt_id, partial_proof_sha256: proof_sha.clone(), }; ensure!( wanted.is_none_or(|w| w == &reference) && reference.validate() && hash(&proof) == proof_sha && hash(&c.original_outcome) == old_sha && hash(&serde_json::to_vec(&c.request)?) == request_sha, "APT_RECOVERY_IMMUTABLE_PROOF" ); let result: Outcome = serde_json::from_slice(&result.context("APT_RECOVERY_PRIOR_UNRESOLVED")?)?; let classified_value: Value = serde_json::from_slice(&classified)?; ensure!( result.state == "failed" && result.error_code == CODE && !result.reboot_required && serde_json::to_value(&result)? == classified_value && serde_json::from_slice::( &outcome.context("APT_RECOVERY_PRIOR_OUTCOME")? )? == classified_value, "APT_RECOVERY_PRIOR_NOT_CLOSED_PARTIAL" ); let p: PartialProof = serde_json::from_slice(&proof)?; ensure!(p.checked_at_ms == checked, "APT_RECOVERY_PROOF_TIME"); let files = read()?; verify_proof( &c, &files, &ProbeOutput { effect_state: "known_failed".into(), code: CODE.into(), proof: p.clone(), }, DateTime::from_timestamp_millis(checked).context("APT_RECOVERY_PROOF_TIME")?, )?; ensure!(found.is_none(), "APT_RECOVERY_AMBIGUOUS_PROOFS"); found = Some(ClosedPartial { reference, proof, job_id: c.probe.job_id, authorization_id: c.probe.authorization_id, plan_sha256: c.probe.plan_sha256, previous_start_before: c.permit.start_before, baseline_sha256: p.observed_snapshot_sha256, status_fingerprint: p.status_fingerprint, }); } found.context("APT_RECOVERY_CLOSED_PROOF_REQUIRED") } fn digest(s: &str) -> bool { s.len() == 64 && s.bytes() .all(|b| b.is_ascii_digit() || b"abcdef".contains(&b)) } fn eligible(binding: &Binding, row: LedgerRow) -> Result> { ensure!( row.start.len() <= 512 * 1024 && row.outcome.len() <= 512 * 1024, "APT_RECONCILE_RECORD_LIMIT" ); let old: Outcome = serde_json::from_slice(&row.outcome)?; if old.state != "unknown" || old.error_code != "DPKG_INCONSISTENT" { return Ok(None); } let start: SavedStart = serde_json::from_slice(&row.start)?; ensure!( !start.previous_boot_id.is_nil() && start.reauthentication_required && !start.postconditions_passed && start.reconnect_deadline.is_none(), "APT_RECONCILE_ORIGINAL_START" ); let permit: ExecutionPermitPayload = serde_json::from_slice(&start.request.permit_bytes)?; // The old start window is verified historically. It never authorizes a // present process start, and the consumed tombstone is never replaced. let (job, permit) = binding.verify(&start.request, permit.not_before)?; ensure!( 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" && start.reserved_at <= permit.start_before, "APT_RECONCILE_ORIGINAL_BINDING" ); let Action::AptNativeAcceptance { recipe_id, recipe_version, apt_manifest, } = &job.action else { return Ok(None); }; if apt_manifest.schema_version != 3 || apt_manifest.native_retry.is_none() { return Ok(None); } ensure!( recipe_id == apt::INSTALL_RECIPE && recipe_version == "1" && apt_manifest.validate() && apt_manifest.schema_version == 3 && apt_manifest.native_retry.is_some() && apt_manifest.action == "apt-native-acceptance" && apt_manifest.execution_profile == "dev-test", "APT_RECONCILE_FIXED_NATIVE_FIXTURE_ONLY" ); 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_RECONCILE_EXPECTED_UNKNOWN_ONLY" ); let probe = ProbeRequest { transaction_sha256: apt_manifest.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(), }; Ok(Some(Candidate { request: start.request, permit, manifest: apt_manifest.clone(), probe, original_boot_id: start.previous_boot_id, original_outcome: row.outcome, })) } fn sealed(path: &Path, limit: u64) -> Result> { for component in path.ancestors() { let meta = fs::symlink_metadata(component)?; ensure!( !meta.file_type().is_symlink() && meta.uid() == 0 && meta.mode() & 0o022 == 0, "APT_RECONCILE_UNTRUSTED_PATH" ); } let mut file = OpenOptions::new() .read(true) .custom_flags(libc::O_NOFOLLOW) .open(path)?; ensure!( file.metadata()?.is_file() && file.metadata()?.len() <= limit, "APT_RECONCILE_FILE_LIMIT" ); let mut bytes = vec![]; (&mut file).take(limit + 1).read_to_end(&mut bytes)?; ensure!(bytes.len() as u64 <= limit, "APT_RECONCILE_FILE_LIMIT"); Ok(bytes) } fn read_evidence() -> Result>> { let base = Path::new(BASE); crate::private_path(base, 0, true)?; crate::private_path(&base.join("active"), 0, true)?; for name in [ "acceptance-rmm-apt-fixture-install-1.0.json", "pending-acceptance-rmm-apt-fixture-install-1.0.json", ] { ensure!( matches!(fs::symlink_metadata(base.join(name)),Err(e) if e.kind()==std::io::ErrorKind::NotFound), "APT_RECONCILE_ACCEPTANCE_EXISTS" ); } let mut result = BTreeMap::new(); for name in EVIDENCE_NAMES.into_iter().chain(["apt.conf"]) { let path = if name.starts_with("bootstrap-") { base.join(name) } else { base.join("active").join(name) }; result.insert(name.to_owned(), sealed(&path, 1024 * 1024)?); } Ok(result) } fn verify_evidence( c: &Candidate, files: &BTreeMap>, ) -> Result> { let read = |name: &str| files.get(name).context("APT_RECONCILE_EVIDENCE_MISSING"); 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_RECONCILE_ORIGINAL_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_RECONCILE_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-result.json")? == json!({"transaction_sha256":c.probe.transaction_sha256,"apt_exit_code":0,"reboot_required":false}) && value("sandbox-ready.json")? == json!({"transaction_sha256":c.probe.transaction_sha256,"sandbox_version":1}) && value("native-prechecks.json")? == native_prechecks(c), "APT_RECONCILE_NATIVE_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"].as_str().is_some_and(digest) && hook["armed_at_ms"].as_i64().is_some_and(|time| time>=context.not_before_ms && time = serde_json::from_slice(read("baseline.json")?)?; ensure!( !baseline.contains_key("rmm-mvp-test:all"), "APT_RECONCILE_ORIGINAL_ABSENCE" ); Ok(baseline) } fn native_prechecks(c: &Candidate) -> Value { json!({"schema_version":1,"transaction_sha256":c.probe.transaction_sha256, "job_payload_sha256":c.probe.job_payload_sha256,"boot_id":c.original_boot_id, "checks":{"namespaces_caps_nnp_seccomp":true,"readonly_controlpaths":true, "private_tmpfs_sockets":true,"control_syscalls":{"invalid_reboot_magic":"EPERM", "invalid_kexec_load_flags":"EPERM","invalid_kexec_file_fds_flags":"EPERM"}, "frontend_lock":"native-apt-check-conflict"}}) } fn evidence_hash(files: &BTreeMap>) -> Result { let mut hashes = BTreeMap::new(); for name in EVIDENCE_NAMES { hashes.insert( name, hash(files.get(name).context("APT_RECONCILE_EVIDENCE_MISSING")?), ); } Ok(hash(&serde_json::to_vec(&hashes)?)) } fn verify_proof( c: &Candidate, files: &BTreeMap>, output: &ProbeOutput, now: DateTime, ) -> Result<()> { let baseline = verify_evidence(c, files)?; let p = &output.proof; ensure!( output.effect_state == "known_failed" && output.code == CODE && p.schema_version == 1 && p.kind == "rmm.apt.partial-reconciliation" && p.partial_effect && !p.postconditions_passed && !p.reboot_required, "APT_RECONCILE_PROOF_TYPE" ); 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(), }; let mut expected = baseline; expected.insert( "rmm-mvp-test:all".into(), PackageState { version: "1.0".into(), status: "install ok unpacked".into(), }, ); ensure!( actual == c.probe && p.original_evidence_sha256 == evidence_hash(files)? && 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_RECONCILE_PROOF_BINDING" ); Ok(()) } fn probe(c: &Candidate) -> Result { Ok(serde_json::from_slice(&probe_mode(c, "verify-partial")?)?) } fn probe_mode(c: &Candidate, mode: &str) -> Result> { ensure!( matches!(mode, "verify-partial" | "verify-configured-recovery"), "APT_RECONCILE_PROBE_MODE" ); apt::verify_installation()?; let mut child = Command::new("/usr/bin/python3") .args(["-I", apt::CODE, mode]) .env_clear() .env("PATH", "/usr/bin:/bin") .env("LC_ALL", "C") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::null()) .spawn()?; child .stdin .take() .context("APT_RECONCILE_STDIN")? .write_all(&serde_json::to_vec(&c.probe)?)?; let mut stdout = child.stdout.take().context("APT_RECONCILE_STDOUT")?; let mut bytes = vec![]; let mut chunk = [0; 8192]; let mut overflow = false; loop { let count = stdout.read(&mut chunk)?; if count == 0 { break; } if bytes.len() + count <= 1024 * 1024 { bytes.extend_from_slice(&chunk[..count]); } else { overflow = true; } } let status = child.wait()?; ensure!(status.success() && !overflow, "APT_RECONCILE_NOT_PROVEN"); Ok(bytes) } fn persist(db: &mut Connection, c: &Candidate, proof: &PartialProof) -> Result<()> { let proof_bytes = serde_json::to_vec(&serde_json::to_value(proof)?)?; let proof_sha = hash(&proof_bytes); let outcome = Outcome { state: "failed".into(), stdout: vec![], stderr: vec![], exit_code: Some(0), output_truncated: false, reboot_required: false, evidence: json!({"postconditions_passed":false,"partial_effect":true,"reconciled_postconditions":true, "effect_armed_ledger_id":c.probe.effect_armed_ledger_id,"test_acceptance":true,"noProductionEvidence":true, "apt":{"test_acceptance":true,"noProductionEvidence":true,"partial_effect":true, "fixture_status":"install ok unpacked","fixture_version":"1.0","fixture_payload_sha256":proof.fixture_payload_sha256, "snapshot_sha256":proof.observed_snapshot_sha256,"status_fingerprint":proof.status_fingerprint, "reconciliation_proof_sha256":proof_sha}}), error_code: CODE.into(), }; let classified = serde_json::to_vec(&outcome)?; let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; tx.execute_batch("CREATE TABLE IF NOT EXISTS apt_partial_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_RECONCILE_OUTCOME_CHANGED" ); tx.execute("INSERT INTO apt_partial_reconciliations(grant_id,original_request_sha256,previous_outcome_sha256,previous_outcome,proof_sha256,proof,classified_outcome,checked_at_ms) 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_bytes,classified,proof.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_RECONCILE_OUTCOME_CHANGED" ); // consumed.result stays NULL. Only the normal independently checked signed // RootSync decision may close this particular consumed resource afterward. tx.commit()?; Ok(()) } /// Invoke under the same executor lock as RootSync capture. Failure to prove a /// postcondition leaves the existing unknown outcome and resource fence intact. pub fn refresh( db: &mut Connection, binding: &Binding, guard: &ExecutorGuard, now: DateTime, ) -> Result<()> { guard.check(db)?; // SAFETY: geteuid has no pointers or preconditions. ensure!( unsafe { libc::geteuid() } == 0, "APT_RECONCILE_ROOT_REQUIRED" ); let mut statement=db.prepare("SELECT c.rowid,c.grant_id,c.agent,c.generation,c.job,c.attempt,e.start,e.outcome FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.result IS NULL AND e.outcome IS NOT NULL")?; let rows = statement .query_map([], |r| { Ok(LedgerRow { rowid: r.get(0)?, grant: r.get(1)?, agent: r.get(2)?, generation: r.get(3)?, job: r.get(4)?, attempt: r.get(5)?, start: r.get(6)?, outcome: r.get(7)?, }) })? .collect::>>()?; drop(statement); ensure!(rows.len() <= 256, "APT_RECONCILE_CAPACITY"); for row in rows { if configured::refresh(db, binding, &row, now)? { continue; } let Some(candidate) = eligible(binding, row)? else { continue; }; // These checks are read-only. Any missing/ambiguous evidence is not a // definitive failure and never releases the unknown attempt. let Ok(files) = read_evidence() else { continue; }; if verify_evidence(&candidate, &files).is_err() { continue; } let Ok(output) = probe(&candidate) else { continue; }; if verify_proof(&candidate, &files, &output, now).is_err() { continue; } persist(db, &candidate, &output.proof)?; } Ok(()) } #[path = "apt_configured_reconcile.rs"] mod configured; #[cfg(test)] mod tests { use super::*; use openssl::{pkey::PKey, sign::Signer}; fn fixture() -> (Binding, LedgerRow, BTreeMap>, DateTime) { 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"}}); let tx = json!({"schema_version":1,"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":hash(&serde_json::to_vec(&baseline).unwrap()),"packages":[{"name":"rmm-mvp-test","architecture":"all", "old_version":null,"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 original_grant = Uuid::new_v4(); let original_attempt = Uuid::new_v4(); let marker = serde_json::to_vec( &json!({"transaction_sha256":hash(&txbytes),"job_payload_sha256":"b".repeat(64), "grant_id":original_grant,"attempt_id":original_attempt}), ) .unwrap(); let native_retry = json!({"schema_version":1,"previous_grant_id":original_grant,"previous_attempt_id":original_attempt, "bootstrap_marker_sha256":hash(&marker)}); let manifest = json!({"type":"rmm.apt.helper-action","schema_version":3,"action":"apt-native-acceptance", "execution_profile":"dev-test","transaction_sha256":hash(&txbytes),"resolved_apt_transaction":tx, "transaction_bytes":txbytes,"provider_sha256":"c".repeat(64),"hook_sha256":"d".repeat(64), "apt_config_sha256":hash(b"historical config"),"runtime_sha256":"e".repeat(64),"test_result_id":"partial-test", "native_retry":native_retry}); let job:JobPayload=serde_json::from_value(json!({"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(),"action":{"action":"apt_native_acceptance", "recipe_id":apt::INSTALL_RECIPE,"recipe_version":"1","apt_manifest":manifest},"execution_identity":"root", "not_before":now,"start_before":now+chrono::Duration::minutes(15),"max_runtime_seconds":300,"max_output_bytes":65536})).unwrap(); let job_bytes = encode(&job).unwrap(); let permit = ExecutionPermitPayload { agent_update_plan_id: None, domain: "rmm.execution-permit".into(), schema_version: 1, grant_id: Uuid::new_v4(), authorization_id: Uuid::new_v4(), tenant_id: binding.tenant_id, asset_id: binding.asset_id, agent_id: binding.agent_id, enrollment_generation: 1, assignment_version: 1, job_id: job.job_id, attempt_id: job.attempt_id, plan_hash: "f".repeat(64), job_payload_hash: hash(&job_bytes), 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 permit_bytes = encode(&permit).unwrap(); let request = Request { job_bytes, signature: Signer::new_without_digest(&key) .unwrap() .sign_oneshot_to_vec(&permit_bytes) .unwrap(), permit_bytes, authorization_id: permit.authorization_id, plan_hash: permit.plan_hash.clone(), }; let boot = Uuid::new_v4(); let ledger = format!("apt-{}-1", 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,"apt":{"test_acceptance":true,"noProductionEvidence":true}}), ..Outcome::unknown("DPKG_INCONSISTENT") }; let row = LedgerRow { rowid: 1, 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 c = eligible(&binding, row.clone()).unwrap().unwrap(); let mut files = BTreeMap::new(); files.insert("signed-action.json".into(), c.request.job_bytes.clone()); files.insert( "expectation.json".into(), c.manifest.transaction_bytes.clone(), ); files.insert( "baseline.json".into(), serde_json::to_vec(&baseline).unwrap(), ); files.insert("apt.conf".into(), b"historical config".to_vec()); let context = 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":permit.not_before.timestamp_millis(),"start_before_ms":permit.start_before.timestamp_millis(), "boot_id":boot,"monotonic_start_before_ns":1}); let objects = [ ("context.json", context), ( "launch.json", json!({"transaction_sha256":c.probe.transaction_sha256,"effect_armed_ledger_id":ledger}), ), ( "sandbox-result.json", json!({"transaction_sha256":c.probe.transaction_sha256,"apt_exit_code":0,"reboot_required":false}), ), ( "sandbox-ready.json", json!({"transaction_sha256":c.probe.transaction_sha256,"sandbox_version":1}), ), ("native-prechecks.json", native_prechecks(&c)), ( "hook-armed.json", json!({"transaction_sha256":c.probe.transaction_sha256,"effect_armed_ledger_id":ledger,"grant_id":permit.grant_id, "protocol_sha256":"a".repeat(64),"armed_at_ms":now.timestamp_millis()}), ), ( "bootstrap-retry-rmm-apt-fixture-install-1.0.json", json!({"transaction_sha256":c.probe.transaction_sha256, "job_payload_sha256":c.probe.job_payload_sha256,"effect_armed_ledger_id":ledger,"grant_id":permit.grant_id,"attempt_id":job.attempt_id, "native_retry":native_retry,"previous_evidence_sha256":"b".repeat(64)}), ), ]; for (name, value) in objects { files.insert(name.into(), serde_json::to_vec(&value).unwrap()); } files.insert( "bootstrap-attempt-rmm-apt-fixture-install-1.0.json".into(), marker, ); (binding, row, files, now) } fn output(c: &Candidate, files: &BTreeMap>, now: DateTime) -> ProbeOutput { let mut snapshot = verify_evidence(c, files).unwrap(); snapshot.insert( "rmm-mvp-test:all".into(), PackageState { version: "1.0".into(), status: "install ok unpacked".into(), }, ); ProbeOutput { effect_state: "known_failed".into(), code: CODE.into(), proof: PartialProof { schema_version: 1, kind: "rmm.apt.partial-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_hash(files).unwrap(), original_baseline_sha256: c .manifest .resolved_apt_transaction .baseline_sha256 .clone(), observed_snapshot_sha256: hash( &serde_json::to_vec(&serde_json::to_value(&snapshot).unwrap()).unwrap(), ), snapshot, status_fingerprint: "a".repeat(64), fixture_payload_sha256: hash(b"1.0\n"), checked_at_ms: now.timestamp_millis(), partial_effect: true, postconditions_passed: false, reboot_required: false, }, } } #[test] fn original_signature_identity_marker_and_complete_evidence_are_required() { let (binding, row, files, now) = fixture(); let c = eligible(&binding, row.clone()).unwrap().unwrap(); verify_proof(&c, &files, &output(&c, &files, now), now).unwrap(); let mut wrong = row.clone(); wrong.agent = Uuid::new_v4().to_string(); assert!(eligible(&binding, wrong).is_err()); let mut wrong = row; let mut start: Value = serde_json::from_slice(&wrong.start).unwrap(); start["request"]["signature"][0] = json!((start["request"]["signature"][0].as_u64().unwrap() + 1) % 256); wrong.start = serde_json::to_vec(&start).unwrap(); assert!(eligible(&binding, wrong).is_err()); for name in [ "context.json", "signed-action.json", "expectation.json", "baseline.json", "launch.json", "sandbox-result.json", "native-prechecks.json", "hook-armed.json", "bootstrap-attempt-rmm-apt-fixture-install-1.0.json", ] { let mut altered = files.clone(); altered.insert(name.into(), b"{}".to_vec()); assert!(verify_evidence(&c, &altered).is_err(), "{name}"); } } #[test] fn partial_snapshot_cannot_hide_other_changes_or_turn_into_success() { let (binding, row, files, now) = fixture(); let c = eligible(&binding, row).unwrap().unwrap(); for variation in 0..6 { let mut o = output(&c, &files, now); match variation { 0 => { o.proof .snapshot .get_mut("base-files:amd64") .unwrap() .version = "changed".into() } 1 => { o.proof.snapshot.get_mut("rmm-mvp-test:all").unwrap().status = "install ok installed".into() } 2 => o.proof.job_id = Uuid::new_v4(), 3 => o.proof.partial_effect = false, 4 => o.proof.checked_at_ms -= 60000, _ => o.proof.postconditions_passed = true, } assert!(verify_proof(&c, &files, &o, now).is_err()); } } #[test] fn append_only_proof_preserves_unknown_and_consumption_until_signed_sync() { let (binding, row, files, now) = fixture(); let c = eligible(&binding, row.clone()).unwrap().unwrap(); let output = output(&c, &files, now); verify_proof(&c, &files, &output, now).unwrap(); 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(), row.outcome], ) .unwrap(); persist(&mut db, &c, &output.proof).unwrap(); assert!( db.query_row("SELECT result IS NULL FROM consumed", [], |r| r .get::<_, bool>(0)) .unwrap() ); let saved: Vec = db .query_row( "SELECT previous_outcome FROM apt_partial_reconciliations", [], |r| r.get(0), ) .unwrap(); assert_eq!(saved, c.original_outcome); let classified: Vec = db .query_row("SELECT outcome FROM execution_evidence", [], |r| r.get(0)) .unwrap(); let outcome: Outcome = serde_json::from_slice(&classified).unwrap(); assert_eq!(outcome.state, "failed"); assert_eq!(outcome.error_code, CODE); assert_eq!(outcome.evidence["postconditions_passed"], false); assert_eq!(outcome.evidence["partial_effect"], true); assert!(persist(&mut db, &c, &output.proof).is_err()); assert_eq!( db.query_row( "SELECT count(*) FROM apt_partial_reconciliations", [], |r| r.get::<_, i64>(0) ) .unwrap(), 1 ); assert_eq!( db.query_row("SELECT outcome FROM execution_evidence", [], |r| r .get::<_, Vec>(0)) .unwrap(), classified ); } #[test] fn new_recovery_requires_exact_closed_partial_signed_history_and_immutable_proof() { let (binding, row, files, now) = fixture(); let c = eligible(&binding, row.clone()).unwrap().unwrap(); let proof = output(&c, &files, now).proof; let mut db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE consumed(grant_id TEXT PRIMARY KEY,agent TEXT,generation INTEGER,job TEXT,attempt TEXT,result BLOB);CREATE TABLE execution_evidence(grant_id TEXT PRIMARY KEY,start BLOB,outcome BLOB);").unwrap(); db.execute("INSERT INTO consumed(rowid,grant_id,agent,generation,job,attempt,result) VALUES(?1,?2,?3,?4,?5,?6,NULL)",params![row.rowid,row.grant,row.agent,row.generation,row.job,row.attempt]).unwrap(); db.execute( "INSERT INTO execution_evidence VALUES(?1,?2,?3)", params![row.grant, row.start, row.outcome], ) .unwrap(); persist(&mut db, &c, &proof).unwrap(); assert!(closed_partial_from(&db, &binding, None, || Ok(files.clone())).is_err()); db.execute( "UPDATE consumed SET result=(SELECT outcome FROM execution_evidence)", [], ) .unwrap(); let closed = closed_partial_from(&db, &binding, None, || Ok(files.clone())).unwrap(); assert_eq!(closed.reference.previous_grant_id, c.probe.grant_id); assert_eq!(closed.reference.previous_attempt_id, c.probe.attempt_id); assert_eq!(closed.baseline_sha256, proof.observed_snapshot_sha256); let mut changed = closed.reference.clone(); changed.previous_attempt_id = Uuid::new_v4(); assert!(closed_partial_from(&db, &binding, Some(&changed), || Ok(files.clone())).is_err()); let mut changed_files = files.clone(); changed_files.insert("signed-action.json".into(), b"{}".to_vec()); assert!(closed_partial_from(&db, &binding, None, || Ok(changed_files.clone())).is_err()); db.execute("UPDATE apt_partial_reconciliations SET proof=x'7b7d'", []) .unwrap(); assert!(closed_partial_from(&db, &binding, None, || Ok(files.clone())).is_err()); } }