//! 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) { 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 { 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::( &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::("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::("SELECT count(*) FROM consumed", [], |r| r.get(0)) .unwrap(), 0 ); assert_eq!( db.query_row::("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::("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 = 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::, _, _>("SELECT outcome FROM execution_evidence", [], |r| r.get(0)) .unwrap() ); assert_eq!( db.query_row::( "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::("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>(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() ); }