use crate::install::{ManifestVerifier, VerifyError};
use crate::manifest::{LayerManifest, ManifestError};
use crate::store::{InstalledLayer, Store, StoreError};
pub const ENVELOPE_FILE: &str = "layer.dsse.json";
#[derive(Debug, thiserror::Error)]
pub enum ReverifyError {
#[error(
"layer {digest} has no retained signature envelope ({ENVELOPE_FILE}) — cannot re-verify \
its signature; reinstall from a signed source"
)]
NoEnvelope { digest: String },
#[error(transparent)]
Verify(#[from] VerifyError),
#[error(
"retained envelope verifies, but its payload does not match layer.json — the core entry \
was modified after install"
)]
PayloadMismatch,
#[error(transparent)]
Manifest(#[from] ManifestError),
#[error("payload '{tool}' is missing from the installed layer")]
MissingTool { tool: String },
#[error(
"verified nothing: layer {layer} carries {available} payload(s), none of them for \
platform '{platform}'. It carries: {carried}. If this layer was installed for \
another platform, verify it for that one."
)]
NothingToVerify {
layer: String,
platform: String,
available: usize,
carried: String,
},
#[error("payload '{tool}' does not match its signed digest {digest} — its bytes were altered")]
ToolDigestMismatch { tool: String, digest: String },
#[error(transparent)]
Store(#[from] StoreError),
#[error("io error at {path}: {source}")]
Io {
path: String,
#[source]
source: std::io::Error,
},
}
fn named(entry: &crate::manifest::ManifestEntry, name: &str) -> String {
match crate::store::entry_version(entry) {
Some(version) => format!("{name}@{version}"),
None => name.to_string(),
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct VerifyTiming {
pub signature: std::time::Duration,
pub manifest: std::time::Duration,
pub payloads: crate::store::StageTiming,
pub checked: usize,
}
pub fn verify_installed(
store: &Store,
layer: &InstalledLayer,
verifier: &dyn ManifestVerifier,
platform: &str,
) -> Result<usize, ReverifyError> {
verify_installed_timed(store, layer, verifier, platform).map(|(checked, _)| checked)
}
pub fn verify_retained_envelope(
layer: &InstalledLayer,
verifier: &dyn ManifestVerifier,
) -> Result<(), ReverifyError> {
retained_payload(layer, verifier, &mut VerifyTiming::default()).map(|_| ())
}
fn retained_payload(
layer: &InstalledLayer,
verifier: &dyn ManifestVerifier,
timing: &mut VerifyTiming,
) -> Result<Vec<u8>, ReverifyError> {
let io = |path: &std::path::Path, source: std::io::Error| ReverifyError::Io {
path: path.display().to_string(),
source,
};
let envelope_path = layer.root.join(ENVELOPE_FILE);
let envelope = match std::fs::read(&envelope_path) {
Ok(bytes) => bytes,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Err(ReverifyError::NoEnvelope {
digest: layer.digest.clone(),
});
}
Err(e) => return Err(io(&envelope_path, e)),
};
let t = std::time::Instant::now();
let payload = verifier.verify(&envelope)?;
timing.signature = t.elapsed();
let manifest_path = layer.root.join("layer.json");
let stored = std::fs::read(&manifest_path).map_err(|e| io(&manifest_path, e))?;
if payload != stored {
return Err(ReverifyError::PayloadMismatch);
}
Ok(payload)
}
pub fn verify_installed_timed(
store: &Store,
layer: &InstalledLayer,
verifier: &dyn ManifestVerifier,
platform: &str,
) -> Result<(usize, VerifyTiming), ReverifyError> {
let mut timing = VerifyTiming::default();
let io = |path: &std::path::Path, source: std::io::Error| ReverifyError::Io {
path: path.display().to_string(),
source,
};
let payload = retained_payload(layer, verifier, &mut timing)?;
let t = std::time::Instant::now();
let manifest = LayerManifest::parse(&payload)?;
timing.manifest = t.elapsed();
let mut checked = 0;
for entry in &manifest.entries {
if !crate::platform::entry_matches(
entry
.annotations
.get(crate::platform::ANN_PLATFORM)
.map(String::as_str),
platform,
) {
continue;
}
if entry.kind() == Ok(crate::kind::PayloadKind::Layer) {
continue;
}
let Some(tool) = entry.annotations.get("eu.pulseengine.tool") else {
continue;
};
let Some(path) = store.entry_path(layer, entry) else {
return Err(ReverifyError::MissingTool {
tool: named(entry, tool),
});
};
let (found, stage) = crate::store::digest_file_timed(&path).map_err(|e| io(&path, e))?;
timing.payloads.add(stage);
if found != entry.digest {
return Err(ReverifyError::ToolDigestMismatch {
tool: named(entry, tool),
digest: entry.digest.clone(),
});
}
checked += 1;
}
let payload_entries = manifest
.entries
.iter()
.filter(|e| e.kind() != Ok(crate::kind::PayloadKind::Layer))
.count();
if checked == 0 && payload_entries > 0 {
let mut carried: Vec<&str> = manifest
.entries
.iter()
.filter(|e| e.kind() != Ok(crate::kind::PayloadKind::Layer))
.map(|e| {
e.annotations
.get(crate::platform::ANN_PLATFORM)
.map(String::as_str)
.unwrap_or("any")
})
.collect();
carried.sort_unstable();
carried.dedup();
return Err(ReverifyError::NothingToVerify {
layer: layer.layer.to_string(),
platform: platform.to_string(),
available: payload_entries,
carried: carried.join(", "),
});
}
timing.checked = checked;
Ok((checked, timing))
}
#[cfg(test)]
mod tests {
#[cfg(unix)]
fn premise_unavailable() -> bool {
use std::os::unix::fs::PermissionsExt;
let Ok(dir) = tempfile::tempdir() else {
return true;
};
let probe = dir.path().join("probe");
if std::fs::write(&probe, b"x").is_err() {
return true;
}
if std::fs::set_permissions(&probe, std::fs::Permissions::from_mode(0o000)).is_err() {
return true;
}
let readable = std::fs::read(&probe).is_ok();
let _ = std::fs::set_permissions(&probe, std::fs::Permissions::from_mode(0o644));
readable
}
use super::*;
use crate::install::{InstallPolicy, install};
use crate::manifest::fixtures::manifest_with_tools;
use crate::pin::Pin;
use crate::rollback::HighWaterMarks;
use crate::source::MemorySource;
use crate::store::manifest_digest;
use crate::verify::{PinnedKeyVerifier, generate_root_keypair, sign_layer_manifest};
struct Installed {
_tmp: tempfile::TempDir,
store: Store,
layer: InstalledLayer,
verifier: PinnedKeyVerifier,
}
fn installed_layer() -> Installed {
let (sk, pk) = generate_root_keypair();
let synth = b"synth-bytes".to_vec();
let blob_digest = manifest_digest(&synth);
let payload = manifest_with_tools(
"2026.07.0",
"qualified",
1,
"2026-07-31T09:14:00Z",
&[("synth", &blob_digest)],
);
let envelope = sign_layer_manifest(&payload, &sk, "varve-root-1").unwrap();
let source = MemorySource::new()
.with_manifest(envelope.as_bytes())
.with_blob(&blob_digest, &synth);
let pin = Pin::parse(
"manifest-version = 1\n[toolchain]\nchannel = \"qualified\"\nlayer = \"2026.07.0\"\n",
"varve.toml",
)
.unwrap();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("root");
let store = Store::at(&root);
let mut marks = HighWaterMarks::load(&root).unwrap();
let verifier = PinnedKeyVerifier::from_public_key_bytes(&pk).unwrap();
let policy = InstallPolicy {
index: None,
now: "2026-08-07T00:00:00Z",
staleness_threshold_days: 90,
platform: "test-platform",
};
let outcome = install(&pin, &source, &verifier, &store, &mut marks, &policy).unwrap();
let layer = store.get(&outcome.digest).unwrap().unwrap();
Installed {
_tmp: tmp,
store,
layer,
verifier,
}
}
fn installed_for(install_platform: &str) -> Installed {
let (sk, pk) = generate_root_keypair();
let linux = b"wac-linux-bytes".to_vec();
let mac = b"wac-darwin-bytes".to_vec();
let (dl, dm) = (manifest_digest(&linux), manifest_digest(&mac));
let payload = crate::manifest::fixtures::manifest_with_platform_tools(
"2026.07.0",
"qualified",
1,
"2026-07-31T09:14:00Z",
&[
("wac", &dl, Some("x86_64-unknown-linux-gnu")),
("wac", &dm, Some("aarch64-apple-darwin")),
],
);
let envelope = sign_layer_manifest(&payload, &sk, "varve-root-1").unwrap();
let source = MemorySource::new()
.with_manifest(envelope.as_bytes())
.with_blob(&dl, &linux)
.with_blob(&dm, &mac);
let pin = Pin::parse(
"manifest-version = 1\n[toolchain]\nchannel = \"qualified\"\nlayer = \"2026.07.0\"\n",
"varve.toml",
)
.unwrap();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("root");
let store = Store::at(&root);
let mut marks = HighWaterMarks::load(&root).unwrap();
let verifier = PinnedKeyVerifier::from_public_key_bytes(&pk).unwrap();
let policy = InstallPolicy {
index: None,
now: "2026-08-07T00:00:00Z",
staleness_threshold_days: 90,
platform: install_platform,
};
let outcome = install(&pin, &source, &verifier, &store, &mut marks, &policy).unwrap();
let layer = store.get(&outcome.digest).unwrap().unwrap();
Installed {
_tmp: tmp,
store,
layer,
verifier,
}
}
#[test]
fn a_composition_only_layer_verifies_although_it_checks_nothing() {
let (sk, pk) = generate_root_keypair();
let payload = format!(
r#"{{"schemaVersion":2,"mediaType":"application/vnd.oci.image.index.v1+json",
"artifactType":"application/vnd.pulseengine.varve.layer.v1+json",
"annotations":{{"eu.pulseengine.varve.layer":"2026.07.0",
"eu.pulseengine.varve.line":"2026.07","eu.pulseengine.varve.channel":"qualified",
"eu.pulseengine.varve.counter":"1",
"org.opencontainers.image.created":"2026-07-31T09:14:00Z"}},
"manifests":[{{"digest":"sha256:{d}","size":0,
"annotations":{{"{k}":"layer","eu.pulseengine.varve.include.realm":"other"}}}}]}}"#,
d = "0".repeat(64),
k = crate::kind::ANN_KIND,
)
.into_bytes();
let envelope = sign_layer_manifest(&payload, &sk, "varve-root-1").unwrap();
let source = MemorySource::new().with_manifest(envelope.as_bytes());
let pin = Pin::parse(
"manifest-version = 1\n[toolchain]\nchannel = \"qualified\"\nlayer = \"2026.07.0\"\n",
"varve.toml",
)
.unwrap();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("root");
let store = Store::at(&root);
let mut marks = HighWaterMarks::load(&root).unwrap();
let verifier = PinnedKeyVerifier::from_public_key_bytes(&pk).unwrap();
let policy = InstallPolicy {
index: None,
now: "2026-08-07T00:00:00Z",
staleness_threshold_days: 90,
platform: "x86_64-unknown-linux-gnu",
};
let outcome = install(&pin, &source, &verifier, &store, &mut marks, &policy).unwrap();
let layer = store.get(&outcome.digest).unwrap().unwrap();
let checked = verify_installed(&store, &layer, &verifier, "x86_64-unknown-linux-gnu")
.expect("a composition-only layer must verify, not be refused for checking nothing");
assert_eq!(checked, 0, "it has no payloads of its own to check");
}
#[test]
fn the_retained_envelope_vouches_only_under_the_root_that_signed_it() {
let (sk, pk) = generate_root_keypair();
let (_, stranger) = generate_root_keypair();
let payload = format!(
r#"{{"schemaVersion":2,"mediaType":"application/vnd.oci.image.index.v1+json",
"artifactType":"application/vnd.pulseengine.varve.layer.v1+json",
"annotations":{{"eu.pulseengine.varve.layer":"2026.07.0",
"eu.pulseengine.varve.line":"2026.07","eu.pulseengine.varve.channel":"qualified",
"eu.pulseengine.varve.counter":"1",
"org.opencontainers.image.created":"2026-07-31T09:14:00Z"}},
"manifests":[{{"digest":"sha256:{d}","size":0,
"annotations":{{"{k}":"layer","eu.pulseengine.varve.include.realm":"other"}}}}]}}"#,
d = "0".repeat(64),
k = crate::kind::ANN_KIND,
)
.into_bytes();
let envelope = sign_layer_manifest(&payload, &sk, "varve-root-1").unwrap();
let source = MemorySource::new().with_manifest(envelope.as_bytes());
let pin = Pin::parse(
"manifest-version = 1\n[toolchain]\nchannel = \"qualified\"\nlayer = \"2026.07.0\"\n",
"varve.toml",
)
.unwrap();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("root");
let store = Store::at(&root);
let mut marks = HighWaterMarks::load(&root).unwrap();
let verifier = PinnedKeyVerifier::from_public_key_bytes(&pk).unwrap();
let policy = InstallPolicy {
index: None,
now: "2026-08-07T00:00:00Z",
staleness_threshold_days: 90,
platform: "x86_64-unknown-linux-gnu",
};
let outcome = install(&pin, &source, &verifier, &store, &mut marks, &policy).unwrap();
let layer = store.get(&outcome.digest).unwrap().unwrap();
verify_retained_envelope(&layer, &verifier).expect("the signing root vouches");
let other = PinnedKeyVerifier::from_public_key_bytes(&stranger).unwrap();
assert!(
verify_retained_envelope(&layer, &other).is_err(),
"a root that signed nothing here must not vouch for it"
);
std::fs::write(layer.root.join("layer.json"), b"{}").unwrap();
assert!(
matches!(
verify_retained_envelope(&layer, &verifier),
Err(ReverifyError::PayloadMismatch)
),
"a manifest that differs from what was signed must not vouch"
);
std::fs::remove_file(layer.root.join(ENVELOPE_FILE)).unwrap();
assert!(
matches!(
verify_retained_envelope(&layer, &verifier),
Err(ReverifyError::NoEnvelope { .. })
),
"no retained envelope, nothing to vouch with"
);
}
#[test]
fn the_refusal_names_the_platforms_the_layer_does_carry() {
let i = installed_for("x86_64-unknown-linux-gnu");
let err = verify_installed(
&i.store,
&i.layer,
&i.verifier,
"riscv64gc-unknown-linux-gnu",
)
.unwrap_err();
let msg = err.to_string();
for expected in ["x86_64-unknown-linux-gnu", "aarch64-apple-darwin"] {
assert!(
msg.contains(expected),
"the refusal does not name {expected}, which this layer carries: {msg}"
);
}
assert!(msg.contains("riscv64gc-unknown-linux-gnu"), "{msg}");
}
#[test]
fn a_layer_installed_for_another_platform_verifies_against_that_platform() {
let i = installed_for("x86_64-unknown-linux-gnu");
assert_eq!(
i.layer.platform.as_deref(),
Some("x86_64-unknown-linux-gnu"),
"install did not record the platform it selected payloads for"
);
let plat = i.layer.platform.clone().unwrap();
let checked = verify_installed(&i.store, &i.layer, &i.verifier, &plat)
.expect("a layer installed for another platform must verify");
assert_eq!(checked, 1, "the linux payload was not the one checked");
}
#[test]
fn asking_the_wrong_platform_is_what_produced_the_false_tamper_claim() {
let i = installed_for("x86_64-unknown-linux-gnu");
let out = verify_installed(&i.store, &i.layer, &i.verifier, "aarch64-apple-darwin");
assert!(
matches!(out, Err(ReverifyError::MissingTool { .. }))
|| matches!(out, Err(ReverifyError::ToolDigestMismatch { .. })),
"expected the host-platform question to fail; got {out:?}"
);
assert_eq!(
i.layer.platform.as_deref(),
Some("x86_64-unknown-linux-gnu")
);
}
#[test]
fn verifying_against_a_platform_the_layer_carries_nothing_for_is_refused() {
let i = installed_for("x86_64-unknown-linux-gnu");
let out = verify_installed(
&i.store,
&i.layer,
&i.verifier,
"riscv64gc-unknown-linux-gnu",
);
assert!(
matches!(out, Err(ReverifyError::NothingToVerify { .. })),
"verifying a layer for a platform it carries nothing for did not refuse: {out:?}"
);
}
#[test]
fn a_freshly_installed_layer_reverifies() {
let ctx = installed_layer();
let checked =
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap();
assert_eq!(checked, 1);
}
fn installed_two_versions() -> (Installed, Vec<u8>, Vec<u8>) {
use crate::manifest::fixtures::manifest_with_payloads;
let (sk, pk) = generate_root_keypair();
let a = b"serde-1.0.200-crate".to_vec();
let b = b"serde-1.0.210-crate".to_vec();
let (da, db) = (manifest_digest(&a), manifest_digest(&b));
let payload = manifest_with_payloads(
"2026.07.0",
"qualified",
1,
"2026-07-31T09:14:00Z",
&[
("serde", "1.0.200", "crate", &da),
("serde", "1.0.210", "crate", &db),
],
);
let envelope = sign_layer_manifest(&payload, &sk, "varve-root-1").unwrap();
let source = MemorySource::new()
.with_manifest(envelope.as_bytes())
.with_blob(&da, &a)
.with_blob(&db, &b);
let pin = Pin::parse(
"manifest-version = 1\n[toolchain]\nchannel = \"qualified\"\nlayer = \"2026.07.0\"\n",
"varve.toml",
)
.unwrap();
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("root");
let store = Store::at(&root);
let mut marks = HighWaterMarks::load(&root).unwrap();
let verifier = PinnedKeyVerifier::from_public_key_bytes(&pk).unwrap();
let policy = InstallPolicy {
index: None,
now: "2026-08-07T00:00:00Z",
staleness_threshold_days: 90,
platform: "test-platform",
};
let outcome = install(&pin, &source, &verifier, &store, &mut marks, &policy).unwrap();
let layer = store.get(&outcome.digest).unwrap().unwrap();
(
Installed {
_tmp: tmp,
store,
layer,
verifier,
},
a,
b,
)
}
#[test]
fn each_version_of_one_name_is_checked_against_its_own_signed_digest() {
let (ctx, a, b) = installed_two_versions();
assert_eq!(
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap(),
2,
"both versions must be checked, not one file twice"
);
assert_eq!(
std::fs::read(ctx.layer.root.join("payloads/serde/1.0.200")).unwrap(),
a
);
assert_eq!(
std::fs::read(ctx.layer.root.join("payloads/serde/1.0.210")).unwrap(),
b
);
for (version, path) in [
("1.0.200", "payloads/serde/1.0.200"),
("1.0.210", "payloads/serde/1.0.210"),
] {
let (ctx, ..) = installed_two_versions();
std::fs::write(ctx.layer.root.join(path), b"EVIL").unwrap();
let err = verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform")
.unwrap_err();
assert!(
matches!(&err, ReverifyError::ToolDigestMismatch { tool, .. }
if tool == &format!("serde@{version}")),
"tampering with {version} must be caught AND named: {err}"
);
}
let (ctx, ..) = installed_two_versions();
std::fs::remove_file(ctx.layer.root.join("payloads/serde/1.0.210")).unwrap();
let err =
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap_err();
assert!(
matches!(&err, ReverifyError::MissingTool { tool } if tool == "serde@1.0.210"),
"got: {err}"
);
}
#[test]
fn install_retains_the_envelope_for_offline_reverification() {
let ctx = installed_layer();
assert!(
ctx.layer.root.join(ENVELOPE_FILE).is_file(),
"install must retain the signature envelope"
);
}
#[test]
fn an_altered_tool_binary_is_detected() {
let ctx = installed_layer();
std::fs::write(ctx.layer.root.join("bin/synth"), b"EVIL").unwrap();
let err =
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap_err();
assert!(
matches!(err, ReverifyError::ToolDigestMismatch { ref tool, .. } if tool == "synth"),
"got: {err}"
);
}
#[test]
fn an_altered_manifest_payload_is_detected() {
let ctx = installed_layer();
let path = ctx.layer.root.join("layer.json");
let mut bytes = std::fs::read(&path).unwrap();
bytes.extend_from_slice(b" ");
std::fs::write(&path, bytes).unwrap();
let err =
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap_err();
assert!(matches!(err, ReverifyError::PayloadMismatch), "got: {err}");
}
#[cfg(unix)]
#[test]
fn an_unreadable_envelope_is_an_io_error_not_a_missing_one() {
if premise_unavailable() {
eprintln!("skipping: this environment does not deny reads on mode 000");
return;
}
use std::os::unix::fs::PermissionsExt;
let ctx = installed_layer();
let path = ctx.layer.root.join(ENVELOPE_FILE);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o000)).unwrap();
let err =
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap_err();
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644));
assert!(
matches!(err, ReverifyError::Io { .. }),
"an unreadable envelope must be an Io error, got: {err}"
);
}
#[test]
fn a_missing_envelope_is_its_own_loud_verdict() {
let ctx = installed_layer();
std::fs::remove_file(ctx.layer.root.join(ENVELOPE_FILE)).unwrap();
let err =
verify_installed(&ctx.store, &ctx.layer, &ctx.verifier, "test-platform").unwrap_err();
assert!(
matches!(err, ReverifyError::NoEnvelope { .. }),
"got: {err}"
);
}
}