diff --git a/.claude/audits/2026-10-29-v1-2-2-arbitrations-security.md b/.claude/audits/2026-10-29-v1-2-2-arbitrations-security.md new file mode 100644 index 00000000..a7ec5da6 --- /dev/null +++ b/.claude/audits/2026-10-29-v1-2-2-arbitrations-security.md @@ -0,0 +1,193 @@ +# Security gate, V1-2.2 owner arbitrations (diff 17d9199..HEAD) + +Mode: audit. Branch `feature/v1-2-anatomical-sheets`, worktree `v1-2`. Date 2026-10-29. + +``` +SECURITY — VERDICT: BLOCK(1) +TOOL: semgrep 1.168.0 present but NOT RUN (p/security-audit, p/secrets, p/owasp-top-ten are fetched from the registry at run time and the brief forbids network) — effectively DEGRADED: checklist + guardrails scanner + manual attack review + probes on the built wasm module and on headless browsers +SCOPE: 40 files +BLOCKING: + 1. [HIGH] url-reference-spelling-mismatch (reader and composer read fewer `url(#…)` spellings than browsers resolve) — crates/core/src/anatomy/svg/sanitize.rs:488 (url_targets), :502 (scope_url_targets), :523 (urls_are_local), :528 (calls_only_local_url); crates/core/src/anatomy/svg/refs.rs:115 (reference_ids); crates/core/src/anatomy/compose.rs:98 (scope_ids) — `fill="url(#%66v.main.g)"` (also `url(#%61)`, and in Chromium `url('#a')`) passes the sanitiser, is invisible to `check_targets`, `check_references` and `scope_url_targets`, and is resolved by Chromium and Firefox after percent-decoding: it defeats B1 (dangling check), B2 (view scoping, it reaches another view's `fv.main.g`) and the expansion budget (a 5 KB drawing hangs Chromium for 45 s) — hint: refuse in `urls_are_local` any `url(` whose target is not `#` + `[A-Za-z_][\w.:-]*` followed by optional space or the closing quote then `)` (so `url(#)`, `%`, tab, `/`, non-ASCII after `#` are refused as active), so the sanitiser admits exactly what `url_targets` reads; add a fail-closed check in `compose_canvas` that every composed `url(` target starts with the view scope +REPORTED (non-blocking): + - [MEDIUM] scope-key-is-view-id-only — crates/core/src/anatomy/compose.rs:92 — two documents that share a view id (every sheet has `main`) and are inlined in one page share the scope `fv.main.`; the first element in tree order wins, so §10 "never in another view" holds inside one document only + - [LOW] colour-function-not-whole-value — crates/core/src/anatomy/svg/sanitize.rs:547 — strict `rgb()` is stripped wherever it sits in the value, so `rgb(1,2,3)rgb(4,5,6)` and `url(#a rgb(1,2,3))` (refused before) now pass; invalid CSS the browser drops, no fetch found in 19 hostile values + - [LOW] test-oracle-shares-the-blind-spot — crates/core/tests/svg_scope.rs:107, apps/app/tests/helpers/svgTree.ts:112 — the oracles read references with `url_targets` / `replaceAll('url(#'`, so they cannot see a reader/browser divergence; no test uses `%`, tab or a non-id first character + - [LOW] new-lint-allow (context, not a security suppression) — crates/core/tests/svg_scope.rs:6 — `#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]`, same header as 49 other test files + - [LOW] mutation-script-rewrites-sources — .claude/audits/2026-10-29-v1-2-2-mutations-arbitrations.py — edits source files in place and restores them in `finally`; a SIGKILL leaves a mutant in the tree (read only, not run) +PROOF: semgrep 0 rules on 0 files (not run, no network) → 0 findings; checklist 9 checks (secrets, SQL concatenation, unsanitised render, authz, error surfaces, logging, tracked .env, guardrails scanner, new suppressions) → 1 context finding; manual attack review of 12 files + 3 probe families (built wasm module, Chromium 1248, Firefox 1555) → 1 HIGH, 1 MEDIUM, 3 LOW +``` + +REPORT_WRITTEN: .claude/audits/2026-10-29-v1-2-2-arbitrations-security.md + +## 1. The blocking finding + +### What the code does + +`sanitize::value_acceptable` (sanitize.rs:417) lets a `url(` through when the text after the +opening, the CSS space and the optional quote starts with `#` (`urls_are_local`, :523), and +when no other `(` remains (`calls_only_local_url`, :528). It does not look at what follows +the `#`. + +Three readers then work on the same value, each with its own idea of "the id": + +- `url_targets` (:488) takes the longest run of `[A-Za-z0-9_.:-]` after `#`, and drops an + empty one. +- `scope_url_targets` (:502) writes the view scope after `#` only when the next character is + in that set. +- `refs::reference_ids` (refs.rs:115), which feeds `check_targets` (B1) and + `check_references` (cycle and expansion budget), calls `url_targets`. + +When the first character after `#` is outside the set, all three see "no reference" and the +value is stored and composed byte for byte. A browser does not: it percent-decodes the +fragment (Chromium and Firefox, measured below), and Chromium also drops a tab inside a +quoted CSS string (URL Standard: tab and newline are removed from the input). + +### Probes (all throwaway, in the session scratchpad, nothing written in the worktree) + +1. Built wasm module of the worktree (`packages/core-wasm/pkg`, built 16:28, after the last + source edit at 16:18), `clean_svg` on a one-rect drawing: + - `fill="url(#nope)"` gives `rejected dangling_reference`. + - `fill="url(#%6eope)"` gives `clean`. The dangling check is bypassed. + - `fill="url(#%66v.main.g)"` with a local `` gives `clean`. +2. Same module, `PreviewBuilder` on the equine draft document with that drawing as the + horse asset, `view.canvas`: + - view `main`: `` and ``. + - view `head`: `` and ``. + The reference is not rewritten. In the page the `head` rectangle resolves into the + `main` canvas. +3. Browsers, inline SVG in an HTML page, `fill="url(#a)"` control painted red: + + | spelling | Chromium 1248 | Firefox 1555 | + |---|---|---| + | `url(#a)` | resolves | resolves | + | `url(#%61)` | resolves | resolves | + | `style="fill:url(#%61)"` | resolves | resolves | + | `url(#%66v.other.x)` (another view's scoped id) | resolves | resolves | + | `url('#a')` (` `) | resolves | does not | + | `url(#nope)` | none | none | + + WebKit was not tested. +4. Budget bypass, Chromium 1248, nested masks written with `url(#%6dN)`, fan-out 10 per + level, one root rectangle masked by level 0: + + | levels | size | render time | + |---|---|---| + | 5 | 3.3 KB page | 0.5 s | + | 6 | 4.1 KB page | 4.6 s | + | 7 | 4.8 KB page | 44.8 s | + + Each level costs ten times more. The same structure with plain `url(#mN)` is refused by + `expanded_size` (10^7 against 50,000). In the core, a value of 250k `url(#a)` gives + `too_complex` in 58 ms, the same value with `url(#%61)` gives `clean` in 107 ms. + Firefox timing was not measured. + +### Impact + +- B2 is not met: a drawing can resolve into another view of the page (paint servers, + filters, masks, clip paths). Into the page itself the reach is theoretical today: no + page-level SVG resource with an id exists in `apps/app/src` (the brand logos are loaded + as `` or rasterised, not inlined). Visual only, no fetch, no script. +- B1 is not met: a reference to an id the drawing does not define is accepted when spelled + this way. +- The R3 expansion budget is bypassed. An editor uploads under 5 KB, the verdict and the + preview say `ok`, the reviewer's or any practitioner's tab freezes when the view draws. + The PDF export rasterises the same view. +- The budget bypass exists at 17d9199 (the old `urls_are_local` is the same). The diff does + not create it, but B1 and B2 are written to close exactly this class and rest on the same + reader, so they ship with the hole. + +### Fix direction (no code written, report only) + +1. Make the sanitiser the authority. In `urls_are_local` (or a new check called first in + `value_acceptable`), require for every `url(`: CSS space, optional quote, `#`, one id + that satisfies `is_reference_name` (first character `[A-Za-z_]`), then space, the same + quote if one was opened, and `)`. Anything else is non-local and therefore active + (rejected), which also removes `url(#)`. Then the set the sanitiser admits and the set + `url_targets` reads are the same by construction. +2. Fail closed in the composer: after `scope_ids`, walk the composed tree and refuse the + canvas (`ComposeError`) when a `url(` target does not start with the view scope, or an + `href` does not start with `#fv..`. A future reader divergence then cannot produce + an unscoped reference silently. +3. Tests with an independent oracle: for every accepted value, normalise the way the URL + Standard does (strip tab and newline, percent-decode the fragment) and assert it equals + the `url_targets` list; cases `url(#%61)`, `url(#%66v.x.g)`, `url('#a')`, `url(#)`, + `url(#é)`, `url(#a%2Eb)` (allowed only if the first character rule holds). +4. After the fix, correct the statements that are false today: docs/development/ + V1-2_ANATOMICAL_SHEETS.md §9.2 and §10 ("a reference resolves only inside its own view"), + docs/development/RUST.md, docs/ANNOTATION-RENDERING.md. + +## 2. Reported findings + +- MEDIUM, scope key. `id_scope` (compose.rs:92) is `fv..`. View ids are unique inside + one document, not across sheets. A catalogue grid, a comparison or a preview next to the + editor puts two `main` canvases in one page; ids collide and `getElementById` takes the + first. Sheet B can then draw with sheet A's gradient or mask. Not verified against the + V1-2.3+ screens (they are not in this diff). Add a per-handle token, or state in §10 that + one sheet is mounted at a time. +- LOW, colour function. `without_colour_functions` (:547) removes a strict `rgb()` anywhere in + the text. Probed: 19 hostile values around a colour (`url(http://…)`, `expression(`, + `image-set(`, `src(`, `cross-fade(`, `\72`, `/**/url(//…)`, `behavior:`, `@import`, `var(`, + `attr(`, `element(`, `-moz-element(`, `paint(`, `RGB(`, nested `url(#a)` as an argument) are + all refused or removed. The remaining looseness is cosmetic: `rgb(1,2,3)rgb(4,5,6)` and + `url(#a rgb(1,2,3))` pass and are invalid CSS (bad-url token), dropped by the browser. +- LOW, test oracle. See table line above. +- LOW, lint allow and mutation script. See table lines above. + +## 3. What was attacked and held + +- Colour exception, `smuggle url(`, `expression(`, escape, `image-set(`, fetch: a backslash is + refused for every attribute before the colour code runs; `style_forbidden` runs on the + original text; a `(` that is neither a local `url(#` nor a strict colour function stays and + refuses the value. The colour parser admits only ASCII digits, `.`, `%`, comma, CSS space + and `)` between `rgb(` and the end, so nothing can hide inside it. `glued` blocks `xrgb(`, + `-rgb(`, `\rgb(`. Uppercase is refused (safe side). No index can leave the slice + (`digits(end + 1)` only after a `.` at `end`; `index += 1` only after a matched separator). + Probe table: 17 `fill` and 5 `style` values (19 hostile, 3 valid controls), all as expected. +- Parsing cost, measured through the built module, attribute values near 2 MiB: `rgb(1,2,3)` + x150k 132 ms, `rgb(` x400k 35 ms, `rgb(1,` x300k 37 ms, `rgb(` plus 1.9M spaces 26 ms, plus + 1.9M digits 23 ms, mixed spacing 84 ms, `url(#` x400k 97 ms, `url(` x400k 15 ms. By reading: + each failed colour attempt scans one run of digits and spaces that cannot contain `rgb`, + and `from` always advances at least 3. +- `check_targets`, `scope_ids`, `references_resolve`: one pass, recursion bounded by the + prescan depth cap 64, one `HashSet`. Scoped output is bounded by the budget (50,000 + references) plus 20,000 ids, then by `MAX_COMPOSED_BYTES` (4 MiB) after serialisation. +- Scoping, spellings: `url( '#x')`, `URL(#x)`, newline and tab before `#` or the quote, + and `.` in ids all go through the same `url_openings` / `skip_url_prefix` for the checker + and the composer, so they agree with each other (the unit test at sanitize.rs:715 covers it). + `href` and `xlink:href` are strict (`#` + reference name after ASCII trim), so a `%`, a tab or + an odd prefix cannot be kept: a prefixed `x:href` is not on the allowlist and the + `xlink:href` must be in the xlink namespace. View ids match `[a-z0-9][a-z0-9_-]{0,63}` + (js.rs:158, enforced at deserialisation), so no `.` in a view id and one scope is never the + start of another's. The layer has no `id`, `href` or `url(`. +- Checker versus composer, same reading: `reference_ids` (all attributes through `url_targets`, + `href` / `xlink:href` apart) and `scope_ids` (same set, `id` added) differ only on `id`, + which cannot hold `(`. No attribute is rewritten and unread, or read and unrewritten. + The one divergence is browser against both (finding 1). +- Stored form: verdict (verdict.rs:323) and preview (preview.rs:119) compare the whole text + with `stored_form(root)` after a removal-free read, so a comment, CDATA, entity, PI, BOM, + another declaration or spacing cannot reach a round; the sha256 is checked first. The + upload tool (upload.rs) and `clean_svg` do the same. Compose works on the sanitised tree, + never on stored text. The `xmlns:xlink` value is unchecked but inert (a rebinding drops the + xlink attributes that depend on it). +- `sheet.edit remove` (edit.rs:570): `dependents` runs after `locate`, before any mutation, + so a refusal leaves the document unchanged; it is a client rule, no authorisation change. +- Checklist greps on the added lines (secrets, SQL built by concatenation, innerHTML / eval / + raw, logging, tracked `.env`): nothing. Guardrails scanner: 0 FAIL, 28 WARN, all in + migrations the diff does not touch, so none kept (gate rule). + +## 4. Not done, and limits + +- semgrep did not run. The three packs come from the registry and the brief says no network. + The Rust surface of those packs is thin; the manual review above is the substitute, it is + not equivalent. +- WebKit was not probed; the Firefox DoS time was not measured; the `` form is + Chromium only. +- Probes ran headless browsers on local files and Node on the built module. No cargo, wasm or + Docker build was started (the `check:all` in the worktree was left alone). The probe files + (HTML pages, screenshots, two Node scripts, a Firefox profile) sit in the session + scratchpad `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/0cee2841-f2bb-4081-9e59-3e6fe9cc8112/scratchpad/probe-audit`; + the `rm -rf` that would have removed them was refused by the permission rules and was not + retried by another route. Nothing was written in the worktree besides this report; `git + status` there shows only this file and the owner's `exports/owner/README.md`. +- The verdict runs in the core, client or worker side; the SQL side cannot check the stored + form. That trust boundary is outside this diff. diff --git a/.claude/audits/2026-10-29-v1-2-2-mutations-arbitrations.py b/.claude/audits/2026-10-29-v1-2-2-mutations-arbitrations.py index a21c8902..b203c533 100644 --- a/.claude/audits/2026-10-29-v1-2-2-mutations-arbitrations.py +++ b/.claude/audits/2026-10-29-v1-2-2-mutations-arbitrations.py @@ -1,4 +1,4 @@ -# V1-2.2 owner arbitrations, mutation run (evidence .claude/audits/2026-10-29-v1-2-2-evidence.md §7): each +# V1-2.2 owner arbitrations, mutation run (evidence .claude/audits/2026-10-29-v1-2-2-evidence.md §7 (A1-A12 on 5281337, A13-A17 after the security review)): each # mutant is applied to its source file, its cargo suite runs (`lib` = the crate's unit tests), the file is # restored. Run from the repo root. import subprocess @@ -15,6 +15,11 @@ muts=[ ('A10 glued name accepted','crates/core/src/anatomy/svg/sanitize.rs',' _ if glued => return None,',' _ if false && glued => return None,','lib'), ('A11 mixed units accepted','crates/core/src/anatomy/svg/sanitize.rs',' _ if *percentages.get_or_insert(percent) != percent => return None,',' _ if *percentages.get_or_insert(percent) != percent && false => return None,','lib'), ('A12 rgba with three components','crates/core/src/anatomy/svg/sanitize.rs',' _ if rest.starts_with("rgba(") => (4, 5),',' _ if rest.starts_with("rgba(") => (3, 5),','svg_clean'), + ('A13 quote left unmatched','crates/core/src/anatomy/svg/sanitize.rs',' if bytes.get(index) != Some("e) {\n return None;\n }\n index += 1;',' if bytes.get(index) == Some("e) {\n index += 1;\n }','svg_clean'), + ('A14 any id after #','crates/core/src/anatomy/svg/sanitize.rs',' if !is_reference_name(&value[id_start..id_end]) {',' if false {','svg_clean'), + ('A15 glued url( read as url(','crates/core/src/anatomy/svg/sanitize.rs',' if !glued {\n return Some(from);',' if true || !glued {\n return Some(from);','svg_clean'), + ('A16 colour glued to what follows','crates/core/src/anatomy/svg/sanitize.rs',' ends.then_some(at + index)',' Some(at + index)','svg_clean'), + ('A17 percent-escaped id read as local','crates/core/src/anatomy/svg/sanitize.rs'," .take_while(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b':' | b'-'))"," .take_while(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b':' | b'-' | b'%'))",'svg_scope'), ] for name,path,old,new,suite in muts: src=open(path).read() diff --git a/.claude/tasks/contracts/2026-10-29-v1-2-2-core.md b/.claude/tasks/contracts/2026-10-29-v1-2-2-core.md index cb8a2444..c354942a 100644 --- a/.claude/tasks/contracts/2026-10-29-v1-2-2-core.md +++ b/.claude/tasks/contracts/2026-10-29-v1-2-2-core.md @@ -93,3 +93,15 @@ Brief « V1-2.2 : arbitrages du propriétaire et finalisation » on `17d9199`. D - B7 Wasm: `--remove-name-section` only; the 600 000-byte cap and `size.test.ts` unchanged. - B8 Still: no SQL change, no protected reader modified (A13), the N-1 copies and frozen oracle files untouched (declared changes applied in tests only), no DEV operation, no merge. + +### After the reviews of 5281337 (security BLOCK(1) HIGH, verifier ECARTS(2)) + +Delta under review: `5281337..HEAD`. + +- B9 A `url(` is kept only in its strict spelling (`sanitize::local_url_target`); every other spelling a browser could + normalise (`%XX`, tab, space or unbalanced quote inside, empty or non-ASCII id) is active content; `url(` or `rgb(` + glued to a longer name (ASCII or not) is another function; a colour is not glued to what follows; the composer refuses, + fail-closed, a canvas keeping a reference outside its scope (`unscoped_reference`). Tests written apart from the reader + (`svg_clean::every_url_spelling_but_the_strict_one_is_refused`, `svg_scope::every_reference_a_browser_reads_stays_in_its_view`). +- B10 The verifier's doc drift fixed (RUST.md §12.1, §12.4, §12.5, §12.6; exports README); the MEDIUM (scope unique per + document only) recorded as a requirement for any page inlining two documents (contract §10, RUST.md §12.7). diff --git a/crates/core/src/anatomy/compose.rs b/crates/core/src/anatomy/compose.rs index 593e1808..0ceb4739 100644 --- a/crates/core/src/anatomy/compose.rs +++ b/crates/core/src/anatomy/compose.rs @@ -15,7 +15,7 @@ use std::collections::HashSet; use super::layer::{LayerError, find_view, render_layer, view_box_of}; -use super::svg::sanitize::{local_reference_text, scope_url_targets}; +use super::svg::sanitize::{local_reference_text, scope_url_targets, url_targets, urls_are_local}; use super::svg::serialize::is_xml_text; use super::svg::{Element, Node}; use crate::domain::sheet::AnatomicalSheetDocument; @@ -31,6 +31,9 @@ pub enum ComposeError { UnknownView, /// A label or a path of the layer holds a code point XML 1.0 cannot carry. InvalidCharacter, + /// A reference of the drawing kept outside its view's scope after scoping (fail-closed: + /// the reader keeps no such reference, so this never happens on a read drawing). + UnscopedReference, } impl From for ComposeError { @@ -81,7 +84,11 @@ pub fn compose_canvas( .or_else(|| asset.attr("viewBox").map(str::to_owned)) .unwrap_or_else(|| CANVAS_FALLBACK_VIEW_BOX.to_owned()); root.set_attr("viewBox", view_box); - scope_ids(&mut root, &id_scope(view_id)); + let scope = id_scope(view_id); + scope_ids(&mut root, &scope); + if !references_scoped(&root, &scope) { + return Err(ComposeError::UnscopedReference); + } let layer = render_layer(document, view_id, &HashSet::new())?; root.children.push(Node::Element(checked(layer)?)); Ok(root) @@ -93,6 +100,27 @@ pub fn id_scope(view_id: &str) -> String { format!("fv.{view_id}.") } +/// Every `href` / `xlink:href` names `#…`, and every value holding `url(` holds only +/// local references whose ids start with `scope`. +fn references_scoped(element: &Element, scope: &str) -> bool { + let attrs_scoped = element.attrs.iter().all(|attr| match attr.qname.as_str() { + "href" | "xlink:href" => local_reference_text(&attr.value) + .strip_prefix('#') + .is_some_and(|id| id.starts_with(scope)), + _ if attr.value.to_ascii_lowercase().contains("url(") => { + urls_are_local(&attr.value) + && url_targets(&attr.value) + .iter() + .all(|id| id.starts_with(scope)) + } + _ => true, + }); + attrs_scoped + && element + .element_children() + .all(|child| references_scoped(child, scope)) +} + /// Every `id`, every local `href` / `xlink:href` and every `url(#id)` of the drawing, with /// `scope` written in front of the id. fn scope_ids(element: &mut Element, scope: &str) { diff --git a/crates/core/src/anatomy/svg/sanitize.rs b/crates/core/src/anatomy/svg/sanitize.rs index 31f6ea39..ff4903cb 100644 --- a/crates/core/src/anatomy/svg/sanitize.rs +++ b/crates/core/src/anatomy/svg/sanitize.rs @@ -453,75 +453,93 @@ pub fn is_reference_name(value: &str) -> bool { && chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | ':' | '-')) } -/// Byte offsets right after each case-insensitive `url(`. +/// A character that continues a CSS identifier before a function name: `xurl(` or `érgb(` is +/// another function, never `url(` or `rgb(` (V1-2.2 reviews). +fn continues_identifier(c: char) -> bool { + c.is_ascii_alphanumeric() || matches!(c, '_' | '-' | '\\') || !c.is_ascii() +} + +/// Byte offsets right after each case-insensitive `url(` that is not the end of a longer +/// function name. fn url_openings(value: &str) -> impl Iterator + '_ { let lower = value.to_ascii_lowercase(); let mut from = 0; std::iter::from_fn(move || { - let at = lower.get(from..)?.find("url(")? + from; - from = at + 4; - Some(from) + loop { + let at = lower.get(from..)?.find("url(")? + from; + from = at + 4; + let glued = value[..at] + .chars() + .next_back() + .is_some_and(continues_identifier); + if !glued { + return Some(from); + } + } }) } -/// After `url(`: whitespace, an optional quote, whitespace; returns the offset of the next -/// character. Only CSS whitespace is skipped, as the browser's CSS tokenizer skips it: the -/// engine skipped JavaScript spaces, so a no-break space before `#a` read as local but the -/// browser resolves it as a relative URL (security audit R3, pass 2). -fn skip_url_prefix(value: &str, at: usize) -> usize { - let rest = &value[at..]; - let mut chars = rest.char_indices().peekable(); - let skip_space = |chars: &mut std::iter::Peekable>| { - while chars.peek().is_some_and(|&(_, c)| is_css_space(c)) { - chars.next(); - } - }; - skip_space(&mut chars); - if chars.peek().is_some_and(|&(_, c)| c == '\'' || c == '"') { - chars.next(); +/// A local reference after the `url(` opening ending at `at`, read as strictly as the reader +/// keeps it (owner decision 2026-10-29 and its security review): CSS whitespace, an optional +/// quote, `#`, an id in the reference grammar, the same quote, CSS whitespace, `)`. Anything a +/// browser could read differently (`%61`, a tab or a space inside the quotes, an empty or +/// non-ASCII id, an unbalanced quote) is not local. Answers the id's byte range in `value`. +fn local_url_target(value: &str, at: usize) -> Option<(usize, usize)> { + let bytes = value.as_bytes(); + let mut index = skip_css_spaces(bytes, at); + let quote = bytes + .get(index) + .copied() + .filter(|b| matches!(b, b'\'' | b'"')); + index += usize::from(quote.is_some()); + if bytes.get(index) != Some(&b'#') { + return None; } - skip_space(&mut chars); - at + chars.peek().map_or(rest.len(), |&(i, _)| i) + let id_start = index + 1; + let id_len = value[id_start..] + .bytes() + .take_while(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b':' | b'-')) + .count(); + let id_end = id_start + id_len; + if !is_reference_name(&value[id_start..id_end]) { + return None; + } + index = id_end; + if let Some(quote) = quote { + if bytes.get(index) != Some("e) { + return None; + } + index += 1; + } + index = skip_css_spaces(bytes, index); + (bytes.get(index) == Some(&b')')).then_some((id_start, id_end)) } -/// The ids of the value's `url(#id)` references, in order. +/// The ids of the value's local `url(#id)` references, in order. pub fn url_targets(value: &str) -> Vec { url_openings(value) - .filter_map(|at| value[skip_url_prefix(value, at)..].strip_prefix('#')) - .map(|rest| { - rest.chars() - .take_while(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | ':' | '-')) - .collect::() - }) - .filter(|id| !id.is_empty()) + .filter_map(|at| local_url_target(value, at)) + .map(|(start, end)| value[start..end].to_owned()) .collect() } -/// The value with `scope` written after the `#` of each `url(#id)` that `url_targets` reads -/// (a non-empty id), everything else kept byte for byte. +/// The value with `scope` written in front of the id of each local `url(#id)` that +/// `url_targets` reads, everything else kept byte for byte. pub fn scope_url_targets(value: &str, scope: &str) -> String { let mut out = String::with_capacity(value.len()); let mut kept_from = 0; - for at in url_openings(value) { - let next = skip_url_prefix(value, at); - let named = value[next..].strip_prefix('#').is_some_and(|rest| { - rest.starts_with(|c: char| { - c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | ':' | '-') - }) - }); - if named { - out.push_str(&value[kept_from..=next]); - out.push_str(scope); - kept_from = next + 1; - } + for (start, _) in url_openings(value).filter_map(|at| local_url_target(value, at)) { + out.push_str(&value[kept_from..start]); + out.push_str(scope); + kept_from = start; } out.push_str(&value[kept_from..]); out } -/// Every `url(` in the value points inside the document (`url(#…)`). -fn urls_are_local(value: &str) -> bool { - url_openings(value).all(|at| value[skip_url_prefix(value, at)..].starts_with('#')) +/// Every `url(` in the value is a local reference (`local_url_target`). +pub fn urls_are_local(value: &str) -> bool { + url_openings(value).all(|at| local_url_target(value, at).is_some()) } /// No `(` once the `url(#` openings and the strict colour functions are taken out. @@ -529,10 +547,12 @@ fn calls_only_local_url(value: &str) -> bool { let mut cut = String::with_capacity(value.len()); let mut kept_from = 0; for at in url_openings(value) { - let next = skip_url_prefix(value, at); - if value[next..].starts_with('#') { + if let Some((_, id_end)) = local_url_target(value, at) { cut.push_str(&value[kept_from..at - 4]); - kept_from = next + 1; + cut.push(' '); + kept_from = value[id_end..] + .find(')') + .map_or(value.len(), |i| id_end + i + 1); } } cut.push_str(&value[kept_from..]); @@ -569,7 +589,7 @@ fn colour_function_end(text: &str, at: usize) -> Option { let glued = text[..at] .chars() .next_back() - .is_some_and(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '-' | '\\')); + .is_some_and(continues_identifier); let rest = &text[at..]; let (components, open) = match () { _ if glued => return None, @@ -600,7 +620,10 @@ fn colour_function_end(text: &str, at: usize) -> Option { } index += 1; } - Some(at + index) + // The function is a whole value of a list or a declaration, never glued to what follows. + let after = bytes.get(index).copied(); + let ends = after.is_none_or(|b| is_css_space(char::from(b)) || matches!(b, b';' | b',' | b'!')); + ends.then_some(at + index) } fn skip_css_spaces(bytes: &[u8], mut index: usize) -> usize { diff --git a/crates/core/src/ops.rs b/crates/core/src/ops.rs index db4513f9..0607f3b0 100644 --- a/crates/core/src/ops.rs +++ b/crates/core/src/ops.rs @@ -477,6 +477,7 @@ fn canvas_of<'a>( let canvas = compose_canvas(document, view_id, drawing).map_err(|e| match e { ComposeError::UnknownView => Failure::new("unknown_view", view_id), ComposeError::InvalidCharacter => Failure::new("invalid_character", view_id), + ComposeError::UnscopedReference => Failure::new("svg_rejected", "unscoped_reference"), })?; let svg = serialize(&canvas); if svg.len() > MAX_COMPOSED_BYTES { diff --git a/crates/core/tests/fixtures/svg/exports/README.md b/crates/core/tests/fixtures/svg/exports/README.md index 88f25902..66f39585 100644 --- a/crates/core/tests/fixtures/svg/exports/README.md +++ b/crates/core/tests/fixtures/svg/exports/README.md @@ -6,7 +6,7 @@ None is edited by hand. | File | Tool | How | Expected | |---|---|---|---| -| `cairo-1.18.4-pycairo-1.27.0-shapes.svg` | cairo 1.18.4 through pycairo 1.27.0 | `generate.sh`: curves, gradient, dash, clip, alpha, text as glyph paths | read with no removal: its colours are written `rgb(20%, 40%, 70%)`, the strict numeric colour function the reader keeps since the owner's decision of 2026-10-29 (before it, the four colours were removed) | +| `cairo-1.18.4-pycairo-1.27.0-shapes.svg` | cairo 1.18.4 through pycairo 1.27.0 | `generate.sh`: curves, gradient, dash, clip, alpha, text as glyph paths | read with no removal: its colours are written `rgb(20%, 40%, 70%)`, the strict numeric colour function the reader keeps since the owner's decision of 2026-10-29 (before it, the five colours were removed) | | `cairo-1.18.4-pycairo-1.27.0-raster.svg` | same | `generate.sh`: an 8 × 8 image surface painted | refused, `svg_active_content` (an embedded raster ``) | | `inkscape-1.4.3-inkscape-svg.svg` | Inkscape 1.4.3 (0d15f75042, 2025-12-25) | `generate-inkscape.sh`: `inkscape-source.svg` opened and exported as Inkscape SVG (`--export-type=svg`) | cleanable: `sodipodi:namedview`, the editor namespaces, `sodipodi:docname`, `xmlns:svg` and the `text` element removed and named; shapes, gradient, clip path, references and colours kept | | `inkscape-1.4.3-plain-svg.svg` | same | `generate-inkscape.sh`: Plain SVG (`--export-plain-svg`) | cleanable: `xmlns:svg` and `text` removed | diff --git a/crates/core/tests/fixtures/svg/exports/owner/README.md b/crates/core/tests/fixtures/svg/exports/owner/README.md index 02b94698..fea7d62d 100644 --- a/crates/core/tests/fixtures/svg/exports/owner/README.md +++ b/crates/core/tests/fixtures/svg/exports/owner/README.md @@ -1 +1,47 @@ Owner-supplied editor exports land here (see ../README.md). + +# What to export (A6, contract §9.2 and §15) + +One small drawing per tool, made in that tool, never retouched by hand afterwards. Same +reference content as `../inkscape-source.svg`, so the results compare: + +- an outline with a curve, filled with a two-stop linear gradient, a 2 px dashed stroke; +- an ellipse with a flat colour; +- a rounded rectangle at 50 % opacity; +- the whole group clipped by a rectangle (Illustrator: clipping mask; Figma: a frame with + « Clip content »); +- the word « Garrot » as live text. + +Artboard or frame 200 × 150 px. Note the exact version (Illustrator: Aide › À propos +d'Illustrator; Figma: menu › Aide › À propos de Figma, or the desktop app's version). + +## Illustrator + +1. Fichier › Exporter › Exporter sous… › format SVG (`svg`), « Utiliser les plans de travail » + ticked. +2. Options SVG, two files: + - `illustrator--export-as.svg`: Style « Attributs de présentation », Police + « Vectoriser », Images « Incorporer », ID d'objet « Noms de calques », Décimales 2, Minifier + off, Responsive on; + - `illustrator--internal-css.svg`: the same with Style « CSS interne » (the export + most users keep by default; expected cleanable, its `