579 lines
23 KiB
Rust
579 lines
23 KiB
Rust
//! Signature/codec/consumption contracts, with no transport or OS execution.
|
|
use chrono::{DateTime, Duration, Utc};
|
|
use ed25519_dalek::{Signer, SigningKey};
|
|
#[cfg(unix)]
|
|
use rmm_agent_core::crypto::{DalekVerifier, Ed25519Verifier};
|
|
use rmm_agent_core::{
|
|
auth::{Binding, Outcome, Request},
|
|
jobs, ledger,
|
|
};
|
|
use rmm_domain::jobs::{Action, ExecutionPermitPayload, JobPayload, encode, hash};
|
|
use rmm_protocol::JobOffer;
|
|
use rusqlite::Connection;
|
|
use uuid::Uuid;
|
|
|
|
fn fixture() -> (Binding, Request, ExecutionPermitPayload, DateTime<Utc>) {
|
|
let key = SigningKey::from_bytes(&[9; 32]);
|
|
let id = Uuid::from_u128(1);
|
|
let now = DateTime::parse_from_rfc3339("2026-11-14T00:00:00Z")
|
|
.unwrap()
|
|
.with_timezone(&Utc);
|
|
let binding = Binding {
|
|
tenant_id: id,
|
|
asset_id: Uuid::from_u128(2),
|
|
agent_id: Uuid::from_u128(3),
|
|
enrollment_generation: 2,
|
|
assignment_version: 4,
|
|
public_key_hex: hex::encode(key.verifying_key().as_bytes()),
|
|
};
|
|
let job = JobPayload {
|
|
schema_version: 1,
|
|
tenant_id: binding.tenant_id,
|
|
asset_id: binding.asset_id,
|
|
agent_id: binding.agent_id,
|
|
enrollment_generation: 2,
|
|
assignment_version: 4,
|
|
job_id: Uuid::from_u128(5),
|
|
attempt_id: Uuid::from_u128(6),
|
|
action: Action::RunScript {
|
|
interpreter: "posix_sh".into(),
|
|
script_utf8: "printf 'Hello\\n'\n".into(),
|
|
arguments: vec![],
|
|
expected_stdout: Some("Hello\n".into()),
|
|
windows_execution_profile: None,
|
|
privileged_script_profile: None,
|
|
},
|
|
execution_identity: "agent_service".into(),
|
|
not_before: now - Duration::minutes(1),
|
|
start_before: now + Duration::minutes(5),
|
|
max_runtime_seconds: 10,
|
|
max_output_bytes: 4096,
|
|
};
|
|
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::from_u128(7),
|
|
authorization_id: Uuid::from_u128(8),
|
|
tenant_id: binding.tenant_id,
|
|
asset_id: binding.asset_id,
|
|
agent_id: binding.agent_id,
|
|
enrollment_generation: 2,
|
|
assignment_version: 4,
|
|
job_id: job.job_id,
|
|
attempt_id: job.attempt_id,
|
|
plan_hash: hash(b"immutable approved plan"),
|
|
job_payload_hash: hash(&job_bytes),
|
|
action: job.action.name().into(),
|
|
execution_identity: job.execution_identity,
|
|
max_runtime_seconds: 10,
|
|
not_before: now - Duration::seconds(1),
|
|
start_before: now + Duration::seconds(59),
|
|
key_id: hash(key.verifying_key().as_bytes()),
|
|
};
|
|
let permit_bytes = encode(&permit).unwrap();
|
|
let signature = key.sign(&permit_bytes).to_bytes().to_vec();
|
|
let request = Request {
|
|
job_bytes,
|
|
permit_bytes,
|
|
signature,
|
|
plan_hash: permit.plan_hash.clone(),
|
|
authorization_id: permit.authorization_id,
|
|
};
|
|
(binding, request, permit, now)
|
|
}
|
|
|
|
#[test]
|
|
fn historical_request_and_binding_codecs_keep_field_order_arrays_and_strictness() {
|
|
let request = Request {
|
|
job_bytes: vec![0, 255],
|
|
permit_bytes: vec![1],
|
|
signature: vec![2],
|
|
plan_hash: "ab".into(),
|
|
authorization_id: Uuid::nil(),
|
|
};
|
|
let expected = r#"{"job_bytes":[0,255],"permit_bytes":[1],"signature":[2],"plan_hash":"ab","authorization_id":"00000000-0000-0000-0000-000000000000"}"#;
|
|
assert_eq!(serde_json::to_vec(&request).unwrap(), expected.as_bytes());
|
|
let parsed: Request = serde_json::from_str(expected).unwrap();
|
|
assert_eq!(serde_json::to_string(&parsed).unwrap(), expected);
|
|
assert!(
|
|
serde_json::from_str::<Request>(
|
|
&expected.replace("\"job_bytes\"", "\"extra\":0,\"job_bytes\"")
|
|
)
|
|
.is_err()
|
|
);
|
|
let binding = Binding {
|
|
tenant_id: Uuid::nil(),
|
|
asset_id: Uuid::nil(),
|
|
agent_id: Uuid::nil(),
|
|
enrollment_generation: 1,
|
|
assignment_version: 2,
|
|
public_key_hex: "key".into(),
|
|
};
|
|
assert_eq!(
|
|
serde_json::to_string(&binding).unwrap(),
|
|
r#"{"tenant_id":"00000000-0000-0000-0000-000000000000","asset_id":"00000000-0000-0000-0000-000000000000","agent_id":"00000000-0000-0000-0000-000000000000","enrollment_generation":1,"assignment_version":2,"public_key_hex":"key"}"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn exact_permit_bytes_time_and_all_identity_hash_bindings_are_required() {
|
|
let (binding, request, permit, now) = fixture();
|
|
assert_eq!(binding.verify(&request, now).unwrap().1, permit);
|
|
assert!(binding.verify(&request, permit.not_before).is_ok());
|
|
assert!(
|
|
binding
|
|
.verify(&request, permit.not_before - Duration::nanoseconds(1))
|
|
.is_err()
|
|
);
|
|
assert!(binding.verify(&request, permit.start_before).is_err());
|
|
let key = SigningKey::from_bytes(&[9; 32]);
|
|
let value = serde_json::to_value(&permit).unwrap();
|
|
for (field, replacement) in [
|
|
("domain", serde_json::json!("rmm.reconciliation-decision")),
|
|
("schema_version", serde_json::json!(2)),
|
|
("tenant_id", serde_json::json!(Uuid::new_v4())),
|
|
("asset_id", serde_json::json!(Uuid::new_v4())),
|
|
("agent_id", serde_json::json!(Uuid::new_v4())),
|
|
("enrollment_generation", serde_json::json!(3)),
|
|
("assignment_version", serde_json::json!(5)),
|
|
("job_id", serde_json::json!(Uuid::new_v4())),
|
|
("attempt_id", serde_json::json!(Uuid::new_v4())),
|
|
("authorization_id", serde_json::json!(Uuid::new_v4())),
|
|
("plan_hash", serde_json::json!(hash(b"other plan"))),
|
|
(
|
|
"job_payload_hash",
|
|
serde_json::json!(hash(b"different bytes")),
|
|
),
|
|
("action", serde_json::json!("reboot")),
|
|
("execution_identity", serde_json::json!("root")),
|
|
("max_runtime_seconds", serde_json::json!(11)),
|
|
("key_id", serde_json::json!(hash(b"otherkey"))),
|
|
("grant_id", serde_json::json!(Uuid::nil())),
|
|
(
|
|
"start_before",
|
|
serde_json::json!(now + Duration::seconds(60)),
|
|
),
|
|
] {
|
|
let mut value = value.clone();
|
|
value[field] = replacement;
|
|
let changed: ExecutionPermitPayload = serde_json::from_value(value).unwrap();
|
|
let mut changed_request = request.clone();
|
|
changed_request.permit_bytes = encode(&changed).unwrap();
|
|
changed_request.signature = key.sign(&changed_request.permit_bytes).to_bytes().to_vec();
|
|
assert!(binding.verify(&changed_request, now).is_err(), "{field}");
|
|
}
|
|
let mut changed = request.clone();
|
|
changed.job_bytes.push(b' ');
|
|
assert!(binding.verify(&changed, now).is_err());
|
|
let mut changed = request.clone();
|
|
changed.signature[0] ^= 1;
|
|
assert!(binding.verify(&changed, now).is_err());
|
|
let mut changed = request;
|
|
changed.signature.truncate(63);
|
|
assert!(binding.verify(&changed, now).is_err());
|
|
// Changing only the process policy is a payload mutation, even with the
|
|
// same script/attempt and a still valid original signature.
|
|
let (_, mut request, mut permit, _) = fixture();
|
|
let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap();
|
|
job.action = Action::RunScript {
|
|
interpreter: "powershell".into(),
|
|
script_utf8: "Write-Output 'Hello'\r\n".into(),
|
|
arguments: vec![],
|
|
expected_stdout: Some("Hello\r\n".into()),
|
|
windows_execution_profile: None,
|
|
privileged_script_profile: None,
|
|
};
|
|
request.job_bytes = encode(&job).unwrap();
|
|
permit.job_payload_hash = hash(&request.job_bytes);
|
|
request.permit_bytes = encode(&permit).unwrap();
|
|
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
|
|
binding.verify(&request, now).unwrap();
|
|
if let Action::RunScript {
|
|
windows_execution_profile,
|
|
..
|
|
} = &mut job.action
|
|
{
|
|
*windows_execution_profile =
|
|
Some(rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned);
|
|
}
|
|
request.job_bytes = encode(&job).unwrap();
|
|
assert!(binding.verify(&request, now).is_err());
|
|
permit.job_payload_hash = hash(&request.job_bytes);
|
|
request.permit_bytes = encode(&permit).unwrap();
|
|
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
|
|
binding.verify(&request, now).unwrap();
|
|
// The exact fixed Event Log source/window/limits are original signed bytes.
|
|
job.action = Action::QueryLogs {
|
|
unit: rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
|
|
since: now - chrono::Duration::hours(1),
|
|
until: now,
|
|
max_lines: 1000,
|
|
};
|
|
request.job_bytes = encode(&job).unwrap();
|
|
permit.action = job.action.name().into();
|
|
permit.job_payload_hash = hash(&request.job_bytes);
|
|
request.permit_bytes = encode(&permit).unwrap();
|
|
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
|
|
binding.verify(&request, now).unwrap();
|
|
let mut wrong_source = job.clone();
|
|
if let Action::QueryLogs { unit, .. } = &mut wrong_source.action {
|
|
*unit = "Security".into();
|
|
}
|
|
let mut changed = request.clone();
|
|
changed.job_bytes = encode(&wrong_source).unwrap();
|
|
assert!(binding.verify(&changed, now).is_err());
|
|
for (runtime, bytes) in [(9, 4096), (121, 4096), (10, 1023), (10, 65537)] {
|
|
let mut changed_job = job.clone();
|
|
changed_job.max_runtime_seconds = runtime;
|
|
changed_job.max_output_bytes = bytes;
|
|
let mut changed_permit = permit.clone();
|
|
changed_permit.max_runtime_seconds = runtime;
|
|
let mut changed = request.clone();
|
|
changed.job_bytes = encode(&changed_job).unwrap();
|
|
changed_permit.job_payload_hash = hash(&changed.job_bytes);
|
|
changed.permit_bytes = encode(&changed_permit).unwrap();
|
|
changed.signature = key.sign(&changed.permit_bytes).to_bytes().to_vec();
|
|
assert!(binding.verify(&changed, now).is_err());
|
|
}
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering() {
|
|
use openssl::{
|
|
pkey::PKey,
|
|
sign::{Signer as OpenSigner, Verifier},
|
|
};
|
|
let key = PKey::generate_ed25519().unwrap();
|
|
let public = key.raw_public_key().unwrap();
|
|
let bytes = b"exact stored signed payload\r\n";
|
|
let signature = OpenSigner::new_without_digest(&key)
|
|
.unwrap()
|
|
.sign_oneshot_to_vec(bytes)
|
|
.unwrap();
|
|
let verify_openssl = |message: &[u8], signature: &[u8]| {
|
|
Verifier::new_without_digest(&key)
|
|
.unwrap()
|
|
.verify_oneshot(signature, message)
|
|
.unwrap_or(false)
|
|
};
|
|
for message in [bytes.as_slice(), b"exact stored signed payload\n", b""] {
|
|
assert_eq!(
|
|
DalekVerifier.verify(&public, message, &signature).unwrap(),
|
|
verify_openssl(message, &signature)
|
|
);
|
|
}
|
|
let mut changed = signature.clone();
|
|
changed[0] ^= 1;
|
|
for signature in [&signature[..], &changed[..], &signature[..63]] {
|
|
assert_eq!(
|
|
DalekVerifier.verify(&public, bytes, signature).unwrap(),
|
|
verify_openssl(bytes, signature)
|
|
);
|
|
}
|
|
assert!(!DalekVerifier.verify(&[0; 32], bytes, &[0; 64]).unwrap());
|
|
assert!(!DalekVerifier.verify(&[0; 31], bytes, &signature).unwrap());
|
|
// Reverse direction uses raw Ed25519, never prehashes the message.
|
|
let signing = SigningKey::from_bytes(&[11; 32]);
|
|
let p = PKey::public_key_from_raw_bytes(
|
|
signing.verifying_key().as_bytes(),
|
|
openssl::pkey::Id::ED25519,
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
Verifier::new_without_digest(&p)
|
|
.unwrap()
|
|
.verify_oneshot(&signing.sign(bytes).to_bytes(), bytes)
|
|
.unwrap()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn consumed_attempt_and_unknown_lock_survive_reopen_without_reexecution() {
|
|
let (_, request, permit, now) = fixture();
|
|
let path = std::env::temp_dir().join(format!("rmm-core-ledger-{}", Uuid::new_v4()));
|
|
{
|
|
let mut db = Connection::open(&path).unwrap();
|
|
ledger::initialize_ledger(&db).unwrap();
|
|
ledger::consume(&mut db, &permit).unwrap();
|
|
ledger::save_start(&db, &permit, &request, Uuid::from_u128(9), now).unwrap();
|
|
ledger::finish(&db, &permit, &Outcome::unknown("EFFECT_UNKNOWN")).unwrap();
|
|
}
|
|
{
|
|
let mut db = Connection::open(&path).unwrap();
|
|
ledger::initialize_ledger(&db).unwrap();
|
|
assert!(ledger::consume(&mut db, &permit).is_err());
|
|
let mut replacement = permit.clone();
|
|
replacement.grant_id = Uuid::new_v4();
|
|
assert!(ledger::consume(&mut db, &replacement).is_err());
|
|
assert_eq!(
|
|
db.query_row(
|
|
"SELECT count(*) FROM consumed WHERE result IS NULL",
|
|
[],
|
|
|r| r.get::<_, u32>(0)
|
|
)
|
|
.unwrap(),
|
|
1
|
|
);
|
|
assert_eq!(
|
|
db.query_row("PRAGMA max_page_count", [], |r| r.get::<_, u32>(0))
|
|
.unwrap(),
|
|
262144
|
|
);
|
|
}
|
|
std::fs::remove_file(path).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn portable_acceptance_requires_platform_capability_and_exact_redelivery() {
|
|
let (binding, request, permit, _) = fixture();
|
|
let offer = JobOffer {
|
|
job_id: permit.job_id.to_string(),
|
|
attempt_id: permit.attempt_id.to_string(),
|
|
payload_bytes: request.job_bytes,
|
|
job_payload_hash: permit.job_payload_hash,
|
|
plan_hash: permit.plan_hash,
|
|
authorization_id: permit.authorization_id.to_string(),
|
|
};
|
|
let db = Connection::open_in_memory().unwrap();
|
|
db.execute_batch("CREATE TABLE job_attempts(job TEXT,attempt TEXT,offer BLOB,state TEXT,revision INTEGER DEFAULT 0,grant_id TEXT DEFAULT '',cancel_requested INTEGER DEFAULT 0,PRIMARY KEY(job,attempt))").unwrap();
|
|
assert!(jobs::accept(&db, &binding, &offer, |_| false).is_err());
|
|
assert_eq!(
|
|
db.query_row("SELECT count(*) FROM job_attempts", [], |r| r
|
|
.get::<_, u32>(0))
|
|
.unwrap(),
|
|
0
|
|
);
|
|
assert!(jobs::accept(&db, &binding, &offer, |_| true).unwrap());
|
|
assert!(!jobs::accept(&db, &binding, &offer, |_| true).unwrap());
|
|
let mut changed = offer.clone();
|
|
changed.authorization_id = Uuid::new_v4().to_string();
|
|
assert!(jobs::accept(&db, &binding, &changed, |_| true).is_err());
|
|
jobs::reserve_request(&db, &offer).unwrap();
|
|
assert!(jobs::reserve_request(&db, &offer).is_err());
|
|
assert_eq!(jobs::transition(&db, &offer, "unknown", "").unwrap(), 1);
|
|
assert!(jobs::next(&db).unwrap().is_none());
|
|
assert!(jobs::transition(&db, &offer, "running", "").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure() {
|
|
let (_, request, permit, now) = fixture();
|
|
let mut db = Connection::open_in_memory().unwrap();
|
|
ledger::initialize_ledger(&db).unwrap();
|
|
assert!(ledger::begin_execution(&mut db, &permit, &request, Uuid::nil(), now).is_err());
|
|
assert_eq!(
|
|
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
|
|
.unwrap(),
|
|
0
|
|
);
|
|
db.execute_batch("CREATE TRIGGER refuse_start BEFORE INSERT ON execution_evidence BEGIN SELECT RAISE(ABORT,'fixture storage failure'); END;").unwrap();
|
|
assert!(ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).is_err());
|
|
assert_eq!(
|
|
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
|
|
.unwrap(),
|
|
0
|
|
);
|
|
assert_eq!(
|
|
db.query_row::<u32, _, _>("SELECT count(*) FROM execution_evidence", [], |r| r.get(0))
|
|
.unwrap(),
|
|
0
|
|
);
|
|
db.execute_batch("DROP TRIGGER refuse_start").unwrap();
|
|
ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).unwrap();
|
|
assert!(ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).is_err());
|
|
assert_eq!(
|
|
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
|
|
.unwrap(),
|
|
1
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence() {
|
|
let (binding, request, permit, now) = fixture();
|
|
let mut db = Connection::open_in_memory().unwrap();
|
|
ledger::initialize_ledger(&db).unwrap();
|
|
ledger::begin_execution(&mut db, &permit, &request, Uuid::from_u128(9), now).unwrap();
|
|
let offer = JobOffer {
|
|
job_id: permit.job_id.to_string(),
|
|
attempt_id: permit.attempt_id.to_string(),
|
|
payload_bytes: request.job_bytes.clone(),
|
|
job_payload_hash: permit.job_payload_hash.clone(),
|
|
plan_hash: permit.plan_hash.clone(),
|
|
authorization_id: permit.authorization_id.to_string(),
|
|
};
|
|
assert!(
|
|
jobs::recover_interrupted_outcome(&db, &binding, &offer, &permit.grant_id.to_string())
|
|
.unwrap()
|
|
.is_none()
|
|
);
|
|
let mut original = Outcome::unknown("");
|
|
original.state = "succeeded".into();
|
|
original.stdout = b"Hello\n".to_vec();
|
|
original.exit_code = Some(0);
|
|
original.evidence = serde_json::json!({"postconditions_passed":true});
|
|
ledger::persist_outcome(&db, &permit, &original).unwrap();
|
|
let saved: Vec<u8> = db
|
|
.query_row("SELECT outcome FROM execution_evidence", [], |r| r.get(0))
|
|
.unwrap();
|
|
ledger::persist_outcome(&db, &permit, &original).unwrap();
|
|
assert_eq!(
|
|
saved,
|
|
db.query_row::<Vec<u8>, _, _>("SELECT outcome FROM execution_evidence", [], |r| r.get(0))
|
|
.unwrap()
|
|
);
|
|
assert_eq!(
|
|
db.query_row::<u32, _, _>(
|
|
"SELECT count(*) FROM consumed WHERE result IS NULL",
|
|
[],
|
|
|r| r.get(0)
|
|
)
|
|
.unwrap(),
|
|
1
|
|
);
|
|
assert!(ledger::persist_outcome(&db, &permit, &Outcome::unknown("late uncertainty")).is_err());
|
|
assert!(ledger::finish(&db, &permit, &Outcome::unknown("late uncertainty")).is_err());
|
|
let recovered =
|
|
jobs::recover_interrupted_outcome(&db, &binding, &offer, &permit.grant_id.to_string())
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_eq!(serde_json::to_vec(&recovered).unwrap(), saved);
|
|
let mut forged = binding.clone();
|
|
forged.public_key_hex =
|
|
hex::encode(SigningKey::from_bytes(&[31; 32]).verifying_key().as_bytes());
|
|
assert!(
|
|
jobs::recover_interrupted_outcome(&db, &forged, &offer, &permit.grant_id.to_string())
|
|
.is_err()
|
|
);
|
|
let mut changed = offer.clone();
|
|
changed.authorization_id = Uuid::new_v4().to_string();
|
|
assert!(
|
|
jobs::recover_interrupted_outcome(&db, &binding, &changed, &permit.grant_id.to_string())
|
|
.is_err()
|
|
);
|
|
let mut changed = permit.clone();
|
|
changed.assignment_version += 1;
|
|
assert!(ledger::persist_outcome(&db, &changed, &original).is_err());
|
|
ledger::finish(&db, &permit, &original).unwrap();
|
|
ledger::finish(&db, &permit, &original).unwrap();
|
|
assert_eq!(
|
|
db.query_row::<u32, _, _>("SELECT count(*) FROM consumed", [], |r| r.get(0))
|
|
.unwrap(),
|
|
1
|
|
);
|
|
assert!(ledger::consume(&mut db, &permit).is_err());
|
|
let mut corrupted: serde_json::Value = db
|
|
.query_row("SELECT start FROM execution_evidence", [], |r| {
|
|
r.get::<_, Vec<u8>>(0)
|
|
})
|
|
.map(|b| serde_json::from_slice(&b).unwrap())
|
|
.unwrap();
|
|
let changed = corrupted["request"]["signature"][0].as_u64().unwrap() ^ 1;
|
|
corrupted["request"]["signature"][0] = serde_json::json!(changed);
|
|
db.execute(
|
|
"UPDATE execution_evidence SET start=?1",
|
|
[serde_json::to_vec(&corrupted).unwrap()],
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
jobs::recover_interrupted_outcome(&db, &binding, &offer, &permit.grant_id.to_string())
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn historical_msi_nonstart_keeps_full_signature_binding_and_never_becomes_root_authority() {
|
|
use rmm_agent_core::auth::HelperIdentity;
|
|
use rmm_domain::windows_execution::*;
|
|
let (binding, mut request, mut permit, now) = fixture();
|
|
let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap();
|
|
let recipe = WindowsMsiRecipe {
|
|
schema_version: 1,
|
|
recipe_id: MSI_RECIPE_ID.into(),
|
|
recipe_version: "1".into(),
|
|
platform: "windows".into(),
|
|
upgrade_code: MSI_UPGRADE_CODE.into(),
|
|
architecture: Architecture::X64,
|
|
context: InstallContext::Machine,
|
|
command_profile: MsiCommandProfile::FixtureQuietNoRebootV1,
|
|
artifact: MsiArtifact {
|
|
artifact_id: Uuid::from_u128(19),
|
|
sha256: "ab".repeat(32),
|
|
bytes: 32,
|
|
},
|
|
postcondition: MsiPostcondition {
|
|
product_code: MSI_PRODUCT_CODE.into(),
|
|
product_version: MSI_VERSION.into(),
|
|
payload_path: MSI_PAYLOAD.into(),
|
|
payload_sha256: MSI_PAYLOAD_10_SHA256.into(),
|
|
payload_bytes: MSI_PAYLOAD_BYTES,
|
|
},
|
|
no_reboot: true,
|
|
package_code: None,
|
|
predecessor: None,
|
|
};
|
|
let manifest = ResolvedWindowsMsi {
|
|
recipe_sha256: recipe.sha256().unwrap(),
|
|
recipe,
|
|
};
|
|
job.action = Action::EnsurePackage {
|
|
provider: "msi".into(),
|
|
package: MSI_PACKAGE_ID.into(),
|
|
version: MSI_VERSION.into(),
|
|
architecture: "x64".into(),
|
|
recipe_version: "1".into(),
|
|
installation_context: "machine".into(),
|
|
recipe_id: Some(MSI_RECIPE_ID.into()),
|
|
apt_manifest: None,
|
|
windows_msi_manifest: Some(Box::new(manifest)),
|
|
};
|
|
job.execution_identity = "system".into();
|
|
request.job_bytes = encode(&job).unwrap();
|
|
permit.action = "ensure_package".into();
|
|
permit.execution_identity = "system".into();
|
|
permit.job_payload_hash = hash(&request.job_bytes);
|
|
request.permit_bytes = encode(&permit).unwrap();
|
|
request.signature = SigningKey::from_bytes(&[9; 32])
|
|
.sign(&request.permit_bytes)
|
|
.to_bytes()
|
|
.to_vec();
|
|
binding
|
|
.verify_historical_for_denial_with(
|
|
&request,
|
|
HelperIdentity::System,
|
|
&rmm_agent_core::crypto::DalekVerifier,
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
binding
|
|
.verify_historical_for_denial_with(
|
|
&request,
|
|
HelperIdentity::Root,
|
|
&rmm_agent_core::crypto::DalekVerifier
|
|
)
|
|
.is_err()
|
|
);
|
|
assert!(binding.verify(&request, now + Duration::hours(1)).is_err()); // historical denial is never live authorization
|
|
if let Action::EnsurePackage {
|
|
windows_msi_manifest: Some(m),
|
|
..
|
|
} = &mut job.action
|
|
{
|
|
m.recipe.artifact.bytes += 1;
|
|
m.recipe_sha256 = m.recipe.sha256().unwrap();
|
|
}
|
|
request.job_bytes = encode(&job).unwrap();
|
|
assert!(
|
|
binding
|
|
.verify_historical_for_denial_with(
|
|
&request,
|
|
HelperIdentity::System,
|
|
&rmm_agent_core::crypto::DalekVerifier
|
|
)
|
|
.is_err()
|
|
);
|
|
}
|