//! 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()), }, 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()); } #[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() ); }