419 lines
16 KiB
Rust
419 lines
16 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()),
|
|
},
|
|
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::<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());
|
|
}
|
|
|
|
#[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()
|
|
);
|
|
}
|