Files
2026-11-14 21:48:21 +01:00

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()
);
}