#![cfg(test)]
use std::sync::Arc;
use hyperlight_testing::{c_simple_guest_as_pathbuf, simple_guest_as_pathbuf};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use sha2::{Digest as _, Sha256};
use crate::func::Registerable;
use crate::mem::shared_mem::{ReadonlySharedMemory, SharedMemory as _};
use crate::sandbox::snapshot::{
OciDigest, OciReference, OciTag, Snapshot, SnapshotBlob, SnapshotMemory,
};
use crate::{GuestBinary, HostFunctions, Sandbox, SandboxBuilder, UninitializedSandbox};
fn create_test_sandbox() -> Sandbox {
let path = simple_guest_as_pathbuf();
SandboxBuilder::from_file(path).build().unwrap()
}
fn create_c_test_sandbox() -> Sandbox {
let path = c_simple_guest_as_pathbuf();
SandboxBuilder::from_file(path).build().unwrap()
}
fn random_sequence(sandbox: &mut Sandbox) -> [i32; 4] {
std::array::from_fn(|_| sandbox.call("NextRandom", ()).unwrap())
}
fn random_long_sequence(sandbox: &mut Sandbox) -> [i64; 4] {
std::array::from_fn(|_| sandbox.call("NextRandomLong", ()).unwrap())
}
fn libc_rng_reseed_request(sandbox: &Sandbox) -> u64 {
let scratch_size = sandbox.mem_mgr.scratch_mem.mem_size();
sandbox
.mem_mgr
.scratch_mem
.read::<u64>(
scratch_size - hyperlight_common::layout::SCRATCH_TOP_LIBC_RNG_SEED_OFFSET as usize,
)
.unwrap()
}
fn create_snapshot() -> Arc<Snapshot> {
let mut sbox = create_test_sandbox();
sbox.snapshot().unwrap()
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
struct TestMetadata {
format_version: u32,
runtime: String,
}
#[track_caller]
fn unwrap_err_snapshot(r: crate::Result<Snapshot>) -> crate::HyperlightError {
match r {
Err(e) => e,
Ok(_) => panic!("expected snapshot load to fail"),
}
}
fn find_config_blob(oci_dir: &std::path::Path) -> std::path::PathBuf {
let manifest_bytes = std::fs::read(oci_dir.join("index.json")).unwrap();
let index: Value = serde_json::from_slice(&manifest_bytes).unwrap();
let manifest_digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
let manifest_path = oci_dir.join("blobs").join("sha256").join(manifest_digest);
let manifest: Value = serde_json::from_slice(&std::fs::read(&manifest_path).unwrap()).unwrap();
let cfg_digest = manifest["config"]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
oci_dir.join("blobs").join("sha256").join(cfg_digest)
}
fn find_snapshot_blob(oci_dir: &std::path::Path) -> std::path::PathBuf {
let index: Value =
serde_json::from_slice(&std::fs::read(oci_dir.join("index.json")).unwrap()).unwrap();
let manifest_digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
let manifest_path = oci_dir.join("blobs").join("sha256").join(manifest_digest);
let manifest: Value = serde_json::from_slice(&std::fs::read(&manifest_path).unwrap()).unwrap();
let snap_digest = manifest["layers"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
oci_dir.join("blobs").join("sha256").join(snap_digest)
}
fn find_transport_blob(oci_dir: &std::path::Path) -> std::path::PathBuf {
let index: Value =
serde_json::from_slice(&std::fs::read(oci_dir.join("index.json")).unwrap()).unwrap();
let manifest_digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
let manifest_path = oci_dir.join("blobs").join("sha256").join(manifest_digest);
let manifest: Value = serde_json::from_slice(&std::fs::read(&manifest_path).unwrap()).unwrap();
let transport_digest = manifest["layers"].as_array().unwrap().last().unwrap()["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
oci_dir.join("blobs").join("sha256").join(transport_digest)
}
#[test]
fn from_snapshot_already_initialized_in_memory() {
let snapshot = create_snapshot();
let mut sbox2 = Sandbox::from_snapshot(snapshot, HostFunctions::default(), None).unwrap();
let result: i32 = sbox2.call("GetStatic", ()).unwrap();
assert_eq!(result, 0);
}
#[test]
fn from_snapshot_in_memory_pre_init() {
let snap = Snapshot::from_env(
GuestBinary::FilePath(simple_guest_as_pathbuf()),
crate::sandbox::SandboxConfiguration::default(),
)
.unwrap();
let mut sbox = Sandbox::from_snapshot(Arc::new(snap), HostFunctions::default(), None).unwrap();
assert_eq!(libc_rng_reseed_request(&sbox), 0);
let result: i32 = sbox.call("GetStatic", ()).unwrap();
assert_eq!(result, 0);
}
#[test]
fn snapshot_metadata_is_immutable_and_shares_state() {
let snapshot = create_snapshot();
let metadata = TestMetadata {
format_version: 1,
runtime: "test".to_string(),
};
let with_metadata = snapshot
.with_metadata("snapshot-metadata-namespace-v1", &metadata)
.unwrap();
assert!(Arc::ptr_eq(&snapshot.state, &with_metadata.state));
assert_eq!(
snapshot
.metadata::<TestMetadata>("snapshot-metadata-namespace-v1")
.unwrap(),
None
);
assert_eq!(
with_metadata
.metadata::<TestMetadata>("snapshot-metadata-namespace-v1")
.unwrap(),
Some(metadata)
);
}
#[test]
fn snapshot_metadata_namespaces_are_independent() {
let snapshot = create_snapshot();
let first = snapshot.with_metadata("first", &1_u32).unwrap();
let second = first.with_metadata("second", &2_u32).unwrap();
let replaced = second.with_metadata("first", &3_u32).unwrap();
assert_eq!(second.metadata::<u32>("first").unwrap(), Some(1));
assert_eq!(replaced.metadata::<u32>("first").unwrap(), Some(3));
assert_eq!(replaced.metadata::<u32>("second").unwrap(), Some(2));
}
#[test]
fn round_trip_save_load_call() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let oci = dir.path().join("snap");
snapshot
.save(&oci, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Snapshot::checked_load(&oci, OciTag::new("latest").unwrap()).unwrap();
let mut sbox2 =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
let result: String = sbox2.call("Echo", "hello\n".to_string()).unwrap();
assert_eq!(result, "hello\n");
}
#[test]
fn snapshot_metadata_round_trip() {
let metadata = TestMetadata {
format_version: 1,
runtime: "test".to_string(),
};
let snapshot = create_snapshot()
.with_metadata("snapshot-metadata-namespace-v1", &metadata)
.unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("metadata");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let config: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
assert_eq!(
config["metadata"],
serde_json::json!({
"snapshot-metadata-namespace-v1": {
"format_version": 1,
"runtime": "test",
}
})
);
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(
loaded
.metadata::<TestMetadata>("snapshot-metadata-namespace-v1")
.unwrap(),
Some(metadata)
);
assert_eq!(
loaded.layout().get_guest_code_gva(),
snapshot.layout().get_guest_code_gva()
);
}
#[test]
fn snapshot_without_metadata_omits_config_field() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("metadata");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let config: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert!(config.get("metadata").is_none());
assert_eq!(loaded.metadata::<Value>("missing").unwrap(), None);
}
#[test]
fn layered_writer_preserves_blobs_and_transport_geometry() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let manifest: Value =
serde_json::from_slice(&std::fs::read(manifest_path(&path)).unwrap()).unwrap();
let config: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
let layers = manifest["layers"].as_array().unwrap();
assert_eq!(
manifest["config"]["mediaType"],
"application/vnd.hyperlight.snapshot.config.v5+json"
);
assert_eq!(
manifest["artifactType"],
"application/vnd.hyperlight.snapshot.config.v5+json"
);
assert_eq!(config["abi_version"], 9);
let blobs = snapshot.snapshot_memory().blobs().collect::<Vec<_>>();
assert_eq!(layers.len(), blobs.len() + 1);
for (index, blob) in blobs.iter().enumerate() {
assert_eq!(
layers[index]["mediaType"],
"application/vnd.hyperlight.snapshot.memory.v2"
);
let bytes = std::fs::read(blob_path(&path, &layers[index])).unwrap();
assert_eq!(bytes, blob.memory().as_slice());
assert_eq!(config["layers"][index]["data_len"], blob.data_len());
assert_eq!(
config["layers"][index]["page_table_len"],
blob.page_table_len()
);
}
let page_table_layer = config["page_table_layer"].as_u64().unwrap() as usize;
assert!(Arc::ptr_eq(
blobs[page_table_layer],
snapshot.snapshot_memory().page_table_blob()
));
assert_eq!(
layers[blobs.len()]["mediaType"],
super::file::MT_TRANSPORT_V1
);
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(
loaded.snapshot_memory().layers().len(),
snapshot.snapshot_memory().layers().len()
);
assert_eq!(
loaded.layout().get_g2h_queue_size(),
snapshot.layout().get_g2h_queue_size()
);
assert_eq!(
loaded.layout().get_h2g_queue_size(),
snapshot.layout().get_h2g_queue_size()
);
assert_eq!(
loaded.layout().get_g2h_buffer_size(),
snapshot.layout().get_g2h_buffer_size()
);
assert_eq!(
loaded.layout().get_h2g_buffer_size(),
snapshot.layout().get_h2g_buffer_size()
);
assert_eq!(
loaded.layout().get_g2h_pool_pages(),
snapshot.layout().get_g2h_pool_pages()
);
assert_eq!(
loaded.layout().get_h2g_pool_pages(),
snapshot.layout().get_h2g_pool_pages()
);
}
#[test]
fn layered_snapshot_recapture_round_trip() {
let mut snapshot = Arc::try_unwrap(create_snapshot()).ok().unwrap();
let source = &snapshot.state.memory.layers()[0];
let data = source.memory().as_slice();
let data_len = source.data_len();
let page_size = page_size::get();
let boundary = (data_len / 2 / page_size) * page_size;
assert!(boundary > 0 && boundary < data_len);
let base = source.gpa_start();
let scratch_base =
hyperlight_common::layout::scratch_base_gpa(snapshot.layout().get_scratch_size());
let mut layers = [(0, boundary), (boundary, data_len)]
.map(|(start, end)| {
let blob = SnapshotBlob::new(
ReadonlySharedMemory::from_bytes(&data[start..end], end - start).unwrap(),
base + start as u64,
0,
scratch_base,
)
.unwrap();
Arc::new(blob)
})
.to_vec();
layers.extend_from_slice(&snapshot.state.memory.layers()[1..]);
let page_tables =
super::memory::tests::page_tables_from_bytes(snapshot.state.memory.page_table_bytes());
Arc::get_mut(&mut snapshot.state).unwrap().memory =
Arc::new(SnapshotMemory::new(layers.into_boxed_slice(), page_tables).unwrap());
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let manifest: Value =
serde_json::from_slice(&std::fs::read(manifest_path(&path)).unwrap()).unwrap();
let layers = manifest["layers"].as_array().unwrap();
let data_layers = snapshot.state.memory.layers().len();
assert_eq!(layers.len(), data_layers + 2);
for layer in &layers[..data_layers + 1] {
assert_eq!(layer["mediaType"], super::file::MT_SNAPSHOT_V2);
}
assert_eq!(
layers[data_layers + 1]["mediaType"],
super::file::MT_TRANSPORT_V1
);
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.snapshot_memory().layers().len(), data_layers);
let mut sandbox =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
assert_eq!(
sandbox
.call::<String>("Echo", "layers".to_string())
.unwrap(),
"layers"
);
let initial = sandbox.call::<i32>("GetStatic", ()).unwrap();
assert_eq!(
sandbox.call::<i32>("AddToStatic", 42).unwrap(),
initial + 42
);
let captured = sandbox.snapshot().unwrap();
captured
.save(&path, &OciTag::new("captured").unwrap())
.unwrap();
assert_eq!(sandbox.call::<i32>("AddToStatic", 1).unwrap(), initial + 43);
let loaded = Snapshot::checked_load(&path, OciTag::new("captured").unwrap()).unwrap();
let mut restored =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
assert_eq!(restored.call::<i32>("GetStatic", ()).unwrap(), initial + 42);
assert_eq!(
restored.call::<i32>("AddToStatic", 1).unwrap(),
initial + 43
);
}
#[test]
fn save_self_heals_same_length_wrong_content_snapshot_blob() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let oci = dir.path().join("snap");
snapshot
.save(&oci, &OciTag::new("latest").unwrap())
.unwrap();
let snap_path = find_snapshot_blob(&oci);
let len = std::fs::metadata(&snap_path).unwrap().len() as usize;
std::fs::write(&snap_path, vec![0xAAu8; len]).unwrap();
snapshot
.save(&oci, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Snapshot::checked_load(&oci, OciTag::new("latest").unwrap()).unwrap();
let mut sbox2 =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
let result: String = sbox2.call("Echo", "hello\n".to_string()).unwrap();
assert_eq!(result, "hello\n");
}
#[test]
fn snapshot_and_pt_size_round_trip() {
let snap = create_snapshot();
let original_snapshot_size = snap.snapshot_memory().gpa_span_len();
let original_pt_size = snap.snapshot_memory().page_table_len();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("running");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(
loaded.snapshot_memory().gpa_span_len(),
original_snapshot_size
);
assert_eq!(loaded.snapshot_memory().page_table_len(), original_pt_size);
}
#[test]
fn snapshot_generation_round_trip() {
let mut sbox = create_test_sandbox();
sbox.call::<String>("Echo", "a".to_string()).unwrap();
let snap1 = sbox.snapshot().unwrap();
sbox.call::<String>("Echo", "b".to_string()).unwrap();
sbox.call::<String>("Echo", "c".to_string()).unwrap();
let snap3 = sbox.snapshot().unwrap();
let gen1 = snap1.snapshot_generation();
let gen3 = snap3.snapshot_generation();
assert_ne!(gen1, gen3);
let dir = tempfile::tempdir().unwrap();
let p1 = dir.path().join("s1");
let p3 = dir.path().join("s3");
snap1.save(&p1, &OciTag::new("latest").unwrap()).unwrap();
snap3.save(&p3, &OciTag::new("latest").unwrap()).unwrap();
let loaded1 = Snapshot::checked_load(&p1, OciTag::new("latest").unwrap()).unwrap();
let loaded3 = Snapshot::checked_load(&p3, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded1.snapshot_generation(), gen1);
assert_eq!(loaded3.snapshot_generation(), gen3);
}
#[cfg(target_arch = "x86_64")]
#[test]
fn msrs_round_trip_via_disk() {
let snap = create_snapshot();
let original = snap.msrs().cloned();
assert!(
original.as_ref().is_some_and(|m| !m.is_empty()),
"a running snapshot should capture a non-empty MSR reset set"
);
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.msrs(), original.as_ref());
}
#[cfg(target_arch = "x86_64")]
#[test]
fn snapshot_without_msrs_key_is_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let obj = cfg.as_object_mut().unwrap();
assert!(
obj.remove("msrs").is_some(),
"a running x86_64 snapshot config should carry msrs to remove"
);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "missing field `msrs`");
}
#[cfg(target_arch = "x86_64")]
#[test]
fn disk_snapshot_restores_declared_msr_value() {
const SYSENTER_CS: u32 = 0x174;
let sentinel: u64 = 0xDEAD_BEEF;
let mut source = SandboxBuilder::from_file(simple_guest_as_pathbuf())
.guest_msrs(&[SYSENTER_CS])
.unwrap()
.build()
.unwrap();
source
.call::<()>("WriteMSR", (SYSENTER_CS, sentinel))
.unwrap();
let snap = source.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap());
let mut sbox = SandboxBuilder::from_snapshot(loaded.clone())
.guest_msrs(&[SYSENTER_CS])
.unwrap()
.build()
.unwrap();
assert_eq!(sbox.call::<u64>("ReadMSR", SYSENTER_CS).unwrap(), sentinel);
sbox.call::<()>("WriteMSR", (SYSENTER_CS, sentinel ^ 0x55))
.unwrap();
sbox.restore(loaded).unwrap();
assert_eq!(sbox.call::<u64>("ReadMSR", SYSENTER_CS).unwrap(), sentinel);
}
#[cfg(target_arch = "x86_64")]
#[test]
fn disk_snapshot_restores_into_superset_guest_msrs() {
const SYSENTER_CS: u32 = 0x174;
const SYSENTER_ESP: u32 = 0x175;
let sentinel: u64 = 0xDEAD_BEEF;
let mut source = SandboxBuilder::from_file(simple_guest_as_pathbuf())
.guest_msrs(&[SYSENTER_CS])
.unwrap()
.build()
.unwrap();
source
.call::<()>("WriteMSR", (SYSENTER_CS, sentinel))
.unwrap();
let snap = source.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap());
let mut sbox = SandboxBuilder::from_snapshot(loaded)
.guest_msrs(&[SYSENTER_CS, SYSENTER_ESP])
.unwrap()
.build()
.unwrap();
assert_eq!(sbox.call::<u64>("ReadMSR", SYSENTER_CS).unwrap(), sentinel);
}
#[cfg(target_arch = "x86_64")]
#[test]
fn disk_snapshot_non_superset_guest_msrs_rejected() {
const SYSENTER_CS: u32 = 0x174;
let sentinel: u64 = 0x1234;
let mut source = SandboxBuilder::from_file(simple_guest_as_pathbuf())
.guest_msrs(&[SYSENTER_CS])
.unwrap()
.build()
.unwrap();
source
.call::<()>("WriteMSR", (SYSENTER_CS, sentinel))
.unwrap();
let snap = source.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap());
let err = Sandbox::from_snapshot(loaded.clone(), HostFunctions::default(), None)
.expect_err("loading a snapshot MSR the destination cannot restore must fail");
assert!(
format!("{err:?}").contains("InvalidSnapshotMsrIndex"),
"expected an MSR reset-set mismatch, got: {err:?}"
);
let mut target = create_test_sandbox();
let err = target
.restore(loaded)
.expect_err("restore of a snapshot MSR the destination cannot restore must fail");
assert!(
format!("{err:?}").contains("InvalidSnapshotMsrIndex"),
"expected an MSR reset-set mismatch, got: {err:?}"
);
assert!(target.status().is_poisoned());
}
#[test]
fn pre_init_snapshot_cannot_be_persisted() {
let snap = Snapshot::from_env(
GuestBinary::FilePath(simple_guest_as_pathbuf()),
crate::sandbox::SandboxConfiguration::default(),
)
.unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("preinit");
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{}", err);
assert!(
msg.contains("pre-init snapshots cannot be persisted"),
"expected pre-init rejection, got: {}",
msg
);
assert!(
!path.exists(),
"a rejected save must not create the layout directory"
);
}
#[test]
fn restore_from_loaded_snapshot() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap());
let mut sbox2 = Sandbox::from_snapshot(loaded.clone(), HostFunctions::default(), None).unwrap();
sbox2.call::<i32>("AddToStatic", 5i32).unwrap();
assert_eq!(sbox2.call::<i32>("GetStatic", ()).unwrap(), 5);
sbox2.restore(loaded).unwrap();
assert_eq!(sbox2.call::<i32>("GetStatic", ()).unwrap(), 0);
}
#[test]
fn restore_missing_transport_preserves_target() {
let mut bad_snapshot = create_snapshot();
let snapshot = Arc::get_mut(&mut bad_snapshot).unwrap();
Arc::get_mut(&mut snapshot.state).unwrap().virtq = None;
let file = tempfile::NamedTempFile::new().unwrap();
std::fs::write(file.path(), vec![0x5a; page_size::get() * 2]).unwrap();
let mut target = create_test_sandbox();
target.call::<i32>("AddToStatic", 5i32).unwrap();
let guest_base = 0x200000000_u64;
target.map_file_cow(file.path(), guest_base).unwrap();
let args = (guest_base, hyperlight_common::vmem::PAGE_SIZE as u64, true);
let expected = vec![0x5a; hyperlight_common::vmem::PAGE_SIZE];
assert_eq!(
target.call::<Vec<u8>>("ReadMappedBuffer", args).unwrap(),
expected
);
let cached = target.snapshot().unwrap();
let generation = target.mem_mgr.snapshot_count;
let error = target.restore(bad_snapshot).unwrap_err();
assert!(
error.to_string().contains("no canonical transport state"),
"{error}"
);
assert!(target.status().is_ready());
assert!(Arc::ptr_eq(target.snapshot.as_ref().unwrap(), &cached));
assert_eq!(target.mem_mgr.snapshot_count, generation);
assert_eq!(
target
.call::<Vec<u8>>(
"ReadMappedBuffer",
(guest_base, hyperlight_common::vmem::PAGE_SIZE as u64, false),
)
.unwrap(),
expected
);
assert_eq!(target.call::<i32>("GetStatic", ()).unwrap(), 5);
}
#[test]
fn load_noncanonical_transport_preserves_target() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
let tag = OciTag::new("latest").unwrap();
snapshot.save(&path, &tag).unwrap();
let transport_path = find_transport_blob(&path);
let mut bytes = std::fs::read(&transport_path).unwrap();
bytes[40] = 1;
std::fs::write(&transport_path, bytes).unwrap();
let file = tempfile::NamedTempFile::new().unwrap();
std::fs::write(file.path(), vec![0x5a; page_size::get() * 2]).unwrap();
let mut target = create_test_sandbox();
target.call::<i32>("AddToStatic", 5i32).unwrap();
let guest_base = 0x200000000_u64;
target.map_file_cow(file.path(), guest_base).unwrap();
let args = (guest_base, hyperlight_common::vmem::PAGE_SIZE as u64, true);
let expected = vec![0x5a; hyperlight_common::vmem::PAGE_SIZE];
assert_eq!(
target.call::<Vec<u8>>("ReadMappedBuffer", args).unwrap(),
expected
);
let cached = target.snapshot().unwrap();
let generation = target.mem_mgr.snapshot_count;
let error = Snapshot::load(&path, tag)
.and_then(|snapshot| target.restore(Arc::new(snapshot)))
.unwrap_err();
assert!(
error.to_string().contains("invalid canonical G2H image"),
"{error}"
);
assert!(target.status().is_ready());
assert!(Arc::ptr_eq(target.snapshot.as_ref().unwrap(), &cached));
assert_eq!(target.mem_mgr.snapshot_count, generation);
assert_eq!(
target
.call::<Vec<u8>>(
"ReadMappedBuffer",
(guest_base, hyperlight_common::vmem::PAGE_SIZE as u64, false),
)
.unwrap(),
expected
);
assert_eq!(target.call::<i32>("GetStatic", ()).unwrap(), 5);
}
#[test]
fn restore_across_independent_oci_loads_succeeds() {
let snap1 = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let p1 = dir.path().join("snap1");
snap1.save(&p1, &OciTag::new("latest").unwrap()).unwrap();
let p2 = dir.path().join("snap2");
snap1.save(&p2, &OciTag::new("latest").unwrap()).unwrap();
let loaded1 = Arc::new(Snapshot::checked_load(&p1, OciTag::new("latest").unwrap()).unwrap());
let loaded2 = Arc::new(Snapshot::checked_load(&p2, OciTag::new("latest").unwrap()).unwrap());
let mut sbox = Sandbox::from_snapshot(loaded2, HostFunctions::default(), None).unwrap();
sbox.restore(loaded1).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 0);
}
#[test]
fn cow_does_not_mutate_backing_file() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let blobs_dir = path.join("blobs").join("sha256");
let snapshot_before: std::collections::BTreeMap<_, _> = std::fs::read_dir(&blobs_dir)
.unwrap()
.map(|e| {
let e = e.unwrap();
let bytes = std::fs::read(e.path()).unwrap();
(e.file_name(), bytes)
})
.collect();
{
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let mut sbox =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
sbox.call::<i32>("AddToStatic", 99).unwrap();
}
let snapshot_after: std::collections::BTreeMap<_, _> = std::fs::read_dir(&blobs_dir)
.unwrap()
.map(|e| {
let e = e.unwrap();
let bytes = std::fs::read(e.path()).unwrap();
(e.file_name(), bytes)
})
.collect();
assert_eq!(
snapshot_before, snapshot_after,
"CoW writes must not mutate any blob in the OCI layout"
);
}
fn sha256_hex(bytes: &[u8]) -> String {
let arr: [u8; 32] = Sha256::digest(bytes).into();
hex::encode(arr)
}
fn rewrite_config<F: FnOnce(&mut Value)>(oci_dir: &std::path::Path, mutate: F) {
let cfg_path = find_config_blob(oci_dir);
let mut cfg: Value = serde_json::from_slice(&std::fs::read(&cfg_path).unwrap()).unwrap();
mutate(&mut cfg);
let new_cfg_bytes = serde_json::to_vec_pretty(&cfg).unwrap();
let new_cfg_hex = sha256_hex(&new_cfg_bytes);
let blobs_dir = oci_dir.join("blobs").join("sha256");
let new_cfg_path = blobs_dir.join(&new_cfg_hex);
std::fs::write(&new_cfg_path, &new_cfg_bytes).unwrap();
if new_cfg_path != cfg_path {
std::fs::remove_file(&cfg_path).ok();
}
let mp = manifest_path(oci_dir);
let mut manifest: Value = serde_json::from_slice(&std::fs::read(&mp).unwrap()).unwrap();
manifest["config"]["digest"] = Value::from(format!("sha256:{}", new_cfg_hex));
manifest["config"]["size"] = Value::from(new_cfg_bytes.len() as u64);
let new_manifest_bytes = serde_json::to_vec_pretty(&manifest).unwrap();
let new_manifest_hex = sha256_hex(&new_manifest_bytes);
let new_manifest_path = blobs_dir.join(&new_manifest_hex);
std::fs::write(&new_manifest_path, &new_manifest_bytes).unwrap();
if new_manifest_path != mp {
std::fs::remove_file(&mp).ok();
}
let index_path = oci_dir.join("index.json");
let mut index: Value = serde_json::from_slice(&std::fs::read(&index_path).unwrap()).unwrap();
index["manifests"][0]["digest"] = Value::from(format!("sha256:{}", new_manifest_hex));
index["manifests"][0]["size"] = Value::from(new_manifest_bytes.len() as u64);
std::fs::write(index_path, serde_json::to_vec_pretty(&index).unwrap()).unwrap();
}
fn manifest_path(oci_dir: &std::path::Path) -> std::path::PathBuf {
let index: Value =
serde_json::from_slice(&std::fs::read(oci_dir.join("index.json")).unwrap()).unwrap();
let digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap()
.to_string();
oci_dir.join("blobs").join("sha256").join(digest)
}
fn rewrite_manifest<F: FnOnce(&mut Value)>(oci_dir: &std::path::Path, mutate: F) {
let mp = manifest_path(oci_dir);
let mut manifest: Value = serde_json::from_slice(&std::fs::read(&mp).unwrap()).unwrap();
mutate(&mut manifest);
let new_bytes = serde_json::to_vec_pretty(&manifest).unwrap();
let new_hex = sha256_hex(&new_bytes);
let blobs_dir = oci_dir.join("blobs").join("sha256");
let new_path = blobs_dir.join(&new_hex);
std::fs::write(&new_path, &new_bytes).unwrap();
if new_path != mp {
std::fs::remove_file(&mp).ok();
}
let index_path = oci_dir.join("index.json");
let mut index: Value = serde_json::from_slice(&std::fs::read(&index_path).unwrap()).unwrap();
index["manifests"][0]["digest"] = Value::from(format!("sha256:{}", new_hex));
index["manifests"][0]["size"] = Value::from(new_bytes.len() as u64);
std::fs::write(index_path, serde_json::to_vec_pretty(&index).unwrap()).unwrap();
}
fn rewrite_index<F: FnOnce(&mut Value)>(oci_dir: &std::path::Path, mutate: F) {
let path = oci_dir.join("index.json");
let mut index: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
mutate(&mut index);
std::fs::write(path, serde_json::to_vec_pretty(&index).unwrap()).unwrap();
}
#[test]
fn arch_mismatch_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
rewrite_config(&path, |cfg| {
cfg["arch"] = Value::from(if cfg!(target_arch = "x86_64") {
"aarch64"
} else {
"x86_64"
});
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("architecture") || msg.contains("arch"),
"expected architecture mismatch, got: {}",
msg
);
}
#[test]
fn abi_version_mismatch_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
rewrite_config(&path, |cfg| {
cfg["abi_version"] = Value::from(9999u32);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("ABI") || msg.contains("abi"),
"expected ABI version mismatch, got: {}",
msg
);
}
#[test]
fn hypervisor_mismatch_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let current = cfg_current_hypervisor();
let other = if current == "kvm" { "mshv" } else { "kvm" };
rewrite_config(&path, |cfg| {
cfg["hypervisor"] = Value::from(other);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("hypervisor"),
"expected hypervisor mismatch, got: {}",
msg
);
}
fn cfg_current_hypervisor() -> &'static str {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("probe");
create_snapshot()
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let cfg_path = find_config_blob(&path);
let cfg: Value = serde_json::from_slice(&std::fs::read(&cfg_path).unwrap()).unwrap();
match cfg["hypervisor"].as_str().unwrap() {
"kvm" => "kvm",
"mshv" => "mshv",
"whp" => "whp",
"hvf" => "hvf",
other => panic!("unknown hypervisor tag {other}"),
}
}
#[test]
fn cpu_vendor_mismatch_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
rewrite_config(&path, |cfg| {
cfg["cpu_vendor"] = Value::from("not-this-cpu-vendor");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("vendor"),
"expected CPU vendor mismatch, got: {}",
msg
);
}
#[test]
fn call_snapshot_without_sregs_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
rewrite_config(&path, |cfg| {
cfg.as_object_mut().unwrap().remove("sregs");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("sregs") || msg.contains("missing field") || msg.contains("config"),
"expected serde error about missing sregs, got: {}",
msg
);
}
fn create_sandbox_with_custom_host_funcs() -> Sandbox {
let path = simple_guest_as_pathbuf();
SandboxBuilder::from_file(path)
.host_function("Add", |a: i32, b: i32| Ok(a + b))
.build()
.unwrap()
}
fn host_funcs_with_matching_add() -> HostFunctions {
let mut hf = HostFunctions::default();
hf.register_host_function("Add", |a: i32, b: i32| Ok(a + b))
.unwrap();
hf
}
#[test]
fn from_snapshot_accepts_matching_host_functions() {
let mut sbox = create_sandbox_with_custom_host_funcs();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let mut sbox2 =
Sandbox::from_snapshot(Arc::new(loaded), host_funcs_with_matching_add(), None).unwrap();
assert_eq!(sbox2.call::<i32>("GetStatic", ()).unwrap(), 0);
}
#[test]
fn from_snapshot_rejects_missing_host_function() {
let mut sbox = create_sandbox_with_custom_host_funcs();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let err = Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None)
.expect_err("from_snapshot must reject a HostFunctions set missing `Add`");
let msg = format!("{}", err);
assert!(
msg.contains("missing") && msg.contains("Add"),
"expected missing-host-function error mentioning Add, got: {}",
msg
);
}
#[test]
fn from_snapshot_rejects_signature_mismatch() {
let mut sbox = create_sandbox_with_custom_host_funcs();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let mut hf = HostFunctions::default();
hf.register_host_function("Add", |a: String, b: String| Ok(format!("{a}{b}")))
.unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let err = Sandbox::from_snapshot(Arc::new(loaded), hf, None)
.expect_err("from_snapshot must reject a signature mismatch on Add");
let msg = format!("{}", err);
assert!(
msg.contains("signature mismatches") && msg.contains("Add"),
"expected signature-mismatch error mentioning Add, got: {}",
msg
);
}
#[test]
fn from_snapshot_accepts_extra_host_functions() {
let mut sbox = create_sandbox_with_custom_host_funcs();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let mut hf = host_funcs_with_matching_add();
hf.register_host_function("Mul", |a: i32, b: i32| Ok(a * b))
.unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let mut sbox2 = Sandbox::from_snapshot(Arc::new(loaded), hf, None).unwrap();
assert_eq!(sbox2.call::<i32>("GetStatic", ()).unwrap(), 0);
}
#[test]
fn from_snapshot_accepts_zero_arg_host_function() {
let path = simple_guest_as_pathbuf();
let mut sbox = SandboxBuilder::from_file(path)
.host_function("Zero", || Ok(7i64))
.build()
.unwrap();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let mut hf = HostFunctions::default();
hf.register_host_function("Zero", || Ok(7i64)).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let _sbox2 = Sandbox::from_snapshot(Arc::new(loaded), hf, None)
.expect("zero-arg host function must round-trip through OCI");
}
#[test]
fn missing_oci_layout_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
std::fs::remove_file(path.join("oci-layout")).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("oci-layout"),
"expected missing oci-layout error, got: {}",
msg
);
}
#[test]
fn wrong_image_layout_version_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
std::fs::write(
path.join("oci-layout"),
r#"{"imageLayoutVersion":"99.0.0"}"#,
)
.unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("image layout version") || msg.contains("imageLayoutVersion"),
"expected layout version error, got: {}",
msg
);
}
#[test]
fn missing_index_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
std::fs::remove_file(path.join("index.json")).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("index.json"),
"expected missing index.json error, got: {}",
msg
);
}
#[test]
fn snapshot_blob_size_mismatch_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let blobs_dir = path.join("blobs").join("sha256");
let manifest_bytes = std::fs::read(path.join("index.json")).unwrap();
let index: Value = serde_json::from_slice(&manifest_bytes).unwrap();
let manifest_digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
let manifest_path = blobs_dir.join(manifest_digest);
let manifest: Value = serde_json::from_slice(&std::fs::read(&manifest_path).unwrap()).unwrap();
let snap_digest = manifest["layers"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
let snap_path = blobs_dir.join(snap_digest);
let bytes = std::fs::read(&snap_path).unwrap();
std::fs::write(&snap_path, &bytes[..bytes.len() - 1]).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("size") || msg.contains("mismatch"),
"expected size mismatch error, got: {}",
msg
);
}
#[test]
fn snapshot_scratch_size_not_in_host_pages_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let size = cfg["layout"]["scratch_size"].as_u64().unwrap();
cfg["layout"]["scratch_size"] = Value::from(size + 2048);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "is not a multiple of this host's");
}
#[test]
fn snapshot_layer_gpa_unaligned_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let gpa = cfg["layers"][0]["gpa_start"].as_u64().unwrap();
cfg["layers"][0]["gpa_start"] = Value::from(gpa + 1);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "not aligned");
}
#[test]
fn snapshot_page_table_len_unaligned_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let layer = cfg["page_table_layer"].as_u64().unwrap() as usize;
let len = cfg["layers"][layer]["page_table_len"].as_u64().unwrap();
cfg["layers"][layer]["page_table_len"] = Value::from(len + 1);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "size");
}
#[test]
fn snapshot_missing_page_table_len_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["layers"][0]
.as_object_mut()
.unwrap()
.remove("page_table_len");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "page_table_len");
}
#[test]
fn snapshot_page_table_len_zero_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let layer = cfg["page_table_layer"].as_u64().unwrap() as usize;
cfg["layers"][layer]["page_table_len"] = Value::from(0u64);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "does not match its data and page-table lengths");
}
#[test]
fn missing_snapshot_blob_rejected() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let blobs_dir = path.join("blobs").join("sha256");
let manifest_bytes = std::fs::read(path.join("index.json")).unwrap();
let index: Value = serde_json::from_slice(&manifest_bytes).unwrap();
let manifest_digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
let manifest_path = blobs_dir.join(manifest_digest);
let manifest: Value = serde_json::from_slice(&std::fs::read(&manifest_path).unwrap()).unwrap();
let snap_digest = manifest["layers"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap();
std::fs::remove_file(blobs_dir.join(snap_digest)).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("snapshot blob") || msg.contains("No such") || msg.contains("not found"),
"expected missing-blob error, got: {}",
msg
);
}
#[test]
fn checked_load_nonexistent_path_returns_error() {
let err = unwrap_err_snapshot(Snapshot::checked_load(
"/nonexistent/path/to/oci",
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("stat") || msg.contains("No such") || msg.contains("not found"),
"expected missing-path error, got: {}",
msg
);
}
#[test]
fn checked_load_file_not_directory_rejected() {
let dir = tempfile::tempdir().unwrap();
let file_path = dir.path().join("not-a-dir");
std::fs::write(&file_path, b"hello").unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&file_path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("not a directory"),
"expected not-a-directory error, got: {}",
msg
);
}
#[test]
fn save_appends_into_existing_layout_with_new_tag() {
let snap_a = create_snapshot();
let snap_b = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap_a.save(&path, &OciTag::new("a").unwrap()).unwrap();
snap_b.save(&path, &OciTag::new("b").unwrap()).unwrap();
let _ = Snapshot::checked_load(&path, OciTag::new("a").unwrap()).unwrap();
let _ = Snapshot::checked_load(&path, OciTag::new("b").unwrap()).unwrap();
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let manifests = index["manifests"].as_array().unwrap();
let tags: Vec<&str> = manifests
.iter()
.map(|m| {
m["annotations"]["org.opencontainers.image.ref.name"]
.as_str()
.unwrap()
})
.collect();
assert_eq!(tags.len(), 2);
assert!(tags.contains(&"a"));
assert!(tags.contains(&"b"));
let expected_arch = if cfg!(target_arch = "aarch64") {
"aarch64"
} else {
"x86_64"
};
for m in manifests {
let anns = &m["annotations"];
assert_eq!(
anns["dev.hyperlight.snapshot.arch"].as_str().unwrap(),
expected_arch
);
let hv = anns["dev.hyperlight.snapshot.hypervisor"].as_str().unwrap();
assert!(
["kvm", "mshv", "whp", "hvf"].contains(&hv),
"unexpected hypervisor annotation: {}",
hv
);
let cpu = anns["dev.hyperlight.snapshot.cpu.vendor"].as_str().unwrap();
assert!(!cpu.is_empty(), "missing cpu vendor annotation");
}
}
#[test]
fn save_replaces_descriptor_for_same_tag() {
let mut sbox = create_test_sandbox();
sbox.call::<String>("Echo", "first".to_string()).unwrap();
let snap_first = sbox.snapshot().unwrap();
sbox.call::<String>("Echo", "second".to_string()).unwrap();
let snap_second = sbox.snapshot().unwrap();
let gen_second = snap_second.snapshot_generation();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap_first
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
snap_second
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.snapshot_generation(), gen_second);
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let entries: Vec<&Value> = index["manifests"]
.as_array()
.unwrap()
.iter()
.filter(|m| {
m["annotations"]["org.opencontainers.image.ref.name"].as_str() == Some("latest")
})
.collect();
assert_eq!(entries.len(), 1, "expected one descriptor for tag 'latest'");
}
#[test]
fn save_requires_parent_dir_to_exist() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let missing_parent = dir.path().join("a").join("b").join("c");
let path = missing_parent.join("store");
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("parent directory") || msg.contains("not accessible"),
"expected missing-parent error, got: {msg}"
);
assert!(!missing_parent.exists(), "no parent dirs should be created");
}
#[test]
fn save_rejects_regular_file_at_path() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("not-a-dir");
std::fs::write(&path, b"i am a file").unwrap();
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("is not a directory") || msg.contains("layout dir"),
"expected non-directory error, got: {msg}"
);
assert_eq!(std::fs::read(&path).unwrap(), b"i am a file");
}
#[test]
fn save_rejects_unsupported_existing_layout_version() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
std::fs::create_dir_all(&path).unwrap();
std::fs::write(
path.join("oci-layout"),
br#"{"imageLayoutVersion":"99.0.0"}"#,
)
.unwrap();
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("imageLayoutVersion") || msg.contains("unsupported"),
"expected unsupported-version error, got: {msg}"
);
assert!(
!path.join("index.json").exists(),
"save must not have written index.json"
);
}
#[test]
fn save_into_empty_existing_directory() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
std::fs::create_dir_all(&path).unwrap();
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let _ = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert!(path.join("oci-layout").exists());
assert!(path.join("index.json").exists());
}
#[test]
fn save_preserves_unrelated_files_in_layout_dir() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
std::fs::create_dir_all(&path).unwrap();
std::fs::write(path.join("README.md"), b"keep me").unwrap();
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
assert_eq!(std::fs::read(path.join("README.md")).unwrap(), b"keep me");
}
#[test]
fn save_same_tag_same_content_is_idempotent() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let blobs_after_first: Vec<_> = std::fs::read_dir(path.join("blobs").join("sha256"))
.unwrap()
.filter_map(|e| e.ok().map(|e| e.file_name()))
.collect();
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let blobs_after_second: Vec<_> = std::fs::read_dir(path.join("blobs").join("sha256"))
.unwrap()
.filter_map(|e| e.ok().map(|e| e.file_name()))
.collect();
assert_eq!(blobs_after_first.len(), blobs_after_second.len());
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let manifests = index["manifests"].as_array().unwrap();
assert_eq!(manifests.len(), 1);
assert_eq!(
manifests[0]["annotations"]["org.opencontainers.image.ref.name"],
"latest"
);
}
#[test]
fn save_shares_blobs_across_tags_with_identical_content() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap.save(&path, &OciTag::new("a").unwrap()).unwrap();
snap.save(&path, &OciTag::new("b").unwrap()).unwrap();
let blobs: Vec<_> = std::fs::read_dir(path.join("blobs").join("sha256"))
.unwrap()
.filter_map(|e| e.ok().map(|e| e.file_name()))
.collect();
assert_eq!(
blobs.len(),
snap.snapshot_memory().blobs().count() + 3,
"expected deduped blobs, got {:?}",
blobs
);
}
#[test]
fn save_replace_in_middle_preserves_other_tags() {
let mut sbox = create_test_sandbox();
let snap_a = sbox.snapshot().unwrap();
sbox.call::<String>("Echo", "x".to_string()).unwrap();
let snap_b = sbox.snapshot().unwrap();
sbox.call::<String>("Echo", "y".to_string()).unwrap();
let snap_c = sbox.snapshot().unwrap();
sbox.call::<String>("Echo", "z".to_string()).unwrap();
let snap_b2 = sbox.snapshot().unwrap();
let gen_b2 = snap_b2.snapshot_generation();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap_a.save(&path, &OciTag::new("a").unwrap()).unwrap();
snap_b.save(&path, &OciTag::new("b").unwrap()).unwrap();
snap_c.save(&path, &OciTag::new("c").unwrap()).unwrap();
snap_b2.save(&path, &OciTag::new("b").unwrap()).unwrap();
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let tags: Vec<&str> = index["manifests"]
.as_array()
.unwrap()
.iter()
.map(|m| {
m["annotations"]["org.opencontainers.image.ref.name"]
.as_str()
.unwrap()
})
.collect();
assert_eq!(tags.len(), 3);
assert!(tags.contains(&"a"));
assert!(tags.contains(&"b"));
assert!(tags.contains(&"c"));
let loaded_b = Snapshot::checked_load(&path, OciTag::new("b").unwrap()).unwrap();
assert_eq!(loaded_b.snapshot_generation(), gen_b2);
}
#[test]
fn save_rejects_malformed_existing_oci_layout_json() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
std::fs::create_dir_all(&path).unwrap();
std::fs::write(path.join("oci-layout"), b"not json").unwrap();
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("oci-layout") && msg.contains("JSON"),
"expected oci-layout JSON error, got: {msg}"
);
assert!(!path.join("index.json").exists());
}
#[test]
fn save_rejects_existing_oci_layout_missing_version() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
std::fs::create_dir_all(&path).unwrap();
std::fs::write(path.join("oci-layout"), br#"{"other":"field"}"#).unwrap();
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("imageLayoutVersion"),
"expected missing-version error, got: {msg}"
);
assert!(!path.join("index.json").exists());
}
#[test]
fn save_rejects_malformed_existing_index_json() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
std::fs::create_dir_all(&path).unwrap();
std::fs::write(
path.join("oci-layout"),
br#"{"imageLayoutVersion":"1.0.0"}"#,
)
.unwrap();
std::fs::write(path.join("index.json"), b"{not valid json").unwrap();
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
let msg = format!("{err}");
assert!(
msg.contains("index.json"),
"expected index.json error, got: {msg}"
);
assert_eq!(
std::fs::read(path.join("index.json")).unwrap(),
b"{not valid json",
"save must not overwrite a malformed existing index.json"
);
}
#[test]
fn checked_load_rejects_snapshot_blob_byte_mutation() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let blobs_dir = path.join("blobs").join("sha256");
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let manifest_digest = index["manifests"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap()
.to_string();
let manifest: Value =
serde_json::from_slice(&std::fs::read(blobs_dir.join(&manifest_digest)).unwrap()).unwrap();
let snap_digest = manifest["layers"][0]["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap()
.to_string();
let snap_path = blobs_dir.join(&snap_digest);
let mut bytes = std::fs::read(&snap_path).unwrap();
let mid = bytes.len() / 2;
bytes[mid] ^= 0xFF;
std::fs::write(&snap_path, &bytes).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("digest") || msg.contains("hash") || msg.contains("sha256"),
"expected digest-mismatch error, got: {}",
msg
);
}
#[test]
fn checked_load_rejects_transport_blob_byte_mutation() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let transport_path = find_transport_blob(&path);
let mut bytes = std::fs::read(&transport_path).unwrap();
let mid = bytes.len() / 2;
bytes[mid] ^= 0xFF;
std::fs::write(&transport_path, bytes).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "digest");
}
#[test]
fn unchecked_load_rejects_noncanonical_transport() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let transport_path = find_transport_blob(&path);
let mut bytes = std::fs::read(&transport_path).unwrap();
*bytes.last_mut().unwrap() ^= 1;
std::fs::write(&transport_path, bytes).unwrap();
let error = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(error, "invalid canonical H2G image");
}
#[test]
fn checked_load_rejects_config_blob_byte_mutation() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let cfg_path = find_config_blob(&path);
let mut bytes = std::fs::read(&cfg_path).unwrap();
bytes[0] = b' ';
std::fs::write(&cfg_path, &bytes).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("digest") || msg.contains("hash") || msg.contains("sha256"),
"expected digest-mismatch error, got: {}",
msg
);
}
fn save_for_mutation() -> (tempfile::TempDir, std::path::PathBuf) {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
(dir, path)
}
fn blob_path(path: &std::path::Path, descriptor: &Value) -> std::path::PathBuf {
path.join("blobs").join("sha256").join(
descriptor["digest"]
.as_str()
.unwrap()
.strip_prefix("sha256:")
.unwrap(),
)
}
fn write_layered_blob(path: &std::path::Path, bytes: &[u8], descriptor: &mut Value) {
let digest = sha256_hex(bytes);
std::fs::write(path.join("blobs").join("sha256").join(&digest), bytes).unwrap();
descriptor["digest"] = Value::from(format!("sha256:{digest}"));
descriptor["size"] = Value::from(bytes.len() as u64);
}
fn make_layered_layout(path: &std::path::Path, split_data: bool) {
if !split_data {
return;
}
let cfg: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(path)).unwrap()).unwrap();
let image = std::fs::read(find_snapshot_blob(path)).unwrap();
let first = &cfg["layers"][0];
let data_len = first["data_len"].as_u64().unwrap() as usize;
let page_size = page_size::get();
let boundary = (data_len / 2 / page_size) * page_size;
assert!(boundary > 0 && boundary < data_len);
let base = first["gpa_start"].as_u64().unwrap();
let parts = [
(&image[..boundary], 0, boundary, 0),
(
&image[boundary..],
boundary,
data_len - boundary,
first["page_table_len"].as_u64().unwrap(),
),
];
let mut layers = Vec::new();
let mut data_descriptors = Vec::new();
let manifest: Value =
serde_json::from_slice(&std::fs::read(manifest_path(path)).unwrap()).unwrap();
for (bytes, start, part_data_len, page_table_len) in parts {
layers.push(serde_json::json!({
"gpa_start": base + start as u64,
"data_len": part_data_len,
"page_table_len": page_table_len
}));
let mut descriptor = manifest["layers"][0].clone();
descriptor["mediaType"] = Value::from(super::file::MT_SNAPSHOT_V2);
write_layered_blob(path, bytes, &mut descriptor);
data_descriptors.push(descriptor);
}
layers.extend_from_slice(&cfg["layers"].as_array().unwrap()[1..]);
data_descriptors.extend_from_slice(&manifest["layers"].as_array().unwrap()[1..]);
let page_table_layer = match cfg["page_table_layer"].as_u64().unwrap() {
0 => 1,
index => index + 1,
};
rewrite_config(path, |cfg| {
cfg["layers"] = Value::Array(layers);
cfg["page_table_layer"] = Value::from(page_table_layer);
});
rewrite_manifest(path, |manifest| {
manifest["layers"] = Value::Array(data_descriptors);
});
}
#[test]
fn layered_oci_load_restores_data_page_tables_and_transport() {
let (_dir, path) = save_for_mutation();
let config: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
let data_layers = config["layers"]
.as_array()
.unwrap()
.iter()
.filter(|layer| layer["data_len"].as_u64().unwrap() > 0)
.count();
make_layered_layout(&path, true);
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.snapshot_memory().layers().len(), data_layers + 1);
let mut sandbox =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
let result: String = sandbox.call("Echo", "layered".to_string()).unwrap();
assert_eq!(result, "layered");
}
#[test]
fn layered_oci_rejects_missing_descriptor() {
let (_dir, path) = save_for_mutation();
make_layered_layout(&path, false);
rewrite_manifest(&path, |manifest| {
manifest["layers"].as_array_mut().unwrap().remove(0);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "snapshot layers and one transport layer");
}
#[test]
fn layered_oci_rejects_wrong_descriptor_media() {
for (media_type, expected_error) in [
(
super::file::MT_SNAPSHOT_V2,
"unexpected snapshot layer media type",
),
(
super::file::MT_TRANSPORT_V1,
"unexpected transport layer media type",
),
] {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |manifest| {
let descriptor = manifest["layers"]
.as_array_mut()
.unwrap()
.iter_mut()
.find(|descriptor| descriptor["mediaType"] == media_type)
.unwrap();
descriptor["mediaType"] = Value::from("application/vnd.example.other");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, expected_error);
}
}
#[test]
fn layered_oci_rejects_mismatched_storage_size_before_opening() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |manifest| {
manifest["layers"][0]["size"] = Value::from(u64::MAX / 2);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "does not match its data and page-table lengths");
}
#[test]
fn layered_oci_rejects_overlapping_data_layers() {
let (_dir, path) = save_for_mutation();
make_layered_layout(&path, true);
rewrite_config(&path, |cfg| {
cfg["layers"][1]["gpa_start"] = cfg["layers"][0]["gpa_start"].clone();
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "overlap");
}
#[test]
fn layered_oci_rejects_too_many_data_layers() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let layer = cfg["layers"][0].clone();
cfg["layers"] = Value::from(vec![layer; super::memory::MAX_SNAPSHOT_LAYERS + 2]);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "data layers, limit is");
}
#[test]
fn layered_oci_rejects_data_beyond_scratch_before_opening() {
let (_dir, path) = save_for_mutation();
let data_len = 1u64 << 40;
let mut page_table_len = 0;
rewrite_config(&path, |cfg| {
cfg["layers"][0]["data_len"] = Value::from(data_len);
page_table_len = cfg["layers"][0]["page_table_len"].as_u64().unwrap();
});
rewrite_manifest(&path, |manifest| {
manifest["layers"][0]["size"] =
Value::from((data_len + page_table_len).next_multiple_of(page_size::get() as u64));
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "snapshot data exceeds");
}
#[test]
fn layered_oci_rejects_mismatched_artifact_type() {
let (_dir, path) = save_for_mutation();
make_layered_layout(&path, false);
rewrite_manifest(&path, |manifest| {
manifest["artifactType"] = Value::from("application/vnd.example.other");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "does not match config media type");
}
fn assert_err_contains(err: crate::HyperlightError, needle: &str) {
let msg = format!("{}", err);
assert!(
msg.contains(needle),
"expected error to contain {:?}, got: {}",
needle,
msg
);
}
#[test]
fn malformed_oci_layout_rejected() {
let (_dir, path) = save_for_mutation();
std::fs::write(path.join("oci-layout"), b"not-valid-json{").unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "oci-layout");
}
#[test]
fn oci_layout_missing_version_field_rejected() {
let (_dir, path) = save_for_mutation();
std::fs::write(path.join("oci-layout"), r#"{"unrelated":"field"}"#).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "imageLayoutVersion");
}
#[test]
fn malformed_index_json_rejected() {
let (_dir, path) = save_for_mutation();
std::fs::write(path.join("index.json"), b"{not json").unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "index.json");
}
#[test]
fn wrong_index_schema_version_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
idx["schemaVersion"] = Value::from(99u32);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "schemaVersion");
}
#[test]
fn wrong_index_media_type_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
idx["mediaType"] = Value::from("application/vnd.oci.image.manifest.v1+json");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "media type");
}
#[test]
fn missing_index_media_type_accepted() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
idx.as_object_mut().unwrap().remove("mediaType");
});
Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
}
#[test]
fn wrong_manifest_media_type_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |manifest| {
manifest["mediaType"] = Value::from("application/vnd.oci.image.index.v1+json");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "media type");
}
#[test]
fn missing_manifest_media_type_accepted() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |manifest| {
manifest.as_object_mut().unwrap().remove("mediaType");
});
Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
}
#[test]
fn empty_index_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
idx["manifests"] = Value::Array(Vec::new());
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "no manifest tagged");
}
#[test]
fn checked_load_rejects_duplicate_tag_in_index() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
let first = idx["manifests"][0].clone();
idx["manifests"].as_array_mut().unwrap().push(first);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "multiple manifests tagged");
}
#[test]
fn missing_manifest_blob_rejected() {
let (_dir, path) = save_for_mutation();
std::fs::remove_file(manifest_path(&path)).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("open") || msg.contains("No such") || msg.contains("not found"),
"expected missing-manifest error, got: {}",
msg
);
}
#[test]
fn bad_digest_format_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
idx["manifests"][0]["digest"] = Value::from("deadbeef");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("digest") || msg.contains("index.json"),
"expected digest or parse error, got: {}",
msg
);
}
#[test]
fn malformed_manifest_json_rejected() {
let (_dir, path) = save_for_mutation();
let mp = manifest_path(&path);
std::fs::write(&mp, b"{not json").unwrap();
let new_len = std::fs::metadata(&mp).unwrap().len();
rewrite_index(&path, |idx| {
idx["manifests"][0]["size"] = Value::from(new_len);
});
let err = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(err, "failed to parse OCI manifest JSON");
}
#[test]
fn wrong_manifest_schema_version_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["schemaVersion"] = Value::from(99u32);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "schemaVersion");
}
#[test]
fn unknown_config_media_type_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["config"]["mediaType"] = Value::from("application/vnd.example.unknown.v1+json");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "config media type");
}
#[test]
fn legacy_config_versions_rejected() {
for media_type in [
"application/vnd.hyperlight.snapshot.config.v1+json",
"application/vnd.hyperlight.snapshot.config.v2+json",
"application/vnd.hyperlight.snapshot.config.v3+json",
"application/vnd.hyperlight.snapshot.config.v4+json",
] {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["config"]["mediaType"] = Value::from(media_type);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "incompatible with snapshot ABI 9");
}
}
#[test]
fn empty_layers_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["layers"] = Value::Array(Vec::new());
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "layer");
}
#[test]
fn extra_layers_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
let first = m["layers"][0].clone();
m["layers"].as_array_mut().unwrap().push(first);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "layer");
}
#[test]
fn unknown_snapshot_layer_media_type_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["layers"][0]["mediaType"] = Value::from("application/vnd.example.unknown.v1");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "snapshot layer media type");
}
#[test]
fn unknown_transport_layer_media_type_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
let descriptor = m["layers"].as_array_mut().unwrap().last_mut().unwrap();
descriptor["mediaType"] = Value::from("application/vnd.example.unknown.v1");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "transport layer media type");
}
#[test]
fn manifest_and_index_annotations_tolerated() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
rewrite_manifest(&path, |m| {
let mut anns = serde_json::Map::new();
anns.insert(
"org.opencontainers.image.created".to_string(),
Value::from("2024-01-01T00:00:00Z"),
);
anns.insert(
"dev.sigstore.cosign/signature".to_string(),
Value::from("MEUCIQDsignature"),
);
m["annotations"] = Value::Object(anns);
});
rewrite_index(&path, |idx| {
let mut anns = serde_json::Map::new();
anns.insert(
"org.opencontainers.image.ref.name".to_string(),
Value::from("v1.2.3"),
);
idx["annotations"] = Value::Object(anns);
});
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let mut sbox2 =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
assert_eq!(sbox2.call::<i32>("GetStatic", ()).unwrap(), 0);
}
#[test]
fn manifest_blob_size_descriptor_mismatch_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
let size = idx["manifests"][0]["size"].as_u64().unwrap();
idx["manifests"][0]["size"] = Value::from(size + 1);
});
let error = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(error, "manifest blob size mismatch");
}
#[test]
fn config_blob_size_descriptor_mismatch_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
let sz = m["config"]["size"].as_u64().unwrap();
m["config"]["size"] = Value::from(sz + 1);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "config blob size mismatch");
}
#[test]
fn transport_blob_size_descriptor_mismatch_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |manifest| {
let descriptor = manifest["layers"]
.as_array_mut()
.unwrap()
.last_mut()
.unwrap();
let size = descriptor["size"].as_u64().unwrap();
descriptor["size"] = Value::from(size + 1);
});
let error = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(error, "transport blob size mismatch");
}
#[test]
fn malformed_config_json_rejected() {
let (_dir, path) = save_for_mutation();
let cfg_path = find_config_blob(&path);
std::fs::write(&cfg_path, b"{not json").unwrap();
let new_cfg_len = std::fs::metadata(&cfg_path).unwrap().len();
rewrite_manifest(&path, |m| {
m["config"]["size"] = Value::from(new_cfg_len);
});
let err = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(err, "config JSON");
}
#[test]
fn bad_init_data_permissions_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["layout"]["init_data_permissions"] = Value::from(0x8000_0000u32);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "init_data_permissions");
}
#[test]
fn entrypoint_addr_outside_snapshot_region_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["entrypoint_addr"] = Value::from(0xDEAD_BEEF_0000u64);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "entrypoint addr");
}
#[test]
fn entrypoint_addr_below_base_address_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["entrypoint_addr"] = Value::from(0u64);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "entrypoint addr");
}
#[test]
fn original_entrypoint_addr_outside_snapshot_region_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["original_entrypoint_addr"] = Value::from(0xDEAD_BEEF_0000u64);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "original entrypoint addr");
}
#[test]
fn original_entrypoint_addr_zero_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["original_entrypoint_addr"] = Value::from(0u64);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "original entrypoint addr");
}
#[test]
fn entrypoint_addr_outside_code_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let code_virt_base = cfg["layout"]["code_virt_base"].as_u64().unwrap();
let code_size = cfg["layout"]["code_size"].as_u64().unwrap();
let page_size = hyperlight_common::vmem::PAGE_SIZE as u64;
let beyond_code = code_virt_base + code_size.next_multiple_of(page_size);
cfg["entrypoint_addr"] = Value::from(beyond_code);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "entrypoint addr");
}
#[cfg(target_arch = "aarch64")]
#[test]
fn unaligned_entrypoint_addr_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let entrypoint = cfg["entrypoint_addr"].as_u64().unwrap();
cfg["entrypoint_addr"] = Value::from(entrypoint + 1);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "entrypoint addr");
}
#[test]
fn load_round_trips() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Snapshot::load(&path, OciTag::new("latest").unwrap()).unwrap();
let mut sbox2 =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
let result: String = sbox2.call("Echo", "hi\n".to_string()).unwrap();
assert_eq!(result, "hi\n");
}
#[test]
fn load_still_validates_config_fields() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["arch"] = Value::from(if cfg!(target_arch = "x86_64") {
"aarch64"
} else {
"x86_64"
});
});
let err = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
let msg = format!("{}", err);
assert!(
msg.contains("architecture") || msg.contains("arch"),
"expected architecture mismatch under load, got: {}",
msg
);
}
#[test]
fn load_accepts_digest_mismatched_snapshot_blob() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let snap_path = find_snapshot_blob(&path);
let mut bytes = std::fs::read(&snap_path).unwrap();
let mid = bytes.len() / 2;
bytes[mid] ^= 0xFF;
std::fs::write(&snap_path, &bytes).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "digest");
let _ = Snapshot::load(&path, OciTag::new("latest").unwrap())
.expect("load loads a digest-mismatched blob");
}
#[test]
fn checked_load_rejects_manifest_blob_byte_mutation() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let mp = manifest_path(&path);
let mut bytes = std::fs::read(&mp).unwrap();
bytes[0] ^= 0x20;
std::fs::write(&mp, &bytes).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "digest mismatch");
}
#[test]
fn checked_load_unknown_tag_lists_available_tags() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("alpha").unwrap()).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("missing").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("no manifest tagged") && msg.contains("\"missing\""),
"expected unknown-tag error mentioning the requested tag, got: {}",
msg
);
assert!(
msg.contains("alpha"),
"expected available-tags listing to include the actual tag, got: {}",
msg
);
}
#[test]
fn manifest_descriptor_carries_ref_name_annotation() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("production-v3").unwrap())
.unwrap();
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let manifest = &index["manifests"][0];
assert_eq!(
manifest["annotations"]["org.opencontainers.image.ref.name"]
.as_str()
.unwrap(),
"production-v3"
);
}
#[test]
fn empty_tag_rejected() {
assert!(OciTag::new("").is_err());
}
#[test]
fn tag_with_illegal_leading_char_rejected() {
assert!(OciTag::new(".dotleader").is_err());
assert!(OciTag::new("-dashleader").is_err());
}
#[test]
fn tag_with_illegal_chars_rejected() {
assert!(OciTag::new("with/slash").is_err());
assert!(OciTag::new("with space").is_err());
}
#[test]
fn long_tag_within_limit_accepted() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let long = OciTag::new("a".repeat(128)).unwrap();
snap.save(dir.path().join("snap"), &long).unwrap();
let _ = Snapshot::checked_load(dir.path().join("snap"), long).unwrap();
}
#[test]
fn over_long_tag_rejected() {
assert!(OciTag::new("a".repeat(129)).is_err());
}
#[test]
fn manifest_descriptor_uses_image_manifest_media_type() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
assert_eq!(
index["manifests"][0]["mediaType"].as_str().unwrap(),
"application/vnd.oci.image.manifest.v1+json"
);
}
#[test]
fn manifest_descriptor_non_image_manifest_rejected() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
rewrite_index(&path, |idx| {
idx["manifests"][0]["mediaType"] = Value::from("application/vnd.oci.image.index.v1+json");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{}", err);
assert!(
msg.contains("unexpected media type"),
"expected manifest-descriptor media type error, got: {}",
msg
);
}
#[test]
fn manifest_missing_artifact_type_rejected() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
rewrite_manifest(&path, |m| {
m.as_object_mut().unwrap().remove("artifactType");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "missing required artifactType");
}
#[test]
fn manifest_mismatched_artifact_type_rejected() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
rewrite_manifest(&path, |m| {
m["artifactType"] = Value::from("application/vnd.example.bogus.v1+json");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "does not match config media type");
}
#[test]
fn save_writes_oci_layout_marker() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let marker: Value =
serde_json::from_slice(&std::fs::read(path.join("oci-layout")).unwrap()).unwrap();
assert_eq!(marker["imageLayoutVersion"].as_str().unwrap(), "1.0.0");
}
#[test]
fn tag_lookup_is_case_sensitive() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("MyTag").unwrap()).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(&path, OciTag::new("mytag").unwrap()));
assert_err_contains(err, "no manifest tagged");
let _ = Snapshot::checked_load(&path, OciTag::new("MyTag").unwrap()).unwrap();
}
#[test]
fn ref_name_annotation_key_is_case_sensitive() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
let anns = idx["manifests"][0]["annotations"].as_object_mut().unwrap();
let value = anns.remove("org.opencontainers.image.ref.name").unwrap();
anns.insert("org.OpenContainers.image.ref.name".to_string(), value);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "no manifest tagged");
}
#[test]
fn tag_with_all_valid_special_chars_accepted() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
let valid = OciTag::new("v1.2.3-rc.1_build").unwrap();
snap.save(&path, &valid).unwrap();
let _ = Snapshot::checked_load(&path, valid).unwrap();
}
#[test]
fn other_descriptor_annotations_do_not_interfere() {
let (_dir, path) = save_for_mutation();
rewrite_index(&path, |idx| {
let anns = idx["manifests"][0]["annotations"].as_object_mut().unwrap();
anns.insert(
"dev.sigstore.cosign/signature".to_string(),
Value::from("MEUCIQDfake"),
);
anns.insert("io.example.build.id".to_string(), Value::from("12345"));
});
let _ = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
}
#[test]
fn bad_config_descriptor_digest_format_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["config"]["digest"] = Value::from("md5:deadbeef");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{err}");
assert!(
msg.contains("digest"),
"expected digest-format error, got: {msg}"
);
}
#[test]
fn bad_snapshot_layer_descriptor_digest_format_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_manifest(&path, |m| {
m["layers"][0]["digest"] = Value::from("sha256:tooshort");
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{err}");
assert!(
msg.contains("digest"),
"expected digest-format error, got: {msg}"
);
}
#[test]
fn missing_config_blob_rejected() {
let (_dir, path) = save_for_mutation();
let cfg_path = find_config_blob(&path);
std::fs::remove_file(&cfg_path).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
let msg = format!("{err}");
assert!(
msg.contains("open") || msg.contains("No such") || msg.contains("not found"),
"expected missing-config-blob error, got: {msg}"
);
}
#[test]
fn manifest_blob_too_large_rejected() {
let (_dir, path) = save_for_mutation();
let mp = manifest_path(&path);
let huge = vec![b'a'; (1024 * 1024 + 16) as usize];
std::fs::write(&mp, &huge).unwrap();
rewrite_index(&path, |idx| {
idx["manifests"][0]["size"] = Value::from(huge.len() as u64);
});
let err = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(err, "exceeds maximum allowed");
}
#[test]
fn config_blob_too_large_rejected() {
let (_dir, path) = save_for_mutation();
let cfg_path = find_config_blob(&path);
let huge = vec![b'a'; (1024 * 1024 + 16) as usize];
std::fs::write(&cfg_path, &huge).unwrap();
rewrite_manifest(&path, |m| {
m["config"]["size"] = Value::from(huge.len() as u64);
});
let err = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(err, "exceeds maximum allowed");
}
#[test]
fn transport_blob_at_size_limit_reaches_decoder() {
let (_dir, path) = save_for_mutation();
let transport_path = find_transport_blob(&path);
let bytes = vec![0; 2 * 1024 * 1024];
std::fs::write(transport_path, &bytes).unwrap();
rewrite_manifest(&path, |manifest| {
let descriptor = manifest["layers"]
.as_array_mut()
.unwrap()
.last_mut()
.unwrap();
descriptor["size"] = Value::from(bytes.len() as u64);
});
let error = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(error, "snapshot transport magic is invalid");
}
#[test]
fn transport_blob_too_large_rejected() {
let (_dir, path) = save_for_mutation();
let transport_path = find_transport_blob(&path);
let bytes = vec![0; 2 * 1024 * 1024 + 1];
std::fs::write(transport_path, &bytes).unwrap();
rewrite_manifest(&path, |manifest| {
let descriptor = manifest["layers"]
.as_array_mut()
.unwrap()
.last_mut()
.unwrap();
descriptor["size"] = Value::from(bytes.len() as u64);
});
let error = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(error, "exceeds maximum allowed 2097152 bytes");
}
#[test]
fn oci_layout_too_large_rejected() {
let (_dir, path) = save_for_mutation();
let huge = vec![b'a'; 1024 * 1024 + 16];
std::fs::write(path.join("oci-layout"), &huge).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "exceeds maximum allowed");
}
#[test]
fn index_json_too_large_rejected() {
let (_dir, path) = save_for_mutation();
let huge = vec![b'a'; 1024 * 1024 + 16];
std::fs::write(path.join("index.json"), &huge).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "exceeds maximum allowed");
}
#[test]
fn index_json_too_large_on_write_rejected() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap.save(&path, &OciTag::new("keep").unwrap()).unwrap();
let index_path = path.join("index.json");
let base = {
let idx: Value = serde_json::from_slice(&std::fs::read(&index_path).unwrap()).unwrap();
idx["manifests"][0].clone()
};
let build = |filler_len: usize| -> Vec<u8> {
let mut d = base.clone();
d["annotations"]["dev.hyperlight.test.filler"] = Value::from("a".repeat(filler_len));
let index = serde_json::json!({
"schemaVersion": 2,
"mediaType": "application/vnd.oci.image.index.v1+json",
"manifests": [d],
});
serde_json::to_vec_pretty(&index).unwrap()
};
let target = 1024 * 1024 - 50;
let filler = target - build(0).len();
let bytes = build(filler);
assert!(
bytes.len() <= 1024 * 1024,
"crafted index must pass the read bound"
);
std::fs::write(&index_path, &bytes).unwrap();
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
assert_err_contains(err, "index.json");
assert_eq!(std::fs::read(&index_path).unwrap(), bytes);
}
#[test]
fn config_blob_too_large_on_write_rejected() {
let guest = simple_guest_as_pathbuf();
let mut builder = SandboxBuilder::from_file(guest);
let long = "h".repeat(300);
for i in 0..3000 {
builder = builder.host_function(format!("{long}{i}"), |a: i32, b: i32| Ok(a + b));
}
let mut sbox = builder.build().unwrap();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
let err = snap
.save(&path, &OciTag::new("latest").unwrap())
.unwrap_err();
assert_err_contains(err, "config blob");
}
#[test]
fn layout_field_too_large_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["layout"]["code_size"] = Value::from(64u64 * 1024 * 1024 * 1024);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "code_size");
}
#[test]
fn stack_top_gva_zero_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["stack_top_gva"] = Value::from(0u64);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "stack_top_gva");
}
#[test]
fn stack_top_gva_out_of_range_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
cfg["stack_top_gva"] = Value::from(u64::MAX);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "stack_top_gva");
}
#[test]
fn stack_top_gva_misaligned_rejected() {
let (_dir, path) = save_for_mutation();
rewrite_config(&path, |cfg| {
let stack_top = cfg["stack_top_gva"].as_u64().unwrap();
cfg["stack_top_gva"] = Value::from(stack_top - 1);
});
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "stack_top_gva");
}
#[test]
#[cfg(unix)]
fn symlink_snapshot_blob_rejected() {
let (_dir, path) = save_for_mutation();
let blob = find_snapshot_blob(&path);
let real = blob.with_extension("real");
std::fs::rename(&blob, &real).unwrap();
std::os::unix::fs::symlink(&real, &blob).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "link");
}
#[test]
#[cfg(unix)]
fn symlink_config_blob_rejected() {
let (_dir, path) = save_for_mutation();
let blob = find_config_blob(&path);
let real = blob.with_extension("real");
std::fs::rename(&blob, &real).unwrap();
std::os::unix::fs::symlink(&real, &blob).unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(
&path,
OciTag::new("latest").unwrap(),
));
assert_err_contains(err, "link");
}
#[test]
#[cfg(unix)]
fn save_replaces_symlink_snapshot_blob_with_regular_file() {
let snapshot = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snap");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let blob = find_snapshot_blob(&path);
let real = blob.with_extension("real");
std::fs::rename(&blob, &real).unwrap();
std::os::unix::fs::symlink(&real, &blob).unwrap();
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let meta = std::fs::symlink_metadata(&blob).unwrap();
assert!(
meta.file_type().is_file() && !meta.file_type().is_symlink(),
"expected the snapshot blob to be a regular file after re-save"
);
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let mut sbox =
Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
let result: String = sbox.call("Echo", "hello\n".to_string()).unwrap();
assert_eq!(result, "hello\n");
}
#[test]
fn snapshot_descriptor_size_disagrees_with_file_rejected() {
let (_dir, path) = save_for_mutation();
let mut blob = std::fs::OpenOptions::new()
.append(true)
.open(find_snapshot_blob(&path))
.unwrap();
std::io::Write::write_all(&mut blob, &[0]).unwrap();
let err = unwrap_err_snapshot(Snapshot::load(&path, OciTag::new("latest").unwrap()));
assert_err_contains(err, "disagrees with OCI descriptor size");
}
#[test]
fn round_trip_preserves_stack_top_gva() {
let snap = create_snapshot();
let original = snap.stack_top_gva();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.stack_top_gva(), original);
}
#[test]
fn round_trip_preserves_non_default_scratch_size() {
use crate::sandbox::SandboxConfiguration;
let custom_scratch = SandboxConfiguration::DEFAULT_SCRATCH_SIZE + 64 * 1024;
let mut sbox = SandboxBuilder::from_file(simple_guest_as_pathbuf())
.scratch_size(custom_scratch)
.build()
.unwrap();
let snap = sbox.snapshot().unwrap();
let original = snap.layout().get_scratch_size();
assert_eq!(original, custom_scratch);
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.layout().get_scratch_size(), custom_scratch);
}
#[test]
fn persisted_non_default_layout_loads_and_runs() {
use crate::sandbox::SandboxConfiguration;
let mut config = SandboxConfiguration::default();
config.set_g2h_pool_pages(16);
config.set_h2g_pool_pages(16);
config.set_scratch_size(0x90_000);
let mut source = UninitializedSandbox::new(
GuestBinary::FilePath(simple_guest_as_pathbuf()),
Some(config),
)
.unwrap()
.evolve()
.unwrap();
source.call::<i32>("AddToStatic", 42i32).unwrap();
let snapshot = source.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap());
assert_eq!(loaded.layout().get_g2h_pool_pages(), 16);
assert_eq!(loaded.layout().get_h2g_pool_pages(), 16);
assert_eq!(loaded.layout().get_scratch_size(), 0x90_000);
let mut restored = Sandbox::from_snapshot(loaded, HostFunctions::default(), None).unwrap();
assert_eq!(restored.call::<i32>("GetStatic", ()).unwrap(), 42);
let large = "x".repeat(0x5000);
assert_eq!(
restored.call::<String>("Echo", large.clone()).unwrap(),
large
);
assert_eq!(
restored.call::<i32>("CallMalloc", 0x10_000i32).unwrap(),
0x10_000
);
}
#[test]
fn round_trip_preserves_transport_layout() {
let mut sbox = SandboxBuilder::from_file(simple_guest_as_pathbuf())
.scratch_size(512 * 1024)
.g2h_queue_size(128)
.h2g_queue_size(16)
.g2h_buffer_size(8192)
.h2g_buffer_size(2048)
.g2h_pool_pages(16)
.h2g_pool_pages(6)
.build()
.unwrap();
let payload = "x".repeat(20 * 1024);
assert_eq!(
sbox.call::<String>("Echo", payload.clone()).unwrap(),
payload
);
let snapshot = sbox.snapshot().unwrap();
let expected = snapshot.layout().get_transport_arena();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.layout().get_g2h_queue_size(), 128);
assert_eq!(loaded.layout().get_h2g_queue_size(), 16);
assert_eq!(loaded.layout().get_g2h_buffer_size(), 8192);
assert_eq!(loaded.layout().get_h2g_buffer_size(), 2048);
assert_eq!(loaded.layout().get_g2h_pool_pages(), 16);
assert_eq!(loaded.layout().get_h2g_pool_pages(), 6);
assert_eq!(loaded.layout().get_transport_arena(), expected);
}
#[test]
fn snapshot_config_records_entrypoint_and_sregs() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let cfg: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
assert!(
cfg["entrypoint_addr"].is_u64(),
"config must carry entrypoint_addr"
);
assert!(cfg["sregs"].is_object(), "config must carry sregs");
}
#[test]
fn round_trip_preserves_host_function_signatures() {
let mut sbox = create_sandbox_with_custom_host_funcs();
let snap = sbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let cfg: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
let funcs = cfg["host_functions"].as_array().unwrap();
let add = funcs
.iter()
.find(|f| f["function_name"].as_str().unwrap() == "Add")
.expect("Add must be recorded");
assert_eq!(
add["parameter_types"].as_array().unwrap().len(),
2,
"Add signature must record two parameters"
);
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
let _ = Sandbox::from_snapshot(Arc::new(loaded), host_funcs_with_matching_add(), None).unwrap();
}
#[test]
fn snapshot_with_no_host_functions_round_trips() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
rewrite_config(&path, |cfg| {
cfg["host_functions"] = Value::Array(Vec::new());
});
let cfg: Value =
serde_json::from_slice(&std::fs::read(find_config_blob(&path)).unwrap()).unwrap();
assert!(cfg["host_functions"].as_array().unwrap().is_empty());
let loaded = Snapshot::load(&path, OciTag::new("latest").unwrap()).unwrap();
let _ = Sandbox::from_snapshot(Arc::new(loaded), HostFunctions::default(), None).unwrap();
}
#[test]
fn linear_chain_restore_in_order() {
let mut sbox = create_test_sandbox();
let s0 = sbox.snapshot().unwrap();
sbox.call::<i32>("AddToStatic", 10i32).unwrap();
let s10 = sbox.snapshot().unwrap();
sbox.call::<i32>("AddToStatic", 20i32).unwrap();
let s30 = sbox.snapshot().unwrap();
sbox.restore(s0.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 0);
sbox.restore(s10.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 10);
sbox.restore(s30.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 30);
}
#[test]
fn restore_idempotent() {
let mut sbox = create_test_sandbox();
sbox.call::<i32>("AddToStatic", 11i32).unwrap();
let s = sbox.snapshot().unwrap();
sbox.call::<i32>("AddToStatic", 22i32).unwrap();
sbox.restore(s.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 11);
sbox.restore(s.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 11);
sbox.call::<i32>("AddToStatic", 1i32).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 12);
}
#[test]
fn separate_oci_loads_are_mutually_restore_compatible() {
let mut seed = create_test_sandbox();
let snap = seed.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("v1").unwrap()).unwrap();
let s_x = Arc::new(Snapshot::checked_load(&path, OciTag::new("v1").unwrap()).unwrap());
let s_y = Arc::new(Snapshot::checked_load(&path, OciTag::new("v1").unwrap()).unwrap());
let mut sbox_x = Sandbox::from_snapshot(s_x.clone(), HostFunctions::default(), None).unwrap();
sbox_x.restore(s_y.clone()).unwrap();
assert_eq!(sbox_x.call::<i32>("GetStatic", ()).unwrap(), 0);
sbox_x.restore(s_x.clone()).unwrap();
assert_eq!(sbox_x.call::<i32>("GetStatic", ()).unwrap(), 0);
}
#[test]
fn oci_loaded_snapshot_supports_full_lifecycle() {
let mut seed = create_test_sandbox();
let snap = seed.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("v1").unwrap()).unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("v1").unwrap()).unwrap());
let mut sbox = Sandbox::from_snapshot(loaded.clone(), HostFunctions::default(), None).unwrap();
sbox.call::<i32>("AddToStatic", 1i32).unwrap();
let s1 = sbox.snapshot().unwrap();
sbox.call::<i32>("AddToStatic", 2i32).unwrap();
let s3 = sbox.snapshot().unwrap();
sbox.call::<i32>("AddToStatic", 4i32).unwrap();
sbox.restore(s1.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 1);
sbox.restore(s3.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 3);
sbox.restore(loaded.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 0);
let s_post = sbox.snapshot().unwrap();
sbox.call::<i32>("AddToStatic", 50i32).unwrap();
sbox.restore(s_post.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 0);
sbox.restore(s3.clone()).unwrap();
assert_eq!(sbox.call::<i32>("GetStatic", ()).unwrap(), 3);
}
#[test]
fn save_returns_manifest_digest_that_loads() {
let mut sbox = create_test_sandbox();
sbox.call::<String>("Echo", "x".to_string()).unwrap();
let snap = sbox.snapshot().unwrap();
let expected_gen = snap.snapshot_generation();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
let digest = snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, digest).unwrap();
assert_eq!(loaded.snapshot_generation(), expected_gen);
}
#[test]
fn round_trip_preserves_code_gva() {
let snap = create_snapshot();
let original = snap.layout().get_guest_code_gva();
assert_ne!(original, 0, "fixture must have a non-zero code GVA");
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let loaded = Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.layout().get_guest_code_gva(), original);
}
#[test]
fn save_returns_digest_matching_index_manifest_descriptor() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
let digest = snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let index: Value =
serde_json::from_slice(&std::fs::read(path.join("index.json")).unwrap()).unwrap();
let descriptor_digest = index["manifests"][0]["digest"].as_str().unwrap();
assert_eq!(digest.as_str(), descriptor_digest);
let manifest_hex = descriptor_digest.strip_prefix("sha256:").unwrap();
let manifest_bytes =
std::fs::read(path.join("blobs").join("sha256").join(manifest_hex)).unwrap();
assert_eq!(
digest.as_str(),
format!("sha256:{}", sha256_hex(&manifest_bytes))
);
}
#[test]
fn checked_load_by_digest_selects_correct_manifest_among_tags() {
let mut sbox = create_test_sandbox();
sbox.call::<String>("Echo", "a".to_string()).unwrap();
let snap_a = sbox.snapshot().unwrap();
let gen_a = snap_a.snapshot_generation();
sbox.call::<String>("Echo", "b".to_string()).unwrap();
let snap_b = sbox.snapshot().unwrap();
let gen_b = snap_b.snapshot_generation();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
let digest_a = snap_a.save(&path, &OciTag::new("a").unwrap()).unwrap();
let digest_b = snap_b.save(&path, &OciTag::new("b").unwrap()).unwrap();
assert_ne!(digest_a.as_str(), digest_b.as_str());
let loaded_a = Snapshot::checked_load(&path, digest_a).unwrap();
let loaded_b = Snapshot::checked_load(&path, digest_b).unwrap();
assert_eq!(loaded_a.snapshot_generation(), gen_a);
assert_eq!(loaded_b.snapshot_generation(), gen_b);
}
#[test]
fn checked_load_accepts_reference_value() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("v1").unwrap()).unwrap();
let reference: OciReference = "v1".parse().unwrap();
let _ = Snapshot::checked_load(&path, reference).unwrap();
}
#[test]
fn unknown_digest_reports_missing_manifest() {
let snap = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("layout");
snap.save(&path, &OciTag::new("latest").unwrap()).unwrap();
let absent: OciDigest = format!("sha256:{}", "0".repeat(64)).parse().unwrap();
let err = unwrap_err_snapshot(Snapshot::checked_load(&path, absent));
assert_err_contains(err, "no manifest with digest");
}
#[test]
fn oci_digest_parsing_accepts_canonical_sha256() {
let canonical = format!("sha256:{}", "a".repeat(64));
let digest: OciDigest = canonical.parse().unwrap();
assert_eq!(digest.as_str(), canonical);
}
#[test]
fn oci_digest_parsing_rejects_malformed_values() {
assert!("a".repeat(64).parse::<OciDigest>().is_err());
assert!(
format!("sha256:{}", "A".repeat(64))
.parse::<OciDigest>()
.is_err()
);
assert!("sha256:deadbeef".parse::<OciDigest>().is_err());
assert!(
format!("sha512:{}", "a".repeat(128))
.parse::<OciDigest>()
.is_err()
);
}
#[test]
fn oci_reference_parsing_disambiguates_on_colon() {
let tag_ref: OciReference = "latest".parse().unwrap();
assert!(matches!(tag_ref, OciReference::Tag(_)));
let digest_ref: OciReference = format!("sha256:{}", "a".repeat(64)).parse().unwrap();
assert!(matches!(digest_ref, OciReference::Digest(_)));
}
#[test]
fn save_new_tag_into_loaded_layout_preserves_live_mapping() {
let snap_a = create_snapshot();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("store");
snap_a.save(&path, &OciTag::new("a").unwrap()).unwrap();
let loaded_a = Arc::new(Snapshot::checked_load(&path, OciTag::new("a").unwrap()).unwrap());
let mapping_before = loaded_a.state.memory.layers()[0]
.memory()
.as_slice()
.to_vec();
let blobs_dir = path.join("blobs").join("sha256");
let blobs_before = read_blob_dir(&blobs_dir);
let mut other = create_test_sandbox();
other.call::<i32>("AddToStatic", 42i32).unwrap();
let snap_b = other.snapshot().unwrap();
snap_b.save(&path, &OciTag::new("b").unwrap()).unwrap();
assert_eq!(
loaded_a.state.memory.layers()[0].memory().as_slice(),
mapping_before.as_slice(),
"live snapshot mapping changed after a new tag was written"
);
let blobs_after = read_blob_dir(&blobs_dir);
for (name, bytes) in &blobs_before {
assert_eq!(
blobs_after.get(name),
Some(bytes),
"existing blob {name:?} was modified by the second save"
);
}
let mut live =
Sandbox::from_snapshot(loaded_a.clone(), HostFunctions::default(), None).unwrap();
live.call::<i32>("AddToStatic", 7i32).unwrap();
assert_eq!(live.call::<i32>("GetStatic", ()).unwrap(), 7);
live.restore(loaded_a).unwrap();
assert_eq!(live.call::<i32>("GetStatic", ()).unwrap(), 0);
let _ = Snapshot::checked_load(&path, OciTag::new("a").unwrap()).unwrap();
let _ = Snapshot::checked_load(&path, OciTag::new("b").unwrap()).unwrap();
}
fn read_blob_dir(
blobs_dir: &std::path::Path,
) -> std::collections::BTreeMap<std::ffi::OsString, Vec<u8>> {
std::fs::read_dir(blobs_dir)
.unwrap()
.map(|e| {
let e = e.unwrap();
(e.file_name(), std::fs::read(e.path()).unwrap())
})
.collect()
}
#[test]
fn from_snapshot_silently_ignores_layout_overrides() {
let mut sbox = create_test_sandbox();
let snapshot = sbox.snapshot().unwrap();
let original = snapshot.layout();
let mut sbox2 = SandboxBuilder::from_snapshot(snapshot.clone())
.scratch_size(original.get_scratch_size() * 2)
.g2h_queue_size(128)
.h2g_queue_size(16)
.g2h_buffer_size(8192)
.h2g_buffer_size(2048)
.g2h_pool_pages(16)
.h2g_pool_pages(6)
.build()
.unwrap();
sbox2.call::<i32>("GetStatic", ()).unwrap();
let new_snap = sbox2.snapshot().unwrap();
let restored = new_snap.layout();
assert_eq!(restored.get_scratch_size(), original.get_scratch_size());
assert_eq!(restored.get_g2h_queue_size(), original.get_g2h_queue_size());
assert_eq!(restored.get_h2g_queue_size(), original.get_h2g_queue_size());
assert_eq!(
restored.get_g2h_buffer_size(),
original.get_g2h_buffer_size()
);
assert_eq!(
restored.get_h2g_buffer_size(),
original.get_h2g_buffer_size()
);
assert_eq!(restored.get_g2h_pool_pages(), original.get_g2h_pool_pages());
assert_eq!(restored.get_h2g_pool_pages(), original.get_h2g_pool_pages());
}
#[test]
fn random_guest_libc_rng_reseeds_from_snapshot() {
let mut sandbox = create_c_test_sandbox();
let snapshot = sandbox.snapshot().unwrap();
let mut first =
Sandbox::from_snapshot(snapshot.clone(), HostFunctions::default(), None).unwrap();
let mut second = Sandbox::from_snapshot(snapshot, HostFunctions::default(), None).unwrap();
assert_ne!(random_sequence(&mut first), random_sequence(&mut second));
}
#[test]
fn guest_libc_rng_random_reseeds_from_snapshot() {
let mut sandbox = create_c_test_sandbox();
let snapshot = sandbox.snapshot().unwrap();
let mut first =
Sandbox::from_snapshot(snapshot.clone(), HostFunctions::default(), None).unwrap();
let mut second = Sandbox::from_snapshot(snapshot, HostFunctions::default(), None).unwrap();
assert_ne!(
random_long_sequence(&mut first),
random_long_sequence(&mut second)
);
}
#[test]
fn fresh_random_guest_libc_rng_sequences_differ() {
let mut first = create_c_test_sandbox();
let mut second = create_c_test_sandbox();
assert_ne!(random_sequence(&mut first), random_sequence(&mut second));
}
#[test]
fn libc_rng_reseed_request_encodes_all_u32_seeds() {
let mut sandbox = create_c_test_sandbox();
for seed in [0, u32::MAX] {
sandbox.mem_mgr.request_libc_rng_reseed(seed).unwrap();
assert_eq!(
libc_rng_reseed_request(&sandbox),
(1_u64 << 32) | u64::from(seed)
);
}
}
#[test]
fn guest_consumes_libc_rng_reseed_request_once() {
let mut sandbox = create_c_test_sandbox();
let snapshot = sandbox.snapshot().unwrap();
sandbox.restore(snapshot).unwrap();
assert_ne!(libc_rng_reseed_request(&sandbox), 0);
sandbox.call::<i32>("NextRandom", ()).unwrap();
assert_eq!(libc_rng_reseed_request(&sandbox), 0);
sandbox.call::<i32>("NextRandom", ()).unwrap();
assert_eq!(libc_rng_reseed_request(&sandbox), 0);
}
#[test]
fn guest_libc_rng_reseeds_on_every_restore() {
let mut sandbox = create_c_test_sandbox();
let snapshot = sandbox.snapshot().unwrap();
sandbox.restore(snapshot.clone()).unwrap();
let first = random_sequence(&mut sandbox);
sandbox.restore(snapshot).unwrap();
let second = random_sequence(&mut sandbox);
assert_ne!(first, second);
}
#[test]
fn persisted_guest_libc_rng_snapshot_reseeds_each_instance() {
let mut sandbox = create_c_test_sandbox();
let snapshot = sandbox.snapshot().unwrap();
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("snapshot");
snapshot
.save(&path, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Arc::new(Snapshot::checked_load(&path, OciTag::new("latest").unwrap()).unwrap());
let mut first = Sandbox::from_snapshot(loaded.clone(), HostFunctions::default(), None).unwrap();
let mut second = Sandbox::from_snapshot(loaded, HostFunctions::default(), None).unwrap();
assert_ne!(random_sequence(&mut first), random_sequence(&mut second));
}
#[test]
#[cfg(crashdump)]
fn from_snapshot_honors_guest_core_dump_enabled() {
let mut sbox = create_test_sandbox();
let snapshot = sbox.snapshot().unwrap();
let mut sbox2 = SandboxBuilder::from_snapshot(snapshot)
.guest_core_dump(true)
.build()
.unwrap();
let dir = tempfile::tempdir().unwrap();
sbox2.generate_crashdump_to_dir(dir.path()).unwrap();
let entries: Vec<_> = std::fs::read_dir(dir.path())
.unwrap()
.filter_map(Result::ok)
.collect();
assert!(
!entries.is_empty(),
"expected core dump file when guest_core_dump=true"
);
}
#[test]
#[cfg(crashdump)]
fn from_snapshot_honors_guest_core_dump_disabled() {
let mut sbox = create_test_sandbox();
let snapshot = sbox.snapshot().unwrap();
let mut sbox2 = SandboxBuilder::from_snapshot(snapshot)
.guest_core_dump(false)
.build()
.unwrap();
let dir = tempfile::tempdir().unwrap();
sbox2.generate_crashdump_to_dir(dir.path()).unwrap();
let entries: Vec<_> = std::fs::read_dir(dir.path())
.unwrap()
.filter_map(Result::ok)
.collect();
assert!(
entries.is_empty(),
"expected no core dump file when guest_core_dump=false, found {:?}",
entries.iter().map(|e| e.path()).collect::<Vec<_>>()
);
}
#[test]
fn round_trip_preserves_non_default_init_data_permissions() {
use crate::mem::memory_region::MemoryRegionFlags;
let path = simple_guest_as_pathbuf();
let data: &[u8] = b"perm-pinned-init-data";
let mut sbox = SandboxBuilder::from_file(path)
.init_data(data, MemoryRegionFlags::READ | MemoryRegionFlags::WRITE)
.build()
.unwrap();
let snap = sbox.snapshot().unwrap();
let expected = snap.layout().init_data_permissions();
assert_eq!(
expected,
Some(MemoryRegionFlags::READ | MemoryRegionFlags::WRITE),
"fixture must produce non-default init_data_permissions",
);
let dir = tempfile::tempdir().unwrap();
let oci_dir = dir.path().join("layout");
snap.save(&oci_dir, &OciTag::new("latest").unwrap())
.unwrap();
let loaded = Snapshot::checked_load(&oci_dir, OciTag::new("latest").unwrap()).unwrap();
assert_eq!(loaded.layout().init_data_permissions(), expected);
}