Files
faunosteo/crates/core/tests/svg_clean.rs
T
bchanot 8294d5471c fix(anatomy): V1-2.2 review findings, PIs and HTML refused, bounds
Security audit (PASS, 2 MEDIUM, 2 LOW) and verifier (ECARTS 6) on
741c25c: processing instructions and HTML fetchers refused, active
content under a long title classified, linear review groups, full
fixpoint check, bounded preview drawings, missing cap fixtures and
property checks, record wordings.
2026-10-29 13:38:33 +01:00

511 lines
19 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 cleaned text reads back with no removal and
//! cleans to itself. 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::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")),
// 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).
("dangling-references.svg", Clean, None),
("duplicate-ids.svg", Clean, None),
("osteo-halo-id.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.cleaned.is_some(),
"{file}"
),
Clean => assert!(
cleaning.removed.is_empty() && cleaning.cleaned.is_none(),
"{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()),
(6, 4),
"rgb() and attr() alone would be cleaned"
);
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>"),
];
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.cleaned.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")));
}
}
#[test]
fn a_clean_file_is_uploaded_as_it_is_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.sha256.as_deref(),
Some("0ea5202fa3b95bac167b87c12ee969ab0272e085b60c2d34dbca6202c5f08541")
);
assert_eq!(cleaning.byte_size, Some(132_997));
assert!(cleaning.preview.unwrap().starts_with("<svg"));
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", Cleanable, 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"]);
// cairo writes its colours as `rgb(20%, 40%, 70%)`: the allowlist takes any function out
// of a presentation attribute, so the cleaned drawing keeps its shapes, not its colours.
let shapes = clean_svg(&fixture("exports/cairo-1.18.4-pycairo-1.27.0-shapes.svg"));
assert_eq!(
shapes.removed,
[
"stop@stop-color",
"stop@stop-color",
"path@stroke",
"path@fill",
"g@fill"
]
);
assert_fixpoint(shapes.cleaned.as_deref().unwrap());
}
#[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 => assert_fixpoint(cleaning.cleaned.as_deref().unwrap()),
Clean => {}
}
println!(
"{name}: {:?} {:?} {:?}",
cleaning.outcome, cleaning.reason, cleaning.removed
);
}
}
/// A cleaned text reads back with nothing removed and cleans to itself.
fn assert_fixpoint(cleaned: &str) {
let read = read_svg(cleaned).unwrap_or_else(|e| panic!("{e:?}: {cleaned}"));
assert!(read.removed.is_empty(), "{:?}: {cleaned}", read.removed);
let again = clean_svg(cleaned.as_bytes());
assert_eq!(again.outcome, Clean, "{cleaned}");
assert_eq!(again.preview.as_deref(), Some(cleaned));
}
#[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(cleaned) = cleaning.cleaned {
assert_fixpoint(&cleaned);
}
}
}
// ---------------------------------------------------------------------------
// 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);
}
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.cleaned.as_deref().unwrap());
}
Rejected => {
rejected += 1;
let reason = cleaning.reason.unwrap();
assert_eq!(reason, "reference_cycle", "{text}");
*reasons.entry(reason).or_insert(0) += 1;
}
}
}
println!("generated: {clean} clean, {cleanable} cleanable, {rejected} rejected {reasons:?}");
assert!(
cleanable > 1000 && clean > 100,
"{clean} {cleanable} {rejected}"
);
}