use std::io::{self, Cursor, Read}; use ed25519_dalek::{Signer, SigningKey}; use rmm_updater::*; use sha2::{Digest, Sha256}; use uuid::Uuid; fn hash(bytes: &[u8]) -> String { hex::encode(Sha256::digest(bytes)) } fn key(revoked: bool, first: u64, last: u64) -> TrustedUpdateKey { TrustedUpdateKey::new( SigningKey::from_bytes(&[41; 32]).verifying_key().to_bytes(), Platform::LinuxX64, first, last, revoked, ) .unwrap() } fn context() -> TrustedContext { TrustedContext { platform: Platform::LinuxX64, now_utc_seconds: 100, keyring_generation: 7, protocol_major: 1, state_schema: 1, updater_version: 1, minimum_release_sequence: 3, active_release: Some(ActiveRelease { sequence: 3, manifest_sha256: hash(b"previous immutable manifest"), }), } } fn manifest() -> ReleaseManifest { ReleaseManifest { schema_version: 1, release_id: Uuid::from_u128(1), release_sequence: 4, version: "0.2.0".into(), platform: Platform::LinuxX64, published_at: 90, expires_at: 110, protocol_major: 1, state_schema: 1, minimum_updater_version: 1, artifacts: [ ArtifactDescriptor { role: ArtifactRole::Agent, artifact_id: Uuid::from_u128(2), sha256: hash(b"agent image"), bytes: 11, }, ArtifactDescriptor { role: ArtifactRole::Helper, artifact_id: Uuid::from_u128(3), sha256: hash(b"helper image"), bytes: 12, }, ], } } fn verify_bytes(payload: &[u8], context: &TrustedContext) -> anyhow::Result { let signer = SigningKey::from_bytes(&[41; 32]); let mut message = RELEASE_SIGNATURE_DOMAIN.to_vec(); message.extend_from_slice(payload); let signature = signer.sign(&message).to_bytes(); let pinned = key(false, 1, 20); let key_id = pinned.key_id().to_owned(); verify_release( SignedRelease { schema_version: 1, key_id: &key_id, payload_bytes: payload, signature: &signature, }, &UpdateKeyring::new(7, vec![pinned]).unwrap(), context, ) } fn verify(manifest: &ReleaseManifest, context: &TrustedContext) -> anyhow::Result { verify_bytes(&serde_json::to_vec(manifest).unwrap(), context) } #[test] fn canonical_release_and_exact_role_bytes_are_metadata_only() { let payload = serde_json::to_vec(&manifest()).unwrap(); assert_eq!(payload, include_bytes!("fixtures/release_v1.json")); let checked = verify_bytes(&payload, &context()).unwrap(); assert_eq!(checked.manifest_sha256(), hash(&payload)); assert_eq!(checked.keyring_generation(), 7); assert_eq!(checked.key_id(), key(false, 1, 20).key_id()); assert_eq!(checked.manifest().release_sequence, 4); assert_eq!(checked.relation(), ReleaseRelation::AboveActivationFloor); checked .verify_artifact(ArtifactRole::Agent, Cursor::new(b"agent image")) .unwrap(); checked .verify_artifact(ArtifactRole::Helper, Cursor::new(b"helper image")) .unwrap(); assert!( checked .verify_artifact(ArtifactRole::Agent, Cursor::new(b"helper image")) .is_err() ); } #[test] fn signature_domain_bytes_unknown_key_and_revocation_are_independent() { let payload = serde_json::to_vec(&manifest()).unwrap(); let signer = SigningKey::from_bytes(&[41; 32]); let mut message = RELEASE_SIGNATURE_DOMAIN.to_vec(); message.extend_from_slice(&payload); let signature = signer.sign(&message).to_bytes(); let pinned = key(false, 1, 20); let key_id = pinned.key_id().to_owned(); let run = |bytes: &[u8], signature: &[u8], id: &str, revoked, first, last| { verify_release( SignedRelease { schema_version: 1, key_id: id, payload_bytes: bytes, signature, }, &UpdateKeyring::new(7, vec![key(revoked, first, last)]).unwrap(), &context(), ) }; assert!(run(&payload, &signature, &key_id, false, 1, 20).is_ok()); let mut changed = payload.clone(); changed[0] = b'['; assert!(run(&changed, &signature, &key_id, false, 1, 20).is_err()); assert!( run( &payload, &signer.sign(&payload).to_bytes(), &key_id, false, 1, 20 ) .is_err() ); let foreign = SigningKey::from_bytes(&[42; 32]).sign(&message).to_bytes(); assert!(run(&payload, &foreign, &key_id, false, 1, 20).is_err()); assert!(run(&payload, &signature[..63], &key_id, false, 1, 20).is_err()); assert!(run(&payload, &signature, &hash(b"job key"), false, 1, 20).is_err()); assert!(run(&payload, &signature, &key_id, true, 1, 20).is_err()); assert!(run(&payload, &signature, &key_id, false, 5, 20).is_err()); assert!(run(&payload, &signature, &key_id, false, 1, 3).is_err()); } #[test] fn signed_noncanonical_unknown_duplicate_and_oversize_payloads_are_rejected() { let payload = String::from_utf8(serde_json::to_vec(&manifest()).unwrap()).unwrap(); for changed in [ format!(" {payload}"), payload.replacen(":1,", ": 1,", 1), payload.replacen("{", "{\"untrusted\":true,", 1), payload.replacen("{", "{\"schema_version\":1,", 1), payload.replacen("\"bytes\":11", "\"bytes\":11,\"path\":\"/etc/passwd\"", 1), payload.replacen("\"release_sequence\":4", "\"release_sequence\":4.0", 1), payload.replacen("x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", 1), ] { assert!(verify_bytes(changed.as_bytes(), &context()).is_err()); } assert!(verify_bytes(&vec![b' '; MAX_MANIFEST_BYTES + 1], &context()).is_err()); assert!(verify_bytes(b"", &context()).is_err()); } #[test] fn incompatible_clock_platform_state_protocol_and_trust_contexts_are_rejected() { let mut ctx = context(); ctx.keyring_generation = 6; assert!(verify(&manifest(), &ctx).is_err()); ctx = context(); ctx.platform = Platform::WindowsX64; assert!(verify(&manifest(), &ctx).is_err()); for now in [89, 110, 111] { ctx = context(); ctx.now_utc_seconds = now; assert!(verify(&manifest(), &ctx).is_err()); } let changes: [fn(&mut ReleaseManifest); 7] = [ |m| m.schema_version = 2, |m| m.platform = Platform::WindowsX64, |m| m.protocol_major = 2, |m| m.state_schema = 2, |m| m.minimum_updater_version = 2, |m| m.minimum_updater_version = 0, |m| m.published_at = m.expires_at, ]; for change in changes { let mut m = manifest(); change(&mut m); assert!(verify(&m, &context()).is_err()); } } #[test] fn monotone_floor_same_sequence_conflict_and_postrollback_state_are_preserved() { let mut ctx = context(); let mut m = manifest(); m.release_sequence = 2; assert!(verify(&m, &ctx).is_err()); m.release_sequence = 3; assert!(verify(&m, &ctx).is_err()); ctx.active_release.as_mut().unwrap().manifest_sha256 = hash(&serde_json::to_vec(&m).unwrap()); assert_eq!( verify(&m, &ctx).unwrap().relation(), ReleaseRelation::SameActiveManifest ); m.version = "modified same sequence".into(); assert!(verify(&m, &ctx).is_err()); // A code rollback never lowers the remembered successfully activated floor. ctx.minimum_release_sequence = 5; assert!(verify(&manifest(), &ctx).is_err()); ctx = context(); ctx.minimum_release_sequence = 2; assert!(verify(&manifest(), &ctx).is_err()); ctx.active_release = None; ctx.minimum_release_sequence = 4; assert!(verify(&manifest(), &ctx).is_err()); } #[test] fn descriptor_roles_ids_bounds_and_digest_encoding_are_strict() { let changes: [fn(&mut ReleaseManifest); 10] = [ |m| m.release_id = Uuid::nil(), |m| m.release_sequence = 0, |m| m.version.clear(), |m| m.version = "https://attacker.invalid/latest".into(), |m| m.artifacts[0].artifact_id = Uuid::nil(), |m| m.artifacts[1].artifact_id = m.artifacts[0].artifact_id, |m| m.artifacts.swap(0, 1), |m| m.artifacts[0].bytes = 0, |m| m.artifacts[0].bytes = MAX_ARTIFACT_BYTES + 1, |m| m.artifacts[0].sha256 = m.artifacts[0].sha256.to_uppercase(), ]; for change in changes { let mut m = manifest(); change(&mut m); assert!(verify(&m, &context()).is_err()); } } #[test] fn artifact_eof_extra_bytes_hash_and_io_errors_never_verify() { let checked = verify(&manifest(), &context()).unwrap(); for bytes in [b"agent imag".as_slice(), b"agent image!", b"agent imagX"] { assert!( checked .verify_artifact(ArtifactRole::Agent, Cursor::new(bytes)) .is_err() ); } struct FailingReader; impl Read for FailingReader { fn read(&mut self, _: &mut [u8]) -> io::Result { Err(io::Error::new(io::ErrorKind::PermissionDenied, "fixture")) } } assert!( checked .verify_artifact(ArtifactRole::Agent, FailingReader) .is_err() ); } #[test] fn streamed_large_release_verifies_with_fixed_read_window() { struct BoundedReader { remaining: u64, largest_read: usize, } impl Read for BoundedReader { fn read(&mut self, output: &mut [u8]) -> io::Result { self.largest_read = self.largest_read.max(output.len()); assert!(output.len() <= 32 * 1024); let size = self.remaining.min(output.len() as u64) as usize; output[..size].fill(19); self.remaining -= size as u64; Ok(size) } } let bytes = vec![19; 512 * 1024 + 7]; let mut m = manifest(); m.artifacts[0].bytes = bytes.len() as u64; m.artifacts[0].sha256 = hash(&bytes); let checked = verify(&m, &context()).unwrap(); let mut reader = BoundedReader { remaining: bytes.len() as u64, largest_read: 0, }; checked .verify_artifact(ArtifactRole::Agent, &mut reader) .unwrap(); assert_eq!(reader.remaining, 0); assert_eq!(reader.largest_read, 32 * 1024); } #[test] fn keyring_rejects_weak_keys_duplicates_empty_sets_and_invalid_ranges() { assert!(TrustedUpdateKey::new([0; 32], Platform::LinuxX64, 1, 10, false).is_err()); let public = SigningKey::from_bytes(&[41; 32]).verifying_key().to_bytes(); assert!(TrustedUpdateKey::new(public, Platform::LinuxX64, 0, 10, false).is_err()); assert!(TrustedUpdateKey::new(public, Platform::LinuxX64, 10, 9, false).is_err()); assert!(UpdateKeyring::new(0, vec![key(false, 1, 20)]).is_err()); assert!(UpdateKeyring::new(1, vec![]).is_err()); assert!(UpdateKeyring::new(1, vec![key(false, 1, 20), key(false, 1, 20)]).is_err()); }