fix: preserve bundle commits and expose SVG resource refusals

This commit is contained in:
Terra854 committed 2026-11-14 17:53:32 +08:00
1 parent f0f4758c01
commit d61afc4a3b
4 files changed
+420 -21

No files matched your search

+37 -20
View File
@@ -370,7 +370,8 @@ impl DirectoryBundleWriter {
/// Saves an entry set incrementally. Existing objects are reused only after a hash check;
/// unchanged file signatures may skip checks until they enter the rolling verification
/// window. The manifest is atomically published last, then stale previews and objects are
/// collected while the bundle lock is held.
/// collected while the bundle lock is held. Collection is best-effort after publication:
/// inaccessible or unsafe leftovers cannot turn a committed save into a reported failure.
pub fn save_directory(&mut self, root: &Path, bundle: ZipBundleWriter) -> Result<DirectoryStats> {
if !bundle.entries.contains_key(craft_pcraft_format::MANIFEST) {
return Err(Error::InvalidBundle("manifest not set".into()));
@@ -454,38 +455,29 @@ impl DirectoryBundleWriter {
craft_atomic::atomic_write(&manifest_path, manifest).map_err(io_error)?;
stats.written = stats.written.saturating_add(1);
let mut removed_paths = Vec::new();
// The durable manifest is the commit boundary. Cleanup owns only canonical regular
// object files and previews; leave unsafe, inaccessible or locked leftovers for later.
for kind in [craft_pcraft_format::TILES_DIR, craft_pcraft_format::BLOBS_DIR] {
let dir = root.join(kind);
if !dir.exists() {
if !cleanup_directory(&dir) {
continue;
}
refuse_symlink(&dir)?;
for entry in fs::read_dir(&dir).map_err(io_error)? {
let entry = entry.map_err(io_error)?;
let Ok(entries) = fs::read_dir(&dir) else { continue };
for entry in entries {
let Ok(entry) = entry else { continue };
let name = entry.file_name();
let path = format!("{kind}/{}", name.to_string_lossy());
if is_object_path(&path) && !bundle.entries.contains_key(&path) {
let metadata = fs::symlink_metadata(entry.path()).map_err(io_error)?;
if metadata.file_type().is_symlink() || !metadata.is_file() {
return Err(Error::InvalidBundle(format!("refusing to collect non-file object {path}")));
}
fs::remove_file(entry.path()).map_err(io_error)?;
removed_paths.push(path);
if is_object_path(&path) && !bundle.entries.contains_key(&path) && remove_cleanup_file(&entry.path()) {
stats.removed = stats.removed.saturating_add(1);
}
}
}
for path in [craft_pcraft_format::THUMB, craft_pcraft_format::COMPOSITE, craft_pcraft_format::FULL_COMPOSITE] {
if !bundle.entries.contains_key(path) {
let target = root.join(path);
refuse_symlink(&target)?;
if fs::symlink_metadata(&target).is_ok() {
fs::remove_file(&target).map_err(io_error)?;
}
let _ = remove_cleanup_file(&root.join(path));
}
}
self.verified.retain(|path, _| bundle.entries.contains_key(path) && !removed_paths.contains(path));
self.verified.retain(|path, _| bundle.entries.contains_key(path));
Ok(stats)
}
@@ -510,7 +502,32 @@ impl DirectoryBundleWriter {
}
fn is_object_path(path: &str) -> bool {
path.starts_with("tiles/") || path.starts_with("blobs/")
valid_object_path(path)
}
/// Do not traverse symlinked object/preview directories, including Windows junctions.
fn cleanup_directory(path: &Path) -> bool {
fs::symlink_metadata(path).is_ok_and(|metadata| metadata.is_dir() && !cleanup_link(&metadata))
}
fn cleanup_link(metadata: &fs::Metadata) -> bool {
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
metadata.file_attributes() & 0x400 != 0 // FILE_ATTRIBUTE_REPARSE_POINT includes junctions.
}
#[cfg(not(windows))]
{
metadata.file_type().is_symlink()
}
}
/// Cleanup never follows or removes a directory/link and never reports a post-commit failure.
fn remove_cleanup_file(path: &Path) -> bool {
if path.parent().is_none_or(|parent| !cleanup_directory(parent)) {
return false;
}
fs::symlink_metadata(path).is_ok_and(|metadata| metadata.is_file() && !cleanup_link(&metadata)) && fs::remove_file(path).is_ok()
}
fn file_signature(path: &Path) -> Result<Option<FileSignature>> {
@@ -0,0 +1,269 @@
//! Publication succeeds independently of best-effort cleanup of the previous entry set.
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use craft_pcraft_bundle::{DirectoryBundle, DirectoryBundleWriter, Limits, ObjectKind, ZipBundleWriter};
use craft_pcraft_format::{COMPOSITE, FULL_COMPOSITE, MANIFEST, THUMB};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
const OLD: &[u8] = br#"{"revision":1}"#;
const NEW: &[u8] = br#"{"revision":2}"#;
struct Temporary(PathBuf);
impl Temporary {
fn new() -> Self {
static NEXT: AtomicU64 = AtomicU64::new(0);
let path = std::env::temp_dir().join(format!("craft-bundle-cleanup-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
fs::create_dir(&path).unwrap();
Self(path)
}
fn bundle(&self) -> PathBuf {
self.0.join("document.pcraft")
}
}
impl Drop for Temporary {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
fn entries(manifest: &[u8]) -> ZipBundleWriter {
let mut bundle = ZipBundleWriter::default();
bundle.set_manifest(manifest.to_vec()).unwrap();
bundle
}
fn assert_manifest(root: &Path, expected: &[u8]) {
assert_eq!(fs::read(root.join(MANIFEST)).unwrap(), expected);
assert_eq!(DirectoryBundle::open(root, Limits::default()).unwrap().manifest().unwrap(), expected);
}
#[test]
fn non_file_stale_object_does_not_fail_the_committed_save() {
let temp = Temporary::new();
let root = temp.bundle();
let mut writer = DirectoryBundleWriter::default();
writer.save_directory(&root, entries(OLD)).unwrap();
let stuck = root.join("tiles").join(format!("{}.zst", "0".repeat(64)));
fs::create_dir_all(stuck.join("inner")).unwrap();
fs::write(stuck.join("inner/keep"), b"not an object file").unwrap();
let stats = writer.save_directory(&root, entries(NEW)).expect("cleanup cannot fail after manifest publication");
assert_manifest(&root, NEW);
assert_eq!(stats.removed, 0);
assert_eq!(fs::read(stuck.join("inner/keep")).unwrap(), b"not an object file");
}
#[test]
fn cleanup_removes_only_canonical_stale_regular_objects_and_reuses_current_objects() {
let temp = Temporary::new();
let root = temp.bundle();
let mut writer = DirectoryBundleWriter::default();
let mut first = entries(OLD);
let retained = first.add_object(ObjectKind::Tile, b"still referenced").unwrap();
let stale = first.add_object(ObjectKind::Blob, b"old blob").unwrap();
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
first.set_preview(preview, b"old preview".to_vec()).unwrap();
}
writer.save_directory(&root, first).unwrap();
let retained_bytes = fs::read(root.join(&retained)).unwrap();
let unrelated = [
"tiles/personal-notes.zst".to_string(),
"blobs/012345.zst".to_string(),
format!("blobs/{}.zst", "A".repeat(64)),
format!("tiles/{}.zst.backup", "b".repeat(64)),
];
for path in &unrelated {
fs::write(root.join(path), b"unrelated").unwrap();
}
let nested = root.join("blobs/not-an-object-folder");
fs::create_dir(&nested).unwrap();
fs::write(nested.join(format!("{}.zst", "c".repeat(64))), b"unrelated nested file").unwrap();
let mut second = entries(NEW);
assert_eq!(second.add_object(ObjectKind::Tile, b"still referenced").unwrap(), retained);
let stats = writer.save_directory(&root, second).unwrap();
assert_manifest(&root, NEW);
assert_eq!(stats.removed, 1);
assert_eq!(stats.reused, 1);
assert_eq!(stats.reused_objects.as_slice(), std::slice::from_ref(&retained));
assert!(stats.written_objects.is_empty());
assert!(!root.join(stale).exists());
assert_eq!(fs::read(root.join(retained)).unwrap(), retained_bytes);
for path in unrelated {
assert_eq!(fs::read(root.join(path)).unwrap(), b"unrelated");
}
assert!(nested.is_dir());
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
assert!(!root.join(preview).exists());
}
}
#[test]
fn stale_preview_directories_are_preserved_after_commit() {
let temp = Temporary::new();
let root = temp.bundle();
let mut writer = DirectoryBundleWriter::default();
writer.save_directory(&root, entries(OLD)).unwrap();
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
fs::create_dir_all(root.join(preview)).unwrap();
fs::write(root.join(preview).join("keep"), b"directory contents").unwrap();
}
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
assert_manifest(&root, NEW);
assert_eq!(stats.removed, 0);
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
assert_eq!(fs::read(root.join(preview).join("keep")).unwrap(), b"directory contents");
}
}
#[test]
fn required_non_file_objects_and_previews_fail_before_manifest_publication() {
let temp = Temporary::new();
let root = temp.bundle();
let mut writer = DirectoryBundleWriter::default();
writer.save_directory(&root, entries(OLD)).unwrap();
let mut changed = entries(NEW);
let object = changed.add_object(ObjectKind::Tile, b"required object").unwrap();
fs::create_dir_all(root.join(&object)).unwrap();
assert!(writer.save_directory(&root, changed).is_err());
assert_manifest(&root, OLD);
for preview in [THUMB, COMPOSITE] {
fs::create_dir_all(root.join(preview)).unwrap();
let mut changed = entries(NEW);
changed.set_preview(preview, b"required preview".to_vec()).unwrap();
assert!(writer.save_directory(&root, changed).is_err());
assert_manifest(&root, OLD);
}
}
#[cfg(windows)]
#[test]
fn locked_stale_object_and_preview_do_not_fail_commit_and_are_collected_on_retry() {
use std::fs::OpenOptions;
use std::os::windows::fs::OpenOptionsExt;
let temp = Temporary::new();
let root = temp.bundle();
let mut writer = DirectoryBundleWriter::default();
let mut first = entries(OLD);
let stale = first.add_object(ObjectKind::Tile, b"locked stale tile").unwrap();
first.set_preview(FULL_COMPOSITE, b"locked preview".to_vec()).unwrap();
writer.save_directory(&root, first).unwrap();
let tile_lock = OpenOptions::new().read(true).share_mode(0).open(root.join(&stale)).unwrap();
let preview_lock = OpenOptions::new().read(true).share_mode(0).open(root.join(FULL_COMPOSITE)).unwrap();
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
assert_manifest(&root, NEW);
assert_eq!(stats.removed, 0);
assert!(root.join(&stale).exists());
assert!(root.join(FULL_COMPOSITE).exists());
drop(tile_lock);
drop(preview_lock);
let retry = writer.save_directory(&root, entries(NEW)).unwrap();
assert_manifest(&root, NEW);
assert_eq!(retry.removed, 1);
assert!(!root.join(stale).exists());
assert!(!root.join(FULL_COMPOSITE).exists());
}
#[cfg(unix)]
#[test]
fn cleanup_preserves_symlinks_and_does_not_traverse_linked_directories() {
use std::os::unix::fs::symlink;
let temp = Temporary::new();
let root = temp.bundle();
let outside = temp.0.join("outside");
fs::create_dir(&outside).unwrap();
let object_name = format!("{}.zst", "d".repeat(64));
fs::write(outside.join(&object_name), b"outside object").unwrap();
fs::write(outside.join("preview.png"), b"outside preview").unwrap();
let mut writer = DirectoryBundleWriter::default();
writer.save_directory(&root, entries(OLD)).unwrap();
symlink(&outside, root.join("blobs")).unwrap();
symlink(&outside, root.join("composite")).unwrap();
symlink(outside.join("preview.png"), root.join(THUMB)).unwrap();
fs::create_dir(root.join("tiles")).unwrap();
let linked_object = root.join("tiles").join(&object_name);
symlink(outside.join(&object_name), &linked_object).unwrap();
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
assert_manifest(&root, NEW);
assert_eq!(stats.removed, 0);
assert_eq!(fs::read(outside.join(object_name)).unwrap(), b"outside object");
assert_eq!(fs::read(outside.join("preview.png")).unwrap(), b"outside preview");
for link in [root.join("blobs"), root.join("composite"), root.join(THUMB), linked_object] {
assert!(fs::symlink_metadata(link).unwrap().file_type().is_symlink());
}
}
#[cfg(unix)]
#[test]
fn required_symlink_objects_and_previews_still_fail_before_commit() {
use std::os::unix::fs::symlink;
let temp = Temporary::new();
let root = temp.bundle();
let outside = temp.0.join("outside-file");
fs::write(&outside, b"unchanged outside bytes").unwrap();
let mut writer = DirectoryBundleWriter::default();
writer.save_directory(&root, entries(OLD)).unwrap();
let mut changed = entries(NEW);
let object = changed.add_object(ObjectKind::Tile, b"required object").unwrap();
fs::create_dir(root.join("tiles")).unwrap();
symlink(&outside, root.join(object)).unwrap();
assert!(writer.save_directory(&root, changed).is_err());
assert_manifest(&root, OLD);
symlink(&outside, root.join(THUMB)).unwrap();
let mut changed = entries(NEW);
changed.set_preview(THUMB, b"new preview".to_vec()).unwrap();
assert!(writer.save_directory(&root, changed).is_err());
assert_manifest(&root, OLD);
assert_eq!(fs::read(outside).unwrap(), b"unchanged outside bytes");
}
#[cfg(windows)]
#[test]
fn cleanup_does_not_traverse_windows_directory_junctions() {
use std::os::windows::process::CommandExt;
struct Junction(PathBuf);
impl Drop for Junction {
fn drop(&mut self) {
let _ = fs::remove_dir(&self.0);
}
}
fn junction(link: PathBuf, target: &Path) -> Junction {
// Fixture-owned absolute paths only; junctions require no symlink privilege.
assert!(link.is_absolute() && target.is_absolute());
let output = std::process::Command::new("cmd")
.args(["/C", "mklink", "/J"])
.arg(&link)
.arg(target)
.creation_flags(0x0800_0000) // CREATE_NO_WINDOW
.output()
.unwrap();
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
Junction(link)
}
let temp = Temporary::new();
let root = temp.bundle();
let outside = temp.0.join("outside");
fs::create_dir(&outside).unwrap();
let object_name = format!("{}.zst", "e".repeat(64));
fs::write(outside.join(&object_name), b"outside object").unwrap();
fs::write(outside.join("preview.png"), b"outside preview").unwrap();
fs::write(outside.join("full.png"), b"outside full preview").unwrap();
let mut writer = DirectoryBundleWriter::default();
writer.save_directory(&root, entries(OLD)).unwrap();
let _objects = junction(root.join("blobs"), &outside);
let _previews = junction(root.join("composite"), &outside);
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
assert_manifest(&root, NEW);
assert_eq!(stats.removed, 0);
assert_eq!(fs::read(outside.join(object_name)).unwrap(), b"outside object");
assert_eq!(fs::read(outside.join("preview.png")).unwrap(), b"outside preview");
assert_eq!(fs::read(outside.join("full.png")).unwrap(), b"outside full preview");
assert!(root.join("blobs").exists());
assert!(root.join("composite").exists());
}
+12 -1
View File
@@ -302,6 +302,7 @@ struct Used {
raster_limit: AtomicUsize,
invalid_svg: AtomicUsize,
svg_limit: AtomicUsize,
svg_resource_limit: AtomicUsize,
}
/// What resolving one drawing's embedded images used or refused.
@@ -323,6 +324,10 @@ pub struct ImageUsage {
pub invalid_svg_images: usize,
/// Embedded SVG data refused by byte or nesting limits.
pub svg_limit_images: usize,
/// Subset of `svg_limit_images` refused by unpacked byte or embedded-document-chain limits.
/// XML/tree-depth omissions and invalid or corrupt data do not set this counter. Consumers
/// can reject resource overruns while still allowing an optional, over-deep child to be omitted.
pub svg_resource_limit_images: usize,
}
/// A data-URL resolver and the accounting for the one drawing it serves.
@@ -350,6 +355,7 @@ impl ImageResolver {
raster_limit: AtomicUsize::new(0),
invalid_svg: AtomicUsize::new(0),
svg_limit: AtomicUsize::new(0),
svg_resource_limit: AtomicUsize::new(0),
}),
}
}
@@ -376,6 +382,7 @@ impl ImageResolver {
raster_limit_images: self.used.raster_limit.load(Ordering::Relaxed),
invalid_svg_images: self.used.invalid_svg.load(Ordering::Relaxed),
svg_limit_images: self.used.svg_limit.load(Ordering::Relaxed),
svg_resource_limit_images: self.used.svg_resource_limit.load(Ordering::Relaxed),
}
}
}
@@ -438,6 +445,7 @@ fn raster_image(used: &Used, limits: &Limits, data: Arc<Vec<u8>>, format: craft_
fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<'_>) -> Option<usvg::ImageKind> {
if used.depth.load(Ordering::Relaxed) >= limits.embedded_depth {
used.svg_limit.fetch_add(1, Ordering::Relaxed);
used.svg_resource_limit.fetch_add(1, Ordering::Relaxed);
return None;
}
let left = limits.embedded_bytes.saturating_sub(used.bytes.load(Ordering::Relaxed));
@@ -445,9 +453,12 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<'
Ok(text) => text,
// What a refused document unpacked before it was refused was work too: it uses up what
// is left, so the next image can't repeat it.
Err(_) => {
Err(error) => {
used.bytes.fetch_add(left, Ordering::Relaxed);
used.svg_limit.fetch_add(1, Ordering::Relaxed);
if matches!(error, svgz::Error::TooLarge(_)) {
used.svg_resource_limit.fetch_add(1, Ordering::Relaxed);
}
return None;
}
};
+102
View File
@@ -245,6 +245,108 @@ fn embedded_svgs_are_read_within_their_budgets() {
assert_eq!(found(&svg(r#"<image width="5" height="5" xlink:href="/etc/passwd.svg"/>"#), shallow()), [false; 0]);
}
mod resource_limit_usage {
use super::*;
fn data_image(bytes: &[u8]) -> String {
let encoded: String = bytes.iter().map(|byte| format!("%{byte:02X}")).collect();
format!(r#"<image width="5" height="5" xlink:href="data:image/svg+xml,{encoded}"/>"#)
}
fn packed(text: &str, gzip: bool) -> Vec<u8> {
if gzip { svgz::compress(text.as_bytes()) } else { text.as_bytes().to_vec() }
}
/// The outer document has its own generous text allowance, so tiny resolver limits
/// test the public embedded admission contract rather than rejecting the outer XML.
fn resolved(text: &str, limits: Limits, outer_depth: usize) -> (Vec<bool>, ImageUsage) {
let resolver = ImageResolver::new(limits);
resolver.set_document_depth(outer_depth);
let options = usvg::Options { image_href_resolver: resolver.resolver(), ..Default::default() };
let tree = parse(text.as_bytes(), &shallow(), &options).unwrap();
let mut found = Vec::new();
images(tree.root(), &mut found);
(found, resolver.usage())
}
#[test]
fn embedded_chain_caps_are_explicit_resource_refusals_for_plain_and_gzip_children() {
for gzip in [false, true] {
let inner = svg("<rect width='1' height='1'/>");
let middle = svg(&data_image(&packed(&inner, gzip)));
let outer = svg(&data_image(&packed(&middle, gzip)));
let (found, usage) = resolved(&outer, Limits { embedded_depth: 1, ..shallow() }, 1);
assert_eq!(found, [true]);
assert_eq!(usage.embedded_svg_depth, 1);
assert_eq!(usage.svg_limit_images, 1, "strict consumers still see the existing limit flag");
assert_eq!(usage.svg_resource_limit_images, 1, "a chain cap must not become a successful partial bounded preview");
let (found, usage) = resolved(&outer, Limits { embedded_depth: 2, ..shallow() }, 1);
assert_eq!(found, [true, true]);
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0));
}
}
#[test]
fn embedded_per_image_byte_caps_are_resource_refusals_for_plain_and_gzip_children() {
let inner = svg("<rect width='1' height='1'/>");
for gzip in [false, true] {
let outer = svg(&data_image(&packed(&inner, gzip)));
let (_, usage) = resolved(&outer, Limits { bytes: inner.len() - 1, embedded_bytes: inner.len() * 3, ..shallow() }, 1);
assert_eq!(usage.embedded_svg_count, 0);
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (1, 1));
let (found, usage) = resolved(&outer, Limits { bytes: inner.len(), ..shallow() }, 1);
assert_eq!(found, [true]);
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0));
}
}
#[test]
fn aggregate_embedded_bytes_are_resource_refusals_even_when_each_child_fits() {
let inner = svg("<rect width='1' height='1'/>");
for gzip in [false, true] {
let image = data_image(&packed(&inner, gzip));
let outer = svg(&format!("{image}{image}"));
let cap = inner.len() * 2 - 1;
let (found, usage) = resolved(&outer, Limits { embedded_bytes: cap, ..shallow() }, 1);
assert_eq!(found, [true]);
assert_eq!(usage.embedded_svg_bytes, cap, "a refused child still spends the remaining work allowance");
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (1, 1));
let (found, usage) = resolved(&outer, Limits { embedded_bytes: inner.len() * 2, ..shallow() }, 1);
assert_eq!(found, [true, true]);
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0));
}
}
#[test]
fn combined_xml_depth_omissions_remain_distinct_from_resource_refusals() {
let inner = svg("<rect width='1' height='1'/>");
for gzip in [false, true] {
let image = data_image(&packed(&inner, gzip));
let outer = svg(&format!("{}{}{}", "<g>".repeat(4), image, "</g>".repeat(4)));
let (found, usage) = resolved(&outer, Limits { tree_depth: 6, ..shallow() }, 5);
assert!(found.is_empty());
assert_eq!(usage.svg_limit_images, 1, "strict consumers must continue to reject this omission");
assert_eq!(usage.svg_resource_limit_images, 0, "non-strict consumers may omit this child without disguising a byte/chain overrun");
let (found, usage) = resolved(&svg(&image), Limits { tree_depth: 6, ..shallow() }, 1);
assert_eq!(found, [true]);
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0));
}
}
#[test]
fn invalid_and_corrupt_children_do_not_claim_a_resource_limit() {
let mut corrupt = svgz::compress(svg("<rect width='1' height='1'/>").as_bytes());
let crc = corrupt.len() - 8;
corrupt[crc] ^= 1;
for data in [b"not XML".to_vec(), corrupt] {
let (found, usage) = resolved(&svg(&data_image(&data)), shallow(), 1);
assert!(found.is_empty());
assert!(usage.invalid_svg_images > 0 || usage.svg_limit_images > 0, "strict consumers still observe unreadable content");
assert_eq!(usage.svg_resource_limit_images, 0);
}
}
}
mod draw_checks {
use super::*;