Files
rust-discovery/crates/privileged-helper/src/apt/tests.rs
T
2026-11-14 16:35:11 +01:00

776 lines
32 KiB
Rust

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<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);
let package = &m.resolved_apt_transaction.packages[0];
let receipt = PrefetchReceipt {
schema_version: 1,
sha256: package.sha256.clone(),
size: package.size,
sealed_at_ms: 1000,
};
receipt.validate(package, 1000).unwrap();
assert!(receipt.validate(package, 999).is_err());
let changed = PackageArchive {
size: 1,
..package.clone()
};
assert!(receipt.validate(&changed, 1001).is_err());
let changed = PackageArchive {
sha256: "0".repeat(64),
..package.clone()
};
assert!(receipt.validate(&changed, 1001).is_err());
assert!(serde_json::from_slice::<PrefetchReceipt>(br#"{"schema_version":1,"sha256":"x","size":1,"sealed_at_ms":1000,"download_url":"https://untrusted.invalid"}"#).is_err());
}
#[test]
fn consumed_parent_row_and_original_start_request_are_mandatory() {
let (binding, request, _, now) = signed_request();
let (job, permit) = binding.verify(&request, now).unwrap();
// Test-only construction exercises the ledger validator without granting
// access to the root process path or weakening the public constructor.
let prepared = PreparedApt {
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<openssl::pkey::Private>,
DateTime<Utc>,
) {
let key = PKey::generate_ed25519().unwrap();
let raw = key.raw_public_key().unwrap();
let now = Utc::now();
let binding = Binding {
tenant_id: Uuid::new_v4(),
asset_id: Uuid::new_v4(),
agent_id: Uuid::new_v4(),
enrollment_generation: 1,
assignment_version: 1,
public_key_hex: hex::encode(&raw),
};
let job = JobPayload {
schema_version: 1,
tenant_id: binding.tenant_id,
asset_id: binding.asset_id,
agent_id: binding.agent_id,
enrollment_generation: 1,
assignment_version: 1,
job_id: Uuid::new_v4(),
attempt_id: Uuid::new_v4(),
// Existing supported typed action supplies a valid cryptographic/ledger
// fixture only. It is never executed and the APT policy rejects it.
action: Action::RunScript {
interpreter: "posix_sh".into(),
script_utf8: "true".into(),
arguments: vec![],
expected_stdout: None,
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::<ActionCarrier>(raw).is_err());
let mut m = serde_json::to_value(manifest(false).1).unwrap();
m["parameters"] = serde_json::json!({});
assert!(serde_json::from_value::<AptExecutionManifest>(m).is_err());
}
#[test]
fn create_only_payloads_fsync_and_hostile_files_fail_closed() {
let dir = temporary();
let file = dir.join("payload");
write_once(&file, b"known", 0o600).unwrap();
assert_eq!(fs::read(&file).unwrap(), b"known");
assert!(write_once(&file, b"replacement", 0o600).is_err());
let link = dir.join("link");
std::os::unix::fs::symlink(&file, &link).unwrap();
assert!(write_once(&link, b"replacement", 0o600).is_err());
assert!(read_sealed(&file, 64).is_err()); // never accept this unprivileged /tmp store as root trusted
assert!(verify_installation().is_err()); // no deployment/mutation during tests
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn no_artifact_or_record_is_not_success() {
let (_, m) = manifest(true);
let (binding, request, _, now) = signed_request();
let (_, p) = binding.verify(&request, now).unwrap();
assert!(verify_prefetched(&m, &p).is_err());
assert!(
map_driver_result(
br#"{"effect_state":"verified","code":"POSTCONDITIONS_VERIFIED","evidence":{}}"#,
Some(0),
false,
&m,
"ledger"
)
.is_err()
);
assert!(map_driver_result(b"not-json", Some(0), false, &m, "ledger").is_err());
}
#[test]
fn structured_effect_state_not_process_exit_and_armed_failures_stay_unknown() {
let (_, m) = manifest(true);
let ledger = "ledger-1";
let p = &m.resolved_apt_transaction.packages[0];
let result = serde_json::json!({"effect_state":"verified","code":"POSTCONDITIONS_VERIFIED","evidence":{
"test_acceptance":true,"noProductionEvidence":true,"test_result_id":m.test_result_id,"native_record_sha256":"a".repeat(64),
"snapshot_sha256":"b".repeat(64),"fixture_payload_sha256":hash(b"1.0\n"),"effect_armed_ledger_id":ledger,"reboot_required":false,
"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();
}