mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 23:42:27 +00:00
fix: preserve bundle commits and expose SVG resource refusals
This commit is contained in:
1 parent
f0f4758c01
commit
d61afc4a3b
4 files changed
+420
-21
No files matched your search
@@ -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
@@ -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;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
|
||||
Reference in new issue
Block a user