feat: add pure signed agent release verifier without apply authority
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 15:55:45 +01:00
parent 287a784c8f
commit cc5c93596d
8 changed files with 1185 additions and 1 deletions
+14
View File
@@ -0,0 +1,14 @@
[package]
name = "rmm-updater"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
anyhow.workspace = true
ed25519-dalek = "=2.2.0"
hex.workspace = true
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
uuid.workspace = true
+12
View File
@@ -0,0 +1,12 @@
//! Pure release verification. This crate does not install, stage, start services,
//! grant approval, persist antirollback state, or trust keys from the network.
//!
//! See docs/agent-updater-proposal.md for the separate, unfinished integration.
mod manifest;
pub use manifest::{
ActiveRelease, ArtifactDescriptor, ArtifactRole, MAX_ARTIFACT_BYTES, MAX_MANIFEST_BYTES,
Platform, RELEASE_SIGNATURE_DOMAIN, ReleaseManifest, ReleaseRelation, SignedRelease,
TrustedContext, TrustedUpdateKey, UpdateKeyring, VerifiedRelease, verify_release,
};
+385
View File
@@ -0,0 +1,385 @@
use std::{collections::BTreeMap, io::Read};
use anyhow::{Context, Result, bail, ensure};
use ed25519_dalek::{Signature, VerifyingKey};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use uuid::Uuid;
pub const MAX_MANIFEST_BYTES: usize = 16 * 1024;
/// Verification limit for a FUTURE update-specific streaming transport.
/// The existing server artifact route only permits 256 KiB and is unchanged.
pub const MAX_ARTIFACT_BYTES: u64 = 256 * 1024 * 1024;
pub const RELEASE_SIGNATURE_DOMAIN: &[u8] = b"rmm.agent-release.v1\0";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Platform {
#[serde(rename = "x86_64-unknown-linux-gnu")]
LinuxX64,
#[serde(rename = "x86_64-pc-windows-msvc")]
WindowsX64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ArtifactRole {
Agent,
Helper,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ArtifactDescriptor {
pub role: ArtifactRole,
pub artifact_id: Uuid,
pub sha256: String,
pub bytes: u64,
}
/// Exact field order defines codec version 1; no maps or floating point fields.
/// These public types describe UNTRUSTED metadata, never update authority.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReleaseManifest {
pub schema_version: u32,
pub release_id: Uuid,
pub release_sequence: u64,
pub version: String,
pub platform: Platform,
pub published_at: u64,
pub expires_at: u64,
pub protocol_major: u32,
pub state_schema: u32,
pub minimum_updater_version: u32,
pub artifacts: [ArtifactDescriptor; 2],
}
/// Already-decoded, bounded transport input. No algorithm negotiation exists.
pub struct SignedRelease<'a> {
pub schema_version: u32,
pub key_id: &'a str,
pub payload_bytes: &'a [u8],
pub signature: &'a [u8],
}
/// Provisioned update trust, not a key returned by a manifest/job/server request.
/// Construction validates raw keys and IDs; it does not authenticate provisioning.
pub struct TrustedUpdateKey {
key: VerifyingKey,
key_id: String,
platform: Platform,
first_sequence: u64,
last_sequence: u64,
revoked: bool,
}
impl TrustedUpdateKey {
pub fn new(
public_key: [u8; 32],
platform: Platform,
first_sequence: u64,
last_sequence: u64,
revoked: bool,
) -> Result<Self> {
let key = VerifyingKey::from_bytes(&public_key).context("invalid update public key")?;
ensure!(!key.is_weak(), "weak update public key");
ensure!(
first_sequence > 0 && last_sequence >= first_sequence,
"invalid key sequence range"
);
Ok(Self {
key,
key_id: digest(&public_key),
platform,
first_sequence,
last_sequence,
revoked,
})
}
pub fn key_id(&self) -> &str {
&self.key_id
}
}
pub struct UpdateKeyring {
generation: u64,
keys: BTreeMap<String, TrustedUpdateKey>,
}
impl UpdateKeyring {
pub fn new(generation: u64, keys: Vec<TrustedUpdateKey>) -> Result<Self> {
ensure!(
generation > 0 && !keys.is_empty() && keys.len() <= 16,
"invalid provisioned keyring"
);
let mut indexed = BTreeMap::new();
for key in keys {
ensure!(!indexed.contains_key(key.key_id()), "duplicate update key");
indexed.insert(key.key_id.clone(), key);
}
Ok(Self {
generation,
keys: indexed,
})
}
}
#[derive(Clone, Debug)]
pub struct ActiveRelease {
pub sequence: u64,
pub manifest_sha256: String,
}
/// Must be obtained from authenticated local state and a trusted clock.
/// No boolean `approved`/`ready` is accepted or produced here. Persistence,
/// rollback detection and independent sync remain the caller's responsibility.
pub struct TrustedContext {
pub platform: Platform,
pub now_utc_seconds: u64,
pub keyring_generation: u64,
pub protocol_major: u32,
pub state_schema: u32,
pub updater_version: u32,
pub minimum_release_sequence: u64,
pub active_release: Option<ActiveRelease>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ReleaseRelation {
AboveActivationFloor,
/// Metadata identity only: neither actual binary health nor a job Noop proof.
SameActiveManifest,
}
/// Private construction proves only release metadata validity at verification.
/// Holding this value grants NO permission to download, stop, install or start.
pub struct VerifiedRelease {
manifest: ReleaseManifest,
manifest_sha256: String,
key_id: String,
keyring_generation: u64,
relation: ReleaseRelation,
}
impl VerifiedRelease {
pub fn manifest(&self) -> &ReleaseManifest {
&self.manifest
}
pub fn manifest_sha256(&self) -> &str {
&self.manifest_sha256
}
pub fn key_id(&self) -> &str {
&self.key_id
}
pub fn keyring_generation(&self) -> u64 {
self.keyring_generation
}
pub fn relation(&self) -> ReleaseRelation {
self.relation
}
/// Verify a complete reader with a fixed 32 KiB buffer and no file writes.
/// A caller supplying a socket/pipe must enforce its own timeout and permit.
/// Descriptors come only from this verified release, never caller input.
pub fn verify_artifact(&self, role: ArtifactRole, mut reader: impl Read) -> Result<()> {
let descriptor = match role {
ArtifactRole::Agent => &self.manifest.artifacts[0],
ArtifactRole::Helper => &self.manifest.artifacts[1],
};
let mut buffer = [0_u8; 32 * 1024];
let mut remaining = descriptor.bytes;
let mut hasher = Sha256::new();
while remaining > 0 {
let limit = remaining.min(buffer.len() as u64) as usize;
let size = match reader.read(&mut buffer[..limit]) {
Ok(size) => size,
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
Err(error) => return Err(error).context("release artifact read failed"),
};
ensure!(size > 0, "release artifact truncated");
hasher.update(&buffer[..size]);
remaining -= size as u64;
}
loop {
match reader.read(&mut buffer[..1]) {
Ok(0) => break,
Ok(_) => bail!("release artifact has extra bytes"),
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
Err(error) => return Err(error).context("release artifact EOF check failed"),
}
}
ensure!(
hex::encode(hasher.finalize()) == descriptor.sha256,
"release artifact hash mismatch"
);
Ok(())
}
}
pub fn verify_release(
signed: SignedRelease<'_>,
keyring: &UpdateKeyring,
context: &TrustedContext,
) -> Result<VerifiedRelease> {
ensure!(
signed.schema_version == 1,
"unsupported release envelope schema"
);
ensure!(
!signed.payload_bytes.is_empty() && signed.payload_bytes.len() <= MAX_MANIFEST_BYTES,
"release manifest size limit"
);
ensure!(is_digest(signed.key_id), "invalid update key ID");
ensure!(
keyring.generation == context.keyring_generation,
"update trust generation mismatch"
);
let key = keyring
.keys
.get(signed.key_id)
.context("untrusted update key")?;
ensure!(
!key.revoked && key.platform == context.platform,
"update key revoked or wrong platform"
);
let signature =
Signature::from_slice(signed.signature).context("invalid release signature size")?;
let mut message =
Vec::with_capacity(RELEASE_SIGNATURE_DOMAIN.len() + signed.payload_bytes.len());
message.extend_from_slice(RELEASE_SIGNATURE_DOMAIN);
message.extend_from_slice(signed.payload_bytes);
key.key
.verify_strict(&message, &signature)
.context("release signature rejected")?;
let manifest: ReleaseManifest =
serde_json::from_slice(signed.payload_bytes).context("invalid release manifest schema")?;
ensure!(
serde_json::to_vec(&manifest)? == signed.payload_bytes,
"noncanonical release manifest"
);
validate_manifest(&manifest, context)?;
ensure!(
(key.first_sequence..=key.last_sequence).contains(&manifest.release_sequence),
"release outside update key sequence range"
);
let manifest_sha256 = digest(signed.payload_bytes);
let relation = match &context.active_release {
Some(active) => {
ensure!(
active.sequence > 0
&& is_digest(&active.manifest_sha256)
&& active.sequence <= context.minimum_release_sequence,
"invalid trusted active release state"
);
if manifest.release_sequence == active.sequence {
ensure!(
manifest_sha256 == active.manifest_sha256,
"release sequence content conflict"
);
ReleaseRelation::SameActiveManifest
} else {
ensure!(
manifest.release_sequence > context.minimum_release_sequence,
"release is not above activation floor"
);
ReleaseRelation::AboveActivationFloor
}
}
None => {
ensure!(
manifest.release_sequence > context.minimum_release_sequence,
"release is not above activation floor"
);
ReleaseRelation::AboveActivationFloor
}
};
Ok(VerifiedRelease {
manifest,
manifest_sha256,
key_id: signed.key_id.to_owned(),
keyring_generation: keyring.generation,
relation,
})
}
fn validate_manifest(manifest: &ReleaseManifest, context: &TrustedContext) -> Result<()> {
ensure!(
manifest.schema_version == 1,
"unsupported release manifest schema"
);
ensure!(
!manifest.release_id.is_nil() && manifest.release_sequence > 0,
"invalid release identity"
);
ensure!(
!manifest.version.is_empty()
&& manifest.version.len() <= 64
&& manifest
.version
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || b".-+_".contains(&byte)),
"invalid release version label"
);
ensure!(
manifest.platform == context.platform,
"release platform mismatch"
);
ensure!(
manifest.published_at <= context.now_utc_seconds
&& manifest.expires_at > context.now_utc_seconds
&& manifest.expires_at > manifest.published_at,
"release outside trusted validity interval"
);
ensure!(
context.protocol_major > 0 && manifest.protocol_major == context.protocol_major,
"incompatible release protocol"
);
ensure!(
context.state_schema > 0 && manifest.state_schema == context.state_schema,
"incompatible release state schema"
);
ensure!(
manifest.minimum_updater_version > 0
&& manifest.minimum_updater_version <= context.updater_version,
"updater version unsupported"
);
ensure!(
manifest.release_sequence >= context.minimum_release_sequence,
"release below activation floor"
);
ensure!(
manifest.artifacts[0].role == ArtifactRole::Agent
&& manifest.artifacts[1].role == ArtifactRole::Helper,
"release requires ordered agent and helper artifacts"
);
ensure!(
manifest.artifacts[0].artifact_id != manifest.artifacts[1].artifact_id,
"duplicate release artifact ID"
);
for artifact in &manifest.artifacts {
ensure!(
!artifact.artifact_id.is_nil()
&& is_digest(&artifact.sha256)
&& (1..=MAX_ARTIFACT_BYTES).contains(&artifact.bytes),
"invalid release artifact descriptor"
);
}
Ok(())
}
fn digest(bytes: &[u8]) -> String {
hex::encode(Sha256::digest(bytes))
}
fn is_digest(value: &str) -> bool {
value.len() == 64
&& value
.bytes()
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
}
+1
View File
@@ -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}]}
+317
View File
@@ -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());
}