Share signed job core and verify native Linux then Windows contracts
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -0,0 +1,292 @@
|
||||
//! 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());
|
||||
}
|
||||
Reference in New Issue
Block a user