776 lines
32 KiB
Rust
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();
|
|
}
|