344 lines
12 KiB
Rust
344 lines
12 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> {
|
|
verify_bytes_with_key(payload, context, key(false, 1, 20))
|
|
}
|
|
|
|
fn verify_bytes_with_key(
|
|
payload: &[u8],
|
|
context: &TrustedContext,
|
|
pinned: TrustedUpdateKey,
|
|
) -> 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 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", "riscv64gc-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 arm64_release_requires_arm64_context_and_key() {
|
|
let mut target = manifest();
|
|
target.platform = Platform::LinuxArm64;
|
|
let mut context = context();
|
|
assert!(verify(&target, &context).is_err());
|
|
context.platform = Platform::LinuxArm64;
|
|
assert!(verify(&target, &context).is_err());
|
|
let arm64_key = TrustedUpdateKey::new(
|
|
SigningKey::from_bytes(&[41; 32]).verifying_key().to_bytes(),
|
|
Platform::LinuxArm64,
|
|
1,
|
|
20,
|
|
false,
|
|
).unwrap();
|
|
let payload = serde_json::to_vec(&target).unwrap();
|
|
assert!(verify_bytes_with_key(&payload, &context, arm64_key).is_ok());
|
|
}
|
|
|
|
#[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());
|
|
}
|