Files
rust-discovery/crates/updater/tests/release_contract.rs
T
2026-11-14 15:55:45 +01:00

318 lines
11 KiB
Rust

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<VerifiedRelease> {
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<VerifiedRelease> {
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<usize> {
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<usize> {
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());
}