fix(anatomy): V1-2.2 read url() references in their strict spelling only

Security review BLOCK(1): url(#%61) passed the dangling check and the
per-view scoping and resolved in browsers. One strict reading now, other
spellings are active content; glued names are other functions; the
composer refuses an unscoped reference; owner export procedure.
This commit is contained in:
bchanot committed 2026-10-29 16:49:15 +01:00
1 parent 5281337412
commit a678faaa23
13 files changed
+553 -70

No files matched your search

@@ -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('#<TAB>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 `<linearGradient id="g"/>` gives `clean`.
2. Same module, `PreviewBuilder` on the equine draft document with that drawing as the
horse asset, `view.canvas`:
- view `main`: `<linearGradient id="fv.main.g"/>` and `<rect fill="url(#%66v.main.g)">`.
- view `head`: `<linearGradient id="fv.head.g"/>` and `<rect fill="url(#%66v.main.g)">`.
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('#<TAB>a')` (`&#9;`) | 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 `<img>` 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.<view>.`. 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('#<TAB>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 id>.`. 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 `<TAB>` 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.
@@ -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(&quote) {\n return None;\n }\n index += 1;',' if bytes.get(index) == Some(&quote) {\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()
@@ -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).