feat: preserve failed APT history for one signed UI-approved recovery
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-13 15:50:34 +01:00
parent a5c2dce4fb
commit fd7225600b
18 changed files with 1345 additions and 34 deletions
+249
View File
@@ -38,6 +38,253 @@ fn actual_domain_native_action_roundtrips_exact_signed_manifest_to_helper() {
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<openssl::pkey::Private>,
) {
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<u8> = 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<u8> = 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);
@@ -70,6 +317,7 @@ fn consumed_parent_row_and_original_start_request_are_mandatory() {
// 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(),
@@ -149,6 +397,7 @@ fn manifest(bootstrap: bool) -> (ProviderConfig, AptExecutionManifest) {
apt_config_sha256: config.apt_config_sha256.clone(),
runtime_sha256: config.runtime_sha256.clone(),
test_result_id: "fixture-test-1".into(),
native_retry: None,
};
(config, manifest)
}