feat: add pure signed agent release verifier without apply authority
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -0,0 +1 @@
|
||||
{"schema_version":1,"release_id":"00000000-0000-0000-0000-000000000001","release_sequence":4,"version":"0.2.0","platform":"x86_64-unknown-linux-gnu","published_at":90,"expires_at":110,"protocol_major":1,"state_schema":1,"minimum_updater_version":1,"artifacts":[{"role":"agent","artifact_id":"00000000-0000-0000-0000-000000000002","sha256":"8a24d82ccecfb6de46d0fd3488549b3c6757a4c05aab0a4b15c1b73e47000dbc","bytes":11},{"role":"helper","artifact_id":"00000000-0000-0000-0000-000000000003","sha256":"dd4e40b8a4de19a3b9143d926178927aea04ba0316f44f7fde254ecd51931d22","bytes":12}]}
|
||||
@@ -0,0 +1,317 @@
|
||||
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());
|
||||
}
|
||||
Reference in New Issue
Block a user