Files
faunosteo/crates/core/tests/svg_clean.rs
T
bchanot 08efd9a792 fix(anatomy): V1-2.2 reserve the PDF halo id in the reader and composers
A drawing defining filter#osteo-halo replaced the PDF halo (a transparent
filter erased the marker); an element holding the id before the first
defs won its resolution. The reader refuses the id in any letter case
(reserved_id), both composers refuse such a tree, the halo is always the
engine's. Exact name only: osteo-overlays stays.
2026-10-30 17:30:48 +01:00

903 lines
34 KiB
Rust

//! V1-2.2: classifying and cleaning a drawing before upload (contract §9.2). The hostile
//! corpus of R3 answers as the table of §9.2 says, file by file; the committed vector-tool
//! exports and the product drawing read clean or are refused for their raster; the owner's
//! editor exports (`fixtures/svg/exports/owner`) are read when present; and a property test
//! over generated drawings proves the fixpoint: a stored text reads back with no removal and
//! gives itself again. Every accepted file is uploaded in the stored form (owner decision
//! 2026-10-29), never as its original bytes. The strict reader of stored drawings is unchanged.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use faunosteo_core::anatomy::svg::clean::{CleaningOutcome, SvgCleaning, clean_svg};
use faunosteo_core::anatomy::svg::read_svg;
use faunosteo_core::anatomy::svg::serialize::{STORED_PROLOG, serialize, stored_form};
use faunosteo_core::domain::sheet::verdict::sha256_hex;
const FIXTURES: &str = "crates/core/tests/fixtures/svg";
fn fixture(path: &str) -> Vec<u8> {
std::fs::read(common::repo_path(&format!("{FIXTURES}/{path}"))).unwrap()
}
fn outcome(cleaning: &SvgCleaning) -> (CleaningOutcome, Option<&str>) {
(cleaning.outcome, cleaning.reason.as_deref())
}
use CleaningOutcome::{Clean, Cleanable, Rejected};
#[test]
fn the_hostile_corpus_answers_as_the_contract_table() {
let active = Some("svg_active_content");
let table: &[(&str, CleaningOutcome, Option<&str>)] = &[
// Active or external content: refused, never cleaned.
("animation.svg", Rejected, active),
("css.svg", Rejected, active),
("data-and-images.svg", Rejected, active),
("entity-in-attribute.svg", Rejected, active),
("events.svg", Rejected, active),
("external-urls.svg", Rejected, active),
("external-use.svg", Rejected, active),
("foreign.svg", Rejected, active),
("href-unicode-space.svg", Rejected, active),
("script-urls.svg", Rejected, active),
("script.svg", Rejected, active),
("style-element.svg", Rejected, active),
("url-unicode-space.svg", Rejected, active),
// A processing instruction survives in the bytes the tree never reads.
("comments-pi-cdata.svg", Rejected, active),
// Hard rejections of the reader.
("bom.svg", Rejected, Some("malformed")),
("cdata-desync.svg", Rejected, Some("too_deep")),
(
"comment-desync-attributes.svg",
Rejected,
Some("too_complex"),
),
("comment-desync-depth.svg", Rejected, Some("too_deep")),
("doctype-entities.svg", Rejected, Some("doctype")),
("doctype-in-comment.svg", Rejected, Some("doctype")),
("malformed.svg", Rejected, Some("malformed")),
("not-svg.svg", Rejected, Some("not_svg")),
("prefixed-root.svg", Rejected, Some("not_svg")),
("unbound-prefix.svg", Rejected, Some("malformed")),
("use-mutual-cycle.svg", Rejected, Some("reference_cycle")),
("use-self-cycle.svg", Rejected, Some("reference_cycle")),
("wrong-root-namespace.svg", Rejected, Some("not_svg")),
// A reference to an id the drawing does not define (owner decision 2026-10-29).
(
"dangling-references.svg",
Rejected,
Some("dangling_reference"),
),
// An id the composition writes (owner brief 2026-10-30).
("osteo-halo-id.svg", Rejected, Some("reserved_id")),
// Other removals: cleaning offered.
("id-grammar.svg", Cleanable, None),
("long-title.svg", Cleanable, None),
("namespaces.svg", Cleanable, None),
("refused-subtrees.svg", Cleanable, None),
("root-class-style.svg", Cleanable, None),
("root-presentation.svg", Cleanable, None),
("whitespace-references.svg", Cleanable, None),
("xlink-other-prefix.svg", Cleanable, None),
("xlink-prefix-rebound.svg", Cleanable, None),
// Nothing removed (comments, stray text and clamped values are no removal).
("duplicate-ids.svg", Clean, None),
("root-without-namespace.svg", Clean, None),
("std-deviation.svg", Clean, None),
("viewbox-non-finite.svg", Clean, None),
];
let corpus = std::fs::read_dir(common::repo_path(&format!("{FIXTURES}/hostile")))
.unwrap()
.count();
assert_eq!(table.len(), corpus, "every hostile file has a line");
for (file, expected, reason) in table {
let cleaning = clean_svg(&fixture(&format!("hostile/{file}")));
assert_eq!(outcome(&cleaning), (*expected, *reason), "{file}");
match expected {
Rejected => assert!(
cleaning.preview.is_none() && cleaning.sha256.is_none(),
"{file}"
),
Cleanable => assert!(
cleaning.active.is_empty() && cleaning.stored.is_some(),
"{file}"
),
Clean => assert!(
cleaning.removed.is_empty() && cleaning.stored.is_some(),
"{file}"
),
}
}
}
#[test]
fn active_names_are_listed_and_ordinary_removals_are_not() {
let css = clean_svg(&fixture("hostile/css.svg"));
assert_eq!(
(css.removed.len(), css.active.len()),
(5, 4),
"attr() alone would be cleaned; the strict rgb() is kept"
);
let events = clean_svg(&fixture("hostile/events.svg"));
assert_eq!(
events.active,
[
"svg@onload",
"path@onclick",
"path@ONMOUSEOVER",
"g@onfocusin"
]
);
let namespaces = clean_svg(&fixture("hostile/namespaces.svg"));
assert!(
namespaces
.removed
.contains(&"path@inkscape:label".to_owned())
);
let title = clean_svg(&fixture("hostile/long-title.svg"));
assert_eq!(title.removed, ["title"]);
// The stored-drawing reader still refuses that file whole.
let text = String::from_utf8(fixture("hostile/long-title.svg")).unwrap();
assert_eq!(read_svg(&text).unwrap_err().reason(), "too_complex");
}
/// The security audit's probes (V1-2.2): content the classification must refuse, never clean.
#[test]
fn hidden_or_html_content_is_refused_not_cleaned() {
let long = "A".repeat(4097);
let svg = |body: &str| {
format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:h=\"http://www.w3.org/1999/xhtml\">{body}</svg>"
)
};
let cases = [
"<?xml-stylesheet type=\"text/xsl\" href=\"https://attacker.example/x.xsl\"?>".to_owned()
+ &svg("<path d=\"M0 0h1\"/>"),
svg("<?xml-stylesheet href=\"x.css\"?><path d=\"M0 0h1\"/>"),
svg(&format!("<title>{long}<script>alert(1)</script></title>")),
svg(&format!("<title onload=\"x()\">{long}</title>")),
svg(&format!(
"<desc>{long}<foreignObject><iframe src=\"https://e/\"/></foreignObject></desc>"
)),
svg("<h:img src=\"https://e/x.png\"/>"),
svg("<h:meta http-equiv=\"refresh\" content=\"0;url=https://e\"/>"),
svg("<h:input type=\"image\" src=\"https://e\"/>"),
svg("<h:source srcset=\"https://e/a.png\"/>"),
svg("<h:frame src=\"https://e\"/>"),
svg("<h:form action=\"https://e\"/>"),
svg("<h:div>x</h:div>"),
svg("<g><x:thing xmlns:x=\"urn:x\" src=\"https://e\"/></g>"),
svg("<g xml:base=\"https://e/\"><path d=\"M0 0h1\"/></g>"),
svg("<path d=\"M0 0h1\" style=\"fill:src('https://e/x')\"/>"),
svg("<style>p{fill:image('https://e/x.png')}</style>"),
];
for case in cases {
let cleaning = clean_svg(case.as_bytes());
assert_eq!(
outcome(&cleaning),
(Rejected, Some("svg_active_content")),
"{case}"
);
assert!(!cleaning.active.is_empty(), "{case}");
}
// A long title alone is still cleaned; editor metadata stays cleanable.
assert_eq!(
outcome(&clean_svg(
svg(&format!("<title>{long}</title>")).as_bytes()
)),
(Cleanable, None)
);
let inkscape = r#"<svg xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"><sodipodi:namedview id="n"/><path d="M0 0h1"/></svg>"#;
assert_eq!(outcome(&clean_svg(inkscape.as_bytes())), (Cleanable, None));
}
#[test]
fn the_verdict_refuses_a_stored_processing_instruction() {
use faunosteo_core::domain::sheet::verdict::{
DrawingResult, VerdictBinding, VerdictDrawing, VerdictInput, compute_verdict,
};
let bytes = b"<?xml-stylesheet href=\"https://e/x.xsl\"?><svg xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M0 0h1\"/></svg>";
let asset = "11111111-2222-4333-8444-555555555555";
let document = serde_json::json!({
"schema_version": 2, "species_id": "canine", "name": { "fr": "C", "en": "C" },
"description": {}, "scope_disclaimer": {}, "attribution": { "authors": [], "license": null, "notes": null },
"vertebral_config": { "regions": [] }, "references": [], "categories": [],
"views": [{ "id": "main", "kind": "main", "name": { "fr": "V", "en": "V" }, "svg_asset_id": asset, "view_box": null }],
"annotations": [], "finding_zones": []
})
.to_string();
let sha = sha256_hex(bytes);
let verdict = compute_verdict(&VerdictInput {
binding: VerdictBinding {
sheet_id: "s".into(),
version_id: "v".into(),
revision: 1,
review_id: "r".into(),
},
document: &document,
base_document: None,
drawings: vec![VerdictDrawing {
asset_id: asset,
sha256: &sha,
byte_size: bytes.len() as u64,
bytes: Some(bytes),
}],
});
assert_eq!(verdict.drawings[0].result, DrawingResult::SvgRejected);
assert_eq!(
verdict.drawings[0].detail.as_deref(),
Some("processing_instruction")
);
}
#[test]
fn a_plain_style_sheet_is_cleaned_and_named() {
let styled = br#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4 4"><defs><style>.st0{fill:#fff}</style></defs><path class="st0" d="M0 0h1"/></svg>"#;
let cleaning = clean_svg(styled);
assert_eq!(outcome(&cleaning), (Cleanable, None));
assert!(cleaning.style_removed);
let cleaned = cleaning.stored.as_deref().unwrap();
assert!(!cleaned.contains("<style") && cleaned.contains("class=\"st0\""));
assert_eq!(
cleaning.sha256.as_deref(),
Some(sha256_hex(cleaned.as_bytes()).as_str())
);
assert_eq!(cleaning.byte_size, Some(cleaned.len() as u64));
for hostile in [
&br#"<svg xmlns="http://www.w3.org/2000/svg"><style>@font-face{src:url(a.woff)}</style></svg>"#[..],
br#"<svg xmlns="http://www.w3.org/2000/svg"><style>p{fill:red;behavior:url(x)}</style></svg>"#,
br#"<svg xmlns="http://www.w3.org/2000/svg"><style>p{background:url(javascript:a)}</style></svg>"#,
br#"<svg xmlns="http://www.w3.org/2000/svg"><style>p{fill:\72 ed}</style></svg>"#,
] {
assert_eq!(outcome(&clean_svg(hostile)), (Rejected, Some("svg_active_content")));
}
}
/// Owner decision 2026-10-29: the bytes uploaded are the stored form, never the original. The
/// seed's equine drawing already is in that form, so its sha256 does not move; another clean
/// file loses its declaration, comments, CDATA, entity spellings and quoting, nothing else.
#[test]
fn a_clean_file_is_uploaded_in_its_stored_form_and_shown_as_read() {
let horse = std::fs::read(common::repo_path(
"supabase/seed/anatomical-sheets/equine/draft/assets/horse.svg",
))
.unwrap();
let cleaning = clean_svg(&horse);
assert_eq!(outcome(&cleaning), (Clean, None));
assert_eq!(
cleaning.stored.as_deref().map(str::as_bytes),
Some(&horse[..])
);
assert_eq!(
cleaning.sha256.as_deref(),
Some("0ea5202fa3b95bac167b87c12ee969ab0272e085b60c2d34dbca6202c5f08541")
);
assert_eq!(cleaning.byte_size, Some(132_997));
assert!(cleaning.preview.unwrap().starts_with("<svg"));
let loose = "<?xml version='1.0' encoding='ISO-8859-1' standalone='no'?>\n<!-- editor -->\
<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 4 4'><!-->--><title><![CDATA[a < b]]> &#233;</title>\
<path d='M0 0h1' fill='#ABC'/></svg>";
let cleaning = clean_svg(loose.as_bytes());
assert_eq!(outcome(&cleaning), (Clean, None));
let stored = cleaning.stored.as_deref().unwrap();
assert_eq!(
stored,
format!(
"{STORED_PROLOG}<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 4 4\"><title>a &lt; b é</title>\
<path d=\"M0 0h1\" fill=\"#ABC\"/></svg>"
)
);
assert_eq!(
cleaning.sha256.as_deref(),
Some(sha256_hex(stored.as_bytes()).as_str())
);
assert_eq!(cleaning.byte_size, Some(stored.len() as u64));
assert_eq!(
cleaning.preview.as_deref(),
stored.strip_prefix(STORED_PROLOG)
);
assert_fixpoint(stored);
assert_eq!(
serialize(&read_svg(stored).unwrap().root),
cleaning.preview.unwrap()
);
assert_eq!(
outcome(&clean_svg(b"\xff\xfe<svg/>")),
(Rejected, Some("malformed"))
);
assert_eq!(
outcome(&clean_svg(&vec![b' '; 2 * 1024 * 1024 + 1])),
(Rejected, Some("too_large"))
);
}
#[test]
fn the_vector_tool_exports_are_read_or_refused_for_their_raster() {
let table = [
("cairo-1.18.4-pycairo-1.27.0-shapes.svg", Clean, None),
(
"cairo-1.18.4-pycairo-1.27.0-raster.svg",
Rejected,
Some("svg_active_content"),
),
("imagemagick-7.1.2-18-draw.svg", Clean, None),
("imagemagick-7.1.2-18-mvg.svg", Clean, None),
];
for (file, expected, reason) in table {
assert_eq!(
outcome(&clean_svg(&fixture(&format!("exports/{file}")))),
(expected, reason),
"{file}"
);
}
let raster = clean_svg(&fixture("exports/cairo-1.18.4-pycairo-1.27.0-raster.svg"));
assert_eq!(raster.active, ["image"]);
}
/// Security review of the arbitrations (2026-10-29): a `url(` is kept only when its target is
/// `#` and an id in the reference grammar, an optional matching quote and `)`; every spelling
/// a browser would normalise or read otherwise is active content, so the dangling check, the
/// per-view scoping and the expansion budget cannot be walked around. Names glued to `url(` or
/// `rgb(` are other functions, removed.
#[test]
fn every_url_spelling_but_the_strict_one_is_refused() {
let svg = |value: &str| {
format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 10 10\">\
<linearGradient id=\"a\"/><path d=\"M0 0\" fill=\"{value}\"/></svg>"
)
};
for value in [
"url(#%61)",
"url(#%66v.main.a)",
"url(\'#\ta\')",
"url(\'#a\tb\')",
"url(#)",
"url(# a)",
"url(\'#a)",
"url(&quot;#a\')",
"url(#é)",
"url(#1a)",
"url(#a b)",
"url(#a rgb(1,2,3))",
"url(#/a)",
"url(#a",
"url(\'#&#9;a\')",
"url(\'#a&#9;\')",
"url(\'#a&#10;\')",
"url(&quot;&#13;#a&quot;)",
] {
let cleaning = clean_svg(svg(value).as_bytes());
assert_eq!(
outcome(&cleaning),
(Rejected, Some("svg_active_content")),
"{value}"
);
assert_eq!(cleaning.active, ["path@fill"], "{value}");
}
for value in [
"url(#a)",
"URL( \'#a\' )",
"url(&quot;#a&quot;)",
"url(\n#a)",
] {
assert_eq!(
outcome(&clean_svg(svg(value).as_bytes())),
(Clean, None),
"{value}"
);
}
for value in [
"érgb(1,2,3)",
"rgurl(#a(1,2,3)",
"xurl(#a)",
"rgb(1,2,3)rgb(4,5,6)",
"rgb(1,2,3)x",
] {
let cleaning = clean_svg(svg(value).as_bytes());
assert_eq!(outcome(&cleaning), (Cleanable, None), "{value}");
assert_eq!(cleaning.removed, ["path@fill"], "{value}");
}
// The expansion budget holds whatever the spelling: 250 000 references written `%61` are
// refused as active content, as the plain spelling is refused as too complex.
let flood = format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\"><linearGradient id=\"a\"/><path d=\"M0 0\" fill=\"{}\"/></svg>",
"url(#%61) ".repeat(25_000)
);
assert_eq!(
outcome(&clean_svg(flood.as_bytes())).1,
Some("svg_active_content")
);
}
/// Final review 2026-10-30: the one `url(` grammar holds in every attribute, not only in the
/// presentation ones. A `url(` glued to a longer name, however spelt, is removed wherever it
/// stands; a non-strict `url(` is active content; a reference to an absent id is refused; a
/// strict reference and a value with no `url(` are kept.
#[test]
fn every_attribute_reads_url_with_the_one_grammar() {
let svg = |attr: &str, value: &str| {
format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 10 10\">\
<linearGradient id=\"a\"/><g {attr}=\"{value}\"><path d=\"M0 0\"/></g></svg>"
)
};
for attr in ["class", "result", "values", "transform", "in", "type"] {
for value in [
"xurl(#a)",
"-url(#a)",
"_url(#a)",
"9url(#a)",
"éurl(#a)",
"\u{a0}url(#a)",
"x&#117;rl(#a)",
"xURL(#a)",
"url(#a) xurl(#a)",
] {
let cleaning = clean_svg(svg(attr, value).as_bytes());
assert_eq!(outcome(&cleaning), (Cleanable, None), "{attr}={value}");
assert_eq!(cleaning.removed, [format!("g@{attr}")], "{attr}={value}");
assert_fixpoint(cleaning.stored.as_deref().unwrap());
}
for value in [
"url(#%61)",
"url('#\ta')",
"url(#a",
"\\75rl(#a)",
"u\\72l(#a)",
] {
let cleaning = clean_svg(svg(attr, value).as_bytes());
assert_eq!(
outcome(&cleaning),
(Rejected, Some("svg_active_content")),
"{attr}={value}"
);
}
assert_eq!(
outcome(&clean_svg(svg(attr, "url(#nope)").as_bytes())),
(Rejected, Some("dangling_reference")),
"{attr}"
);
for value in ["url(#a)", "URL( '#a' )", "curl", "url", "a(b)", "M0 0"] {
assert_eq!(
outcome(&clean_svg(svg(attr, value).as_bytes())),
(Clean, None),
"{attr}={value}"
);
}
}
}
/// Owner decision 2026-10-30 (Figma writes `maskUnits="userSpaceOnUse"`): the three unit
/// attributes of masks and clip paths are kept with their two keywords only.
#[test]
fn mask_and_clip_units_keep_their_keywords_only() {
for attr in ["maskUnits", "maskContentUnits", "clipPathUnits"] {
for value in ["userSpaceOnUse", "objectBoundingBox"] {
let svg = format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\"><mask id=\"m\" {attr}=\"{value}\"/></svg>"
);
assert_eq!(
outcome(&clean_svg(svg.as_bytes())),
(Clean, None),
"{attr}={value}"
);
}
for value in ["", " userSpaceOnUse", "userspaceonuse", "url(#m)", "x(1)"] {
let svg = format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\"><mask id=\"m\" {attr}=\"{value}\"/></svg>"
);
let cleaning = clean_svg(svg.as_bytes());
assert_eq!(cleaning.outcome, Cleanable, "{attr}={value}");
assert_eq!(cleaning.removed, [format!("mask@{attr}")], "{attr}={value}");
}
}
}
/// The owner's Figma exports (2026-10-30, the frame of `inkscape-source.svg`, raw files): the
/// clip path written as a luminance `mask` in user space, the dashed stroke expanded into path
/// segments, the ellipse and the rectangle as paths, `fill="none"` on the root, the gradient
/// after its use in `defs`. `ids` adds layer names as ids, some with spaces (`Clip path group`),
/// which the id grammar removes; nothing names them. The live text is in neither file.
#[test]
fn the_figma_exports_keep_their_mask_gradient_and_shapes() {
let cases: [(&str, CleaningOutcome, &[&str]); 2] = [
("figma-web-20261030-default.svg", Clean, &[]),
("figma-web-20261030-ids.svg", Cleanable, &["g@id"]),
];
for (file, expected, removed) in cases {
let cleaning = clean_svg(&fixture(&format!("exports/owner/{file}")));
assert_eq!(outcome(&cleaning), (expected, None), "{file}");
assert_eq!(cleaning.removed, removed, "{file}");
assert!(
cleaning.active.is_empty() && !cleaning.style_removed,
"{file}"
);
let stored = cleaning.stored.as_deref().unwrap();
for kept in [
"maskUnits=\"userSpaceOnUse\"",
"style=\"mask-type:luminance\"",
"mask=\"url(#mask0_3_9)\"",
"fill=\"url(#paint0_linear_3_9)\"",
"gradientUnits=\"userSpaceOnUse\"",
"stop-opacity=\"0.8\"",
"fill-opacity=\"0.5\"",
] {
assert!(stored.contains(kept), "{file}: {kept}");
}
assert!(!stored.contains("<text"), "{file}");
assert_fixpoint(stored);
}
}
/// Real Inkscape 1.4.3 exports (owner go 2026-10-29; `exports/generate-inkscape.sh`): its
/// editor metadata and namespaces and the `text` it keeps as text are removed and named, so
/// each is cleanable; shapes, gradient, clip path, internal references and colours stay; the
/// stored text is a fixpoint.
#[test]
fn the_inkscape_exports_are_cleaned_with_their_shapes() {
let cases: [(&str, &[&str]); 3] = [
(
"inkscape-1.4.3-inkscape-svg.svg",
&[
"svg@xmlns:inkscape",
"svg@xmlns:sodipodi",
"svg@xmlns:svg",
"svg@sodipodi:docname",
"sodipodi:namedview",
"text",
],
),
("inkscape-1.4.3-plain-svg.svg", &["svg@xmlns:svg", "text"]),
(
"inkscape-1.4.3-paths.svg",
&["svg@xmlns:svg", "path@aria-label"],
),
];
for (file, removed) in cases {
let cleaning = clean_svg(&fixture(&format!("exports/{file}")));
assert_eq!(outcome(&cleaning), (Cleanable, None), "{file}");
assert_eq!(cleaning.removed, removed, "{file}");
assert!(
cleaning.active.is_empty() && !cleaning.style_removed,
"{file}"
);
let stored = cleaning.stored.as_deref().unwrap();
for kept in [
"<linearGradient",
"<clipPath",
"clip-path=\"url(#frame)\"",
"fill=\"url(#coat)\"",
"stroke-dasharray=\"6 3\"",
] {
assert!(stored.contains(kept), "{file}: {kept}");
}
assert_fixpoint(stored);
}
let plain = clean_svg(&fixture("exports/inkscape-1.4.3-plain-svg.svg"));
assert!(plain.stored.unwrap().contains("fill=\"rgb(51, 102, 179)\""));
let paths = clean_svg(&fixture("exports/inkscape-1.4.3-paths.svg"));
assert!(
paths
.stored
.unwrap()
.contains("style=\"fill:#3366b3;fill-opacity:0.5\"")
);
}
/// Owner decision 2026-10-29: cairo writes its colours `rgb(20%, 40%, 70%)`; the strict
/// numeric `rgb()` is kept, so its export reads with no removal, colours, shapes and internal
/// references included, and its text is stable.
#[test]
fn the_cairo_export_keeps_its_colours_shapes_and_references() {
let bytes = fixture("exports/cairo-1.18.4-pycairo-1.27.0-shapes.svg");
let shapes = clean_svg(&bytes);
assert!(shapes.removed.is_empty(), "{:?}", shapes.removed);
let preview = shapes.preview.as_deref().unwrap();
for colour in [
"stop-color=\"rgb(60%, 30%, 20%)\"",
"stop-color=\"rgb(90%, 80%, 60%)\"",
"stroke=\"rgb(20%, 20%, 20%)\"",
"fill=\"rgb(20%, 40%, 70%)\"",
"fill=\"rgb(0%, 0%, 0%)\"",
] {
assert!(preview.contains(colour), "{colour}");
}
let original = std::str::from_utf8(&bytes).unwrap();
let count = |text: &str, tag: &str| text.matches(tag).count();
for tag in ["<path", "<use", "<g", "<clipPath", "<linearGradient"] {
assert_eq!(count(preview, tag), count(original, tag), "{tag}");
}
for reference in [
"clip-path=\"url(#clip-0)\"",
"fill=\"url(#linear-pattern-0)\"",
"xlink:href=\"#glyph-0-0\"",
] {
assert!(preview.contains(reference), "{reference}");
}
assert!(read_svg(preview).is_ok_and(|read| read.removed.is_empty()));
assert_eq!(
clean_svg(preview.as_bytes()).preview.as_deref(),
Some(preview)
);
}
/// The colour exception opens nothing else: a reference outside the document, an active CSS
/// token or a script next to a colour still refuses the file; any other function, or a colour
/// outside the strict form, is still removed (and cleaned, never kept).
#[test]
fn colours_open_no_way_for_active_or_unknown_functions() {
let svg = |body: &str| {
format!("<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 10 10\">{body}</svg>")
};
for (body, active) in [
(
"<path d=\"M0 0\" fill=\"rgb(1,2,3) url(http://e/x)\"/>",
"path@fill",
),
(
"<path d=\"M0 0\" style=\"fill:rgb(1,2,3);background:url(x)\"/>",
"path@style",
),
(
"<path d=\"M0 0\" style=\"fill:rgb(1,2,expression(alert(1)))\"/>",
"path@style",
),
(
"<path d=\"M0 0\" fill=\"rgb(1,2,3)\" onclick=\"x()\"/>",
"path@onclick",
),
(
"<path d=\"M0 0\" style=\"fill:rgb(1,2,3);@import 'x'\"/>",
"path@style",
),
("<path d=\"M0 0\" fill=\"\\72 gb(1,2,3)\"/>", "path@fill"),
(
"<path d=\"M0 0\" fill=\"rgb(1,2,3)\"/><script>alert(1)</script>",
"script",
),
] {
let cleaning = clean_svg(svg(body).as_bytes());
assert_eq!(
outcome(&cleaning),
(Rejected, Some("svg_active_content")),
"{body}"
);
assert_eq!(cleaning.active, [active], "{body}");
}
for (body, removed) in [
("<path d=\"M0 0\" fill=\"rgb(1,2,var(--x))\"/>", "path@fill"),
("<path d=\"M0 0\" fill=\"RGB(1,2,3)\"/>", "path@fill"),
("<path d=\"M0 0\" stroke=\"rgb(300,0,0)\"/>", "path@stroke"),
(
"<path d=\"M0 0\" style=\"fill:hsl(1,2%,3%)\"/>",
"path@style",
),
("<stop stop-color=\"rgba(1,2,3)\"/>", "stop@stop-color"),
] {
let cleaning = clean_svg(svg(body).as_bytes());
assert_eq!(outcome(&cleaning), (Cleanable, None), "{body}");
assert_eq!(cleaning.removed, [removed], "{body}");
assert_fixpoint(cleaning.stored.as_deref().unwrap());
}
let kept =
svg("<path d=\"M0 0\" fill=\"rgba(10%, 20%, 30%, 50%)\" style=\"stroke:rgb(1, 2, 3)\"/>");
assert_eq!(outcome(&clean_svg(kept.as_bytes())), (Clean, None));
}
#[test]
fn the_owner_editor_exports_are_cleaned_or_refused_with_a_reason() {
let dir = common::repo_path(&format!("{FIXTURES}/exports/owner"));
let files: Vec<_> = std::fs::read_dir(dir)
.unwrap()
.map(|entry| entry.unwrap().path())
.filter(|path| path.extension().is_some_and(|e| e == "svg"))
.collect();
println!("owner editor exports: {}", files.len());
for path in files {
let name = path.file_name().unwrap().to_string_lossy().into_owned();
let cleaning = clean_svg(&std::fs::read(&path).unwrap());
if name.contains("-active-") {
assert_eq!(
outcome(&cleaning),
(Rejected, Some("svg_active_content")),
"{name}"
);
continue;
}
match cleaning.outcome {
Rejected => assert!(cleaning.reason.is_some(), "{name}"),
Cleanable | Clean => assert_fixpoint(cleaning.stored.as_deref().unwrap()),
}
println!(
"{name}: {:?} {:?} {:?}",
cleaning.outcome, cleaning.reason, cleaning.removed
);
}
}
/// A stored text reads back with nothing removed, is clean and is its own stored form.
fn assert_fixpoint(stored: &str) {
let read = read_svg(stored).unwrap_or_else(|e| panic!("{e:?}: {stored}"));
assert!(read.removed.is_empty(), "{:?}: {stored}", read.removed);
let again = clean_svg(stored.as_bytes());
assert_eq!(again.outcome, Clean, "{stored}");
assert_eq!(again.stored.as_deref(), Some(stored));
assert_eq!(stored_form(&read.root), stored);
}
#[test]
fn every_cleanable_file_of_the_corpus_reaches_the_fixpoint() {
for file in std::fs::read_dir(common::repo_path(&format!("{FIXTURES}/hostile"))).unwrap() {
let cleaning = clean_svg(&std::fs::read(file.unwrap().path()).unwrap());
if let Some(stored) = cleaning.stored {
assert_fixpoint(&stored);
}
}
}
// ---------------------------------------------------------------------------
// Property test: generated drawings mixing what the reader keeps, cleans and refuses.
struct Rng(u64);
impl Rng {
fn next(&mut self) -> u64 {
self.0 ^= self.0 << 13;
self.0 ^= self.0 >> 7;
self.0 ^= self.0 << 17;
self.0
}
fn pick<'a>(&mut self, items: &[&'a str]) -> &'a str {
items[(self.next() % items.len() as u64) as usize]
}
}
const ELEMENTS: [&str; 14] = [
"g",
"path",
"circle",
"rect",
"defs",
"linearGradient",
"clipPath",
"title",
"symbol",
"metadata",
"sodipodi:namedview",
"text",
"switch",
"use",
];
const ATTRIBUTES: [&str; 22] = [
"id=\"a1\"",
"id=\"1bad\"",
"id=\"b_2\"",
"class=\"st0\"",
"style=\"fill:#123456\"",
"style=\"fill:rgb(1,2,3)\"",
"fill=\"url(#a1)\"",
"fill=\"none\"",
"d=\"M0 0L1 1\"",
"data-name=\"Calque 1\"",
"inkscape:label=\"x\"",
"xml:space=\"preserve\"",
"transform=\"translate(1 2)\"",
"stroke-width=\"0.5\"",
"opacity=\"0.5\"",
"href=\"#b_2\"",
"xlink:href=\"#a1\"",
"x=\"0px\"",
"enable-background=\"new\"",
"stdDeviation=\"500\"",
"sodipodi:docname=\"a.svg\"",
"points=\"0,0 1,1 2,0\"",
];
/// One element and its subtree; prefixed names only when the root declares them.
fn element(rng: &mut Rng, depth: usize, out: &mut String, editor: bool) {
let name = loop {
let name = rng.pick(&ELEMENTS);
if editor || !name.contains(':') {
break name;
}
};
out.push('<');
out.push_str(name);
let mut written: Vec<&str> = Vec::new();
for _ in 0..rng.next() % 4 {
let attribute = rng.pick(&ATTRIBUTES);
let attribute_name = attribute.split('=').next().unwrap_or(attribute);
let declared =
editor || !attribute.starts_with("inkscape:") && !attribute.starts_with("sodipodi:");
if declared && !written.contains(&attribute_name) {
written.push(attribute_name);
out.push(' ');
out.push_str(attribute);
}
}
if depth >= 4 || rng.next().is_multiple_of(3) {
out.push_str("/>");
return;
}
out.push('>');
if name == "title" {
out.push_str("Garrot &amp; « encolure »");
}
for _ in 0..rng.next() % 3 {
element(rng, depth + 1, out, editor);
}
out.push_str("</");
out.push_str(name);
out.push('>');
}
fn drawing(rng: &mut Rng) -> String {
let root = rng.pick(&[
"",
"",
" class=\"page\"",
" style=\"width:100%\"",
" version=\"1.1\"",
]);
let editor = rng.next().is_multiple_of(2);
let declarations = if editor {
" xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" \
xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\""
} else {
""
};
let mut out = format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"{declarations} \
viewBox=\"0 0 10 10\"{root}>"
);
for _ in 0..1 + rng.next() % 4 {
element(rng, 1, &mut out, editor);
}
// Most drawings define the ids the references name, after the generated ones (which stay
// first, so their cycles still count); the others may dangle.
if !rng.next().is_multiple_of(4) {
out.push_str("<defs><linearGradient id=\"a1\"/><path id=\"b_2\" d=\"M0 0\"/></defs>");
}
out.push_str("</svg>");
out
}
#[test]
fn generated_drawings_clean_to_a_fixpoint() {
let mut rng = Rng(0x5eed_1234_abcd_0001);
let (mut clean, mut cleanable, mut rejected) = (0, 0, 0);
let mut reasons = std::collections::BTreeMap::new();
for _ in 0..3000 {
let text = drawing(&mut rng);
let cleaning = clean_svg(text.as_bytes());
match cleaning.outcome {
Clean => clean += 1,
Cleanable => {
cleanable += 1;
assert_fixpoint(cleaning.stored.as_deref().unwrap());
}
Rejected => {
rejected += 1;
let reason = cleaning.reason.unwrap();
assert!(
matches!(reason.as_str(), "reference_cycle" | "dangling_reference"),
"{reason}: {text}"
);
*reasons.entry(reason).or_insert(0) += 1;
}
}
}
println!("generated: {clean} clean, {cleanable} cleanable, {rejected} rejected {reasons:?}");
assert!(
cleanable > 1000 && clean > 100 && reasons.len() == 2,
"{clean} {cleanable} {rejected} {reasons:?}"
);
}