use crate::digest::{canonicalize, verify, ManifestDigest};
use crate::error::{PackageError, Result};
use crate::oci::layout::OciLayout;
use crate::oci::media_types::{
ANNOTATION_ATTESTATION_ISSUER, ANNOTATION_ATTESTATION_PAYLOAD_TYPE,
ANNOTATION_ATTESTATION_SUBJECT, MT_ATTESTATION, MT_SERVER_BINARY_REF, MT_SERVER_BOOTSTRAP,
MT_SERVER_CEDAR_POLICY_SET, MT_SERVER_CONFIG, MT_SERVER_CONFIG_SLOTS,
MT_SERVER_DEPLOY_DESCRIPTOR, MT_SERVER_ENVELOPE, MT_SERVER_OPENAPI_SPEC,
MT_SERVER_TOOL_METADATA,
};
use crate::oci::pack::ServerEnvelope;
use crate::oci::SingleLayerPackage;
use crate::package::{AgentPackage, BinaryRef, ServerPackage, TeamPackage, WorkflowManifest};
use oci_spec::image::{Descriptor, ImageManifest, ANNOTATION_TITLE};
use std::collections::BTreeMap;
fn read_verified_blob(layout: &OciLayout, descriptor: &Descriptor) -> Result<Vec<u8>> {
let expected = ManifestDigest::try_from(descriptor.digest())?;
let bytes = layout.read_blob(descriptor)?;
verify(&expected, &bytes)?;
Ok(bytes)
}
fn read_the_one_manifest(layout: &OciLayout) -> Result<ImageManifest> {
let index = layout.read_index()?;
let manifests = index.manifests();
if manifests.len() != 1 {
return Err(PackageError::Layout {
reason: format!(
"expected exactly one manifest in index.json, found {}",
manifests.len()
),
});
}
let bytes = read_verified_blob(layout, &manifests[0])?;
let manifest = serde_json::from_slice(&bytes)?;
Ok(manifest)
}
fn verify_config_blob(layout: &OciLayout, manifest: &ImageManifest) -> Result<()> {
read_verified_blob(layout, manifest.config())?;
Ok(())
}
fn missing_layer(name: &str) -> PackageError {
PackageError::Layout {
reason: format!("manifest is missing the '{name}' layer"),
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UnpackedBinary {
Embedded(Vec<u8>),
Referenced {
digest: ManifestDigest,
media_type: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RestoredFile {
pub file_name: String,
pub bytes: Vec<u8>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SubjectVerdict {
pub claimed: String,
pub unattested_digest: ManifestDigest,
}
impl SubjectVerdict {
pub fn matches(&self) -> bool {
self.claimed == self.unattested_digest.as_str()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnpackedAttestation {
pub bytes: Vec<u8>,
pub subject: SubjectVerdict,
pub issuer: String,
pub payload_type: String,
}
#[derive(Debug, Clone, PartialEq)]
pub struct UnpackedServer {
pub package: ServerPackage,
pub binary: UnpackedBinary,
pub config: Option<RestoredFile>,
pub spec: Option<RestoredFile>,
pub attestation: Option<UnpackedAttestation>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnpackedTeam {
pub package: TeamPackage,
pub attestation: Option<UnpackedAttestation>,
}
fn index_layers(manifest: &ImageManifest) -> Result<BTreeMap<String, &Descriptor>> {
let mut index: BTreeMap<String, &Descriptor> = BTreeMap::new();
for layer in manifest.layers() {
let media_type = layer.media_type().to_string();
if index.insert(media_type.clone(), layer).is_some() {
return Err(PackageError::Layout {
reason: format!("manifest carries more than one '{media_type}' layer"),
});
}
}
Ok(index)
}
fn read_binary_mode(
layout: &OciLayout,
by_media_type: &BTreeMap<String, &Descriptor>,
) -> Result<UnpackedBinary> {
let bootstrap = by_media_type.get(MT_SERVER_BOOTSTRAP);
let binary_ref = by_media_type.get(MT_SERVER_BINARY_REF);
match (bootstrap, binary_ref) {
(Some(_), Some(_)) => Err(PackageError::Layout {
reason: "manifest carries BOTH an embedded bootstrap layer and a binary-ref layer \
(exactly one is required)"
.to_string(),
}),
(None, None) => Err(missing_layer("bootstrap or binary-ref")),
(Some(descriptor), None) => {
Ok(UnpackedBinary::Embedded(read_verified_blob(
layout, descriptor,
)?))
},
(None, Some(descriptor)) => {
let bytes = read_verified_blob(layout, descriptor)?;
let wire: BinaryRef = serde_json::from_slice(&bytes)?;
let digest = wire.digest.ok_or_else(|| PackageError::Layout {
reason: "binary-ref layer carries no digest".to_string(),
})?;
Ok(UnpackedBinary::Referenced {
digest,
media_type: wire.media_type,
})
},
}
}
fn read_named_file_layer(
layout: &OciLayout,
descriptor: Option<&&Descriptor>,
layer_name: &str,
) -> Result<Option<RestoredFile>> {
let Some(descriptor) = descriptor else {
return Ok(None);
};
let bytes = read_verified_blob(layout, descriptor)?;
let file_name = descriptor
.annotations()
.as_ref()
.and_then(|a| a.get(ANNOTATION_TITLE))
.ok_or_else(|| PackageError::Layout {
reason: format!("the '{layer_name}' layer has no '{ANNOTATION_TITLE}' annotation"),
})?
.clone();
Ok(Some(RestoredFile { file_name, bytes }))
}
fn required_annotation(descriptor: &Descriptor, key: &str, layer_name: &str) -> Result<String> {
Ok(descriptor
.annotations()
.as_ref()
.and_then(|a| a.get(key))
.ok_or_else(|| PackageError::Layout {
reason: format!("the '{layer_name}' layer has no '{key}' annotation"),
})?
.clone())
}
fn re_derive_unattested_digest(manifest: &ImageManifest) -> Result<ManifestDigest> {
let mut unattested = manifest.clone();
let layers: Vec<Descriptor> = manifest
.layers()
.iter()
.filter(|layer| layer.media_type().to_string() != MT_ATTESTATION)
.cloned()
.collect();
unattested.set_layers(layers);
Ok(ManifestDigest::from_bytes(&canonicalize(&unattested)?))
}
fn read_attestation_layer(
layout: &OciLayout,
descriptor: Option<&&Descriptor>,
layer_name: &str,
manifest: &ImageManifest,
) -> Result<Option<UnpackedAttestation>> {
let Some(descriptor) = descriptor else {
return Ok(None);
};
let bytes = read_verified_blob(layout, descriptor)?;
let subject = SubjectVerdict {
claimed: required_annotation(descriptor, ANNOTATION_ATTESTATION_SUBJECT, layer_name)?,
unattested_digest: re_derive_unattested_digest(manifest)?,
};
Ok(Some(UnpackedAttestation {
bytes,
subject,
issuer: required_annotation(descriptor, ANNOTATION_ATTESTATION_ISSUER, layer_name)?,
payload_type: required_annotation(
descriptor,
ANNOTATION_ATTESTATION_PAYLOAD_TYPE,
layer_name,
)?,
}))
}
fn read_required_layer_bytes(
layout: &OciLayout,
by_media_type: &BTreeMap<String, &Descriptor>,
media_type: &str,
layer_name: &str,
) -> Result<Vec<u8>> {
let descriptor = by_media_type
.get(media_type)
.ok_or_else(|| missing_layer(layer_name))?;
read_verified_blob(layout, descriptor)
}
fn read_required_layer<T: serde::de::DeserializeOwned>(
layout: &OciLayout,
by_media_type: &BTreeMap<String, &Descriptor>,
media_type: &str,
layer_name: &str,
) -> Result<T> {
let bytes = read_required_layer_bytes(layout, by_media_type, media_type, layer_name)?;
Ok(serde_json::from_slice(&bytes)?)
}
const LEGACY_ENVELOPE_KEY: &str = "binary_ref";
fn detect_legacy_shape(envelope_bytes: &[u8]) -> Result<()> {
let Ok(serde_json::Value::Object(envelope)) =
serde_json::from_slice::<serde_json::Value>(envelope_bytes)
else {
return Ok(());
};
if envelope.contains_key(LEGACY_ENVELOPE_KEY) {
return Err(PackageError::Layout {
reason: format!(
"the envelope layer carries the pre-0.2.0 layer shape (a '{LEGACY_ENVELOPE_KEY}' \
key). The package format changed in 0.2.0, when the binary's identity moved off \
the envelope and onto its own OCI layer; 0.2.0 does not read 0.1.x packages. \
Repack the package with a 0.2.0 producer."
),
});
}
Ok(())
}
pub fn unpack_server(layout: &OciLayout) -> Result<UnpackedServer> {
let manifest = read_the_one_manifest(layout)?;
verify_config_blob(layout, &manifest)?;
let by_media_type = index_layers(&manifest)?;
let binary = read_binary_mode(layout, &by_media_type)?;
let envelope_bytes =
read_required_layer_bytes(layout, &by_media_type, MT_SERVER_ENVELOPE, "envelope")?;
detect_legacy_shape(&envelope_bytes)?;
let envelope: ServerEnvelope = serde_json::from_slice(&envelope_bytes)?;
let package = ServerPackage {
name: envelope.name,
version: envelope.version,
digest: envelope.digest,
deploy: read_required_layer(
layout,
&by_media_type,
MT_SERVER_DEPLOY_DESCRIPTOR,
"deploy-descriptor",
)?,
policies: read_required_layer(
layout,
&by_media_type,
MT_SERVER_CEDAR_POLICY_SET,
"cedar-policy-set",
)?,
tools: read_required_layer(
layout,
&by_media_type,
MT_SERVER_TOOL_METADATA,
"tool-metadata",
)?,
config_slots: read_required_layer(
layout,
&by_media_type,
MT_SERVER_CONFIG_SLOTS,
"config-slots",
)?,
};
let config = read_named_file_layer(layout, by_media_type.get(MT_SERVER_CONFIG), "config")?;
let spec = read_named_file_layer(
layout,
by_media_type.get(MT_SERVER_OPENAPI_SPEC),
"openapi-spec",
)?;
let attestation = read_attestation_layer(
layout,
by_media_type.get(MT_ATTESTATION),
"attestation",
&manifest,
)?;
Ok(UnpackedServer {
package,
binary,
config,
spec,
attestation,
})
}
fn unpack_single_layer<P: SingleLayerPackage>(layout: &OciLayout) -> Result<P> {
let manifest = read_the_one_manifest(layout)?;
verify_config_blob(layout, &manifest)?;
let by_media_type = index_layers(&manifest)?;
let expected = vendor_media_type_name(P::LAYER_MEDIA_TYPE);
if by_media_type.len() != 1 {
return Err(PackageError::Layout {
reason: format!(
"a {} package must carry exactly ONE layer ('{expected}'), found {}: {:?}",
P::LAYER_NAME,
by_media_type.len(),
by_media_type.keys().collect::<Vec<_>>()
),
});
}
let layer = by_media_type
.get(&expected)
.ok_or_else(|| missing_layer(P::LAYER_NAME))?;
let bytes = read_verified_blob(layout, layer)?;
Ok(serde_json::from_slice(&bytes)?)
}
fn vendor_media_type_name(media_type: &str) -> String {
crate::oci::media_types::vendor_media_type(media_type).to_string()
}
pub fn unpack_agent(layout: &OciLayout) -> Result<AgentPackage> {
unpack_single_layer(layout)
}
pub fn unpack_team(layout: &OciLayout) -> Result<UnpackedTeam> {
let manifest = read_the_one_manifest(layout)?;
verify_config_blob(layout, &manifest)?;
let by_media_type = index_layers(&manifest)?;
let expected = vendor_media_type_name(TeamPackage::LAYER_MEDIA_TYPE);
reject_layers_a_team_may_not_carry(&by_media_type, &expected)?;
let layer = by_media_type
.get(&expected)
.ok_or_else(|| missing_layer(TeamPackage::LAYER_NAME))?;
let bytes = read_verified_blob(layout, layer)?;
let package: TeamPackage = serde_json::from_slice(&bytes)?;
let attestation = read_attestation_layer(
layout,
by_media_type.get(MT_ATTESTATION),
"attestation",
&manifest,
)?;
Ok(UnpackedTeam {
package,
attestation,
})
}
fn reject_layers_a_team_may_not_carry(
by_media_type: &BTreeMap<String, &Descriptor>,
expected: &str,
) -> Result<()> {
for media_type in by_media_type.keys() {
if media_type != expected && media_type != MT_ATTESTATION {
return Err(PackageError::Layout {
reason: format!(
"a team package may carry only its '{expected}' layer and an OPTIONAL \
'{MT_ATTESTATION}' layer; found '{media_type}'. Layers present: {:?}",
by_media_type.keys().collect::<Vec<_>>()
),
});
}
}
Ok(())
}
pub fn unpack_workflow(layout: &OciLayout) -> Result<WorkflowManifest> {
unpack_single_layer(layout)
}
#[cfg(test)]
pub(crate) mod tests_support {
use crate::digest::ManifestDigest;
use crate::package::Provenance;
use crate::package::{
AgentPackage, AssetsSection, AuthSection, AwsSection, CedarPolicy, CedarPolicySet,
DeployDescriptor, HumanRole, ServerPackage, ServerSection, TargetSection, TeamLimits,
TeamMember, TeamPackage, TeamRole, ToolMetadata, WorkflowManifest,
};
use crate::reference::{ComponentRef, ComponentType, PinnedRef};
use crate::slot::{ConfigSlot, SlotType};
use std::collections::BTreeMap;
fn minimal_deploy_descriptor() -> DeployDescriptor {
DeployDescriptor {
target: TargetSection {
target_type: "pmcp-run".to_string(),
version: "1.0.0".to_string(),
},
metadata: None,
aws: AwsSection {
region: "us-east-1".to_string(),
},
server: ServerSection {
name: "team-fs".to_string(),
memory_mb: Some(1024),
timeout_seconds: 30,
memory: None,
cpu: None,
ingress: None,
allow_unauthenticated: None,
binary: None,
},
environment: BTreeMap::from([("RUST_LOG".to_string(), "info".to_string())]),
secrets: BTreeMap::new(),
auth: AuthSection {
enabled: false,
provider: "none".to_string(),
callback_urls: vec![],
cognito: None,
dcr: None,
groups: None,
scopes: None,
},
observability: crate::package::ObservabilitySection {
log_retention_days: 30,
enable_xray: true,
create_dashboard: true,
alarms: None,
},
composition: None,
assets: Some(AssetsSection {
include: vec![],
exclude: vec!["**/*.tmp".to_string()],
}),
iam: None,
gcp: None,
layout: None,
}
}
pub(crate) fn sample_server_package() -> (ServerPackage, Vec<u8>) {
let bootstrap = b"fake-arm64-bootstrap-binary-bytes-for-testing".to_vec();
let package = ServerPackage {
name: "team-fs".to_string(),
version: semver::Version::parse("1.0.0").unwrap(),
digest: None,
deploy: minimal_deploy_descriptor(),
policies: CedarPolicySet(vec![CedarPolicy {
id: "p1".to_string(),
cedar_text: "permit(principal, action, resource);".to_string(),
title: "Allow all".to_string(),
description: "test policy".to_string(),
category: "read".to_string(),
risk: "low".to_string(),
}]),
tools: vec![ToolMetadata {
name: "fs__list".to_string(),
description: "List files in a team workspace".to_string(),
annotations: Some(serde_json::json!({ "read_only_hint": true })),
}],
config_slots: vec![ConfigSlot::new(SlotType::Secret {
name: "API_KEY".to_string(),
})],
};
(package, bootstrap)
}
pub(crate) fn sample_agent_package() -> AgentPackage {
AgentPackage {
name: "triage-agent".to_string(),
version: semver::Version::parse("1.0.0").unwrap(),
instructions: "You triage incoming support tickets.".to_string(),
llm: ConfigSlot::new(SlotType::LlmProvider {
name: "primary-llm".to_string(),
tested_value: "anthropic".to_string(),
}),
max_tokens: 4096,
max_iterations: 25,
connectors: vec![ComponentRef::Range {
name: "london-tube".to_string(),
range: semver::VersionReq::parse("^1.2").unwrap(),
component_type: ComponentType::Server,
}],
tool_selection: Some(serde_json::json!({ "london-tube": ["get_status"] })),
input_schema: None,
output_schema: Some(serde_json::json!({ "type": "object" })),
importance: Some("HIGH".to_string()),
finalizer_role: Some("formatter".to_string()),
budget_defaults: vec![ConfigSlot::new(SlotType::BudgetOverride {
name: "monthly-cap".to_string(),
tested_value: "1000".to_string(),
})],
}
}
pub(crate) fn sample_team_package() -> TeamPackage {
let entry_point = ComponentRef::Range {
name: "triage-agent".to_string(),
range: semver::VersionReq::parse("^1").unwrap(),
component_type: ComponentType::Agent,
};
let human_role = HumanRole {
role: "approver".to_string(),
description: "Approves budget overrides".to_string(),
responsibilities: vec!["review".to_string(), "approve".to_string()],
channel_hints: vec!["slack".to_string()],
};
TeamPackage {
name: "support-team".to_string(),
version: semver::Version::parse("1.0.0").unwrap(),
entry_point: entry_point.clone(),
members: vec![TeamMember {
agent: entry_point,
role: TeamRole::EntryPoint,
}],
human_roles: vec![human_role.clone()],
limits: TeamLimits {
max_team_depth: 3,
max_team_total_tokens: 200_000,
max_team_wall_clock_seconds: 600,
poll_interval_ms: 2000,
},
built_in_servers: vec![ComponentRef::Range {
name: "team-fs".to_string(),
range: semver::VersionReq::parse("^1").unwrap(),
component_type: ComponentType::Server,
}],
finalizer_agents: vec![],
budget_defaults: vec![],
config_slots: vec![human_role.to_config_slot()],
}
}
pub(crate) fn sample_workflow_manifest() -> WorkflowManifest {
WorkflowManifest::new(
"support-triage".to_string(),
semver::Version::parse("1.0.0").unwrap(),
vec![
ComponentRef::Pinned(PinnedRef {
name: "triage-agent".to_string(),
component_type: ComponentType::Agent,
version: semver::Version::parse("1.2.0").unwrap(),
digest: ManifestDigest::from_bytes(b"triage-agent"),
resolved_from: None,
}),
ComponentRef::Pinned(PinnedRef {
name: "london-tube".to_string(),
component_type: ComponentType::Server,
version: semver::Version::parse("2.0.1").unwrap(),
digest: ManifestDigest::from_bytes(b"london-tube"),
resolved_from: None,
}),
],
vec![ConfigSlot::new(SlotType::LlmProvider {
name: "primary-llm".to_string(),
tested_value: "anthropic".to_string(),
})],
Provenance {
source_environment: "dev".to_string(),
capturer: "cargo-pmcp".to_string(),
timestamp: "2026-07-16T00:00:00Z".to_string(),
root_team_id: "support-team".to_string(),
},
)
}
}
#[cfg(test)]
mod tests {
use super::tests_support::{
sample_agent_package, sample_server_package, sample_team_package, sample_workflow_manifest,
};
use super::*;
use crate::oci::pack::{
pack_agent, pack_server, pack_team, pack_workflow, AttestationFile, BinaryMode,
};
#[test]
fn server_pack_then_unpack_round_trips_losslessly_including_bootstrap_bytes() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let (package, bootstrap) = sample_server_package();
pack_server(
&package,
BinaryMode::Embedded(&bootstrap),
None,
None,
None,
&layout,
)
.unwrap();
let unpacked = unpack_server(&layout).unwrap();
assert_eq!(unpacked.package, package);
assert_eq!(unpacked.binary, UnpackedBinary::Embedded(bootstrap));
assert_eq!(unpacked.config, None);
assert_eq!(unpacked.spec, None);
}
#[test]
fn a_duplicated_layer_media_type_is_rejected_rather_than_last_wins() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let (package, bootstrap) = sample_server_package();
pack_server(
&package,
BinaryMode::Embedded(&bootstrap),
None,
None,
None,
&layout,
)
.unwrap();
let index = layout.read_index().unwrap();
let mut manifest = layout.read_manifest(&index.manifests()[0]).unwrap();
let mut layers = manifest.layers().clone();
let envelope = layers
.iter()
.find(|l| l.media_type().to_string() == MT_SERVER_ENVELOPE)
.unwrap()
.clone();
layers.push(envelope);
manifest.set_layers(layers);
let bytes = crate::digest::canonicalize(&manifest).unwrap();
let new_descriptor = layout.write_manifest(&bytes).unwrap();
let new_index = oci_spec::image::ImageIndexBuilder::default()
.schema_version(oci_spec::image::SCHEMA_VERSION)
.manifests(vec![new_descriptor])
.build()
.unwrap();
layout.write_index(&new_index).unwrap();
let err = unpack_server(&layout).unwrap_err();
assert!(matches!(err, PackageError::Layout { .. }), "got {err:?}");
}
#[test]
fn a_duplicated_attestation_layer_is_rejected_rather_than_last_wins() {
let (package, bootstrap) = sample_server_package();
let unattested_dir = tempfile::tempdir().unwrap();
let unattested_layout = OciLayout::create(unattested_dir.path()).unwrap();
let subject = pack_server(
&package,
BinaryMode::Embedded(&bootstrap),
None,
None,
None,
&unattested_layout,
)
.unwrap();
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
pack_server(
&package,
BinaryMode::Embedded(&bootstrap),
None,
None,
Some(AttestationFile {
bytes: b"\x00\x01 not json \xff\xfe",
subject: subject.as_str(),
issuer: "https://issuer.test.invalid/pmcp-run",
payload_type: "application/vnd.test.attestation-payload",
}),
&layout,
)
.unwrap();
let index = layout.read_index().unwrap();
let mut manifest = layout.read_manifest(&index.manifests()[0]).unwrap();
let mut layers = manifest.layers().clone();
let attestation = layers
.iter()
.find(|l| l.media_type().to_string() == MT_ATTESTATION)
.unwrap()
.clone();
layers.push(attestation);
manifest.set_layers(layers);
let bytes = crate::digest::canonicalize(&manifest).unwrap();
let new_descriptor = layout.write_manifest(&bytes).unwrap();
let new_index = oci_spec::image::ImageIndexBuilder::default()
.schema_version(oci_spec::image::SCHEMA_VERSION)
.manifests(vec![new_descriptor])
.build()
.unwrap();
layout.write_index(&new_index).unwrap();
let err = unpack_server(&layout).unwrap_err();
assert!(matches!(err, PackageError::Layout { .. }), "got {err:?}");
let PackageError::Layout { reason } = &err else {
unreachable!("just asserted the variant")
};
assert!(
reason.contains(MT_ATTESTATION),
"the error must NAME the duplicated media type so the operator can act on it; was: \
{reason}"
);
}
#[test]
fn agent_pack_then_unpack_round_trips_losslessly() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let package = sample_agent_package();
pack_agent(&package, &layout).unwrap();
let unpacked = unpack_agent(&layout).unwrap();
assert_eq!(unpacked, package);
}
#[test]
fn team_pack_then_unpack_round_trips_losslessly() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let package = sample_team_package();
pack_team(&package, None, &layout).unwrap();
let unpacked = unpack_team(&layout).unwrap();
assert_eq!(unpacked.package, package);
assert_eq!(unpacked.attestation, None);
}
#[test]
fn workflow_pack_then_unpack_round_trips_losslessly() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let package = sample_workflow_manifest();
pack_workflow(&package, &layout).unwrap();
let unpacked = unpack_workflow(&layout).unwrap();
assert_eq!(unpacked, package);
}
#[test]
fn tampering_a_blob_byte_on_disk_makes_unpack_fail_with_digest_mismatch() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let (package, bootstrap) = sample_server_package();
pack_server(
&package,
BinaryMode::Embedded(&bootstrap),
None,
None,
None,
&layout,
)
.unwrap();
let index = layout.read_index().unwrap();
let manifest = layout.read_manifest(&index.manifests()[0]).unwrap();
let bootstrap_descriptor = manifest
.layers()
.iter()
.find(|l| l.media_type().to_string() == MT_SERVER_BOOTSTRAP)
.unwrap();
let hex = bootstrap_descriptor.digest().digest();
let blob_path = dir.path().join("blobs").join("sha256").join(hex);
let mut bytes = std::fs::read(&blob_path).unwrap();
bytes[0] ^= 0x01;
std::fs::write(&blob_path, bytes).unwrap();
let err = unpack_server(&layout).unwrap_err();
assert!(
matches!(err, PackageError::DigestMismatch { .. }),
"expected DigestMismatch, got {err:?}"
);
}
#[test]
fn tampering_the_manifest_blob_itself_makes_unpack_fail_with_digest_mismatch() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let package = sample_agent_package();
pack_agent(&package, &layout).unwrap();
let index = layout.read_index().unwrap();
let manifest_descriptor = &index.manifests()[0];
let hex = manifest_descriptor.digest().digest();
let blob_path = dir.path().join("blobs").join("sha256").join(hex);
let mut bytes = std::fs::read(&blob_path).unwrap();
bytes[0] ^= 0x01;
std::fs::write(&blob_path, bytes).unwrap();
let err = unpack_agent(&layout).unwrap_err();
assert!(matches!(err, PackageError::DigestMismatch { .. }));
}
#[test]
fn missing_layer_yields_layout_error_not_a_panic() {
let dir = tempfile::tempdir().unwrap();
let layout = OciLayout::create(dir.path()).unwrap();
let package = sample_agent_package();
pack_agent(&package, &layout).unwrap();
let index = layout.read_index().unwrap();
let mut manifest = layout.read_manifest(&index.manifests()[0]).unwrap();
manifest.set_layers(vec![]);
let bytes = crate::digest::canonicalize(&manifest).unwrap();
let new_descriptor = layout.write_manifest(&bytes).unwrap();
let new_index = oci_spec::image::ImageIndexBuilder::default()
.schema_version(oci_spec::image::SCHEMA_VERSION)
.manifests(vec![new_descriptor])
.build()
.unwrap();
layout.write_index(&new_index).unwrap();
let err = unpack_agent(&layout).unwrap_err();
assert!(matches!(err, PackageError::Layout { .. }));
}
}