# Security gate R5.4 (round 7): review files in Rust Branch `feature/rust-r5-pipeline-core`, HEAD `777c800`. Scope: `git diff c6e0d85..HEAD -- crates/core packages/anatomy/tests docs/development/RUST.md` (26 files). Blind, complete scan. No prior verdict was read. ``` SECURITY — VERDICT: BLOCK(2) TOOL: semgrep 1.168.0 — p/security-audit, p/secrets, p/owasp-top-ten SCOPE: 26 files BLOCKING: 1. [HIGH] resource-bound/output-amplification — crates/core/src/curation/draft/changelog.rs:68 (record_row), :116-119 (table built whole); crates/core/src/curation/markdown.rs:52-63 (table), :139-159 (bound checked after the raw rows exist); crates/core/src/curation/draft/pipeline.rs:247-252; docs/development/RUST.md:3206 — the CHANGELOG raw table (rows × authored rationale/title) is fully built, joined and split before MAX_TABLE_COLUMNS_TOTAL is checked, so the declared case "80 KB rationale over 14,000 records" still exhausts memory: a 1.9 MB changes.json aborts at a 3 GB address-space cap; RUST.md's "refused before any row is built" is false — hint: bound before render_changelog builds a row (project rows × widest authored cell per level from the records, or cap the raw length while table() accumulates), and pin it with a pipeline-level test (build + render of the declared case under a memory ceiling), not format_markdown on a hand-built table 2. [HIGH] resource-bound/record-amplification — crates/core/src/curation/draft/ops.rs:197 (rename), :384 (remove); crates/core/src/curation/draft/records.rs:18-28 (out of diff, same pipeline) — every rename/remove record deep-copies the whole item (before and after) and every record clones the ChangeSummary (title, rationale, question); MAX_DOCUMENT_VALUES (200,000) bounds the document after an op, never the sum of the records: an 810 KB changes.json (one 5,000-child add, 400 renames back and forth) reaches 4.3 GB RSS at build, linear at ~10.7 MB per rename; ~1,400 renames exceed the 15 GB dev machine; R5.4's CHANGELOG then serialises each whole item again (compact_value) — hint: bound the records (total values or bytes recorded, checked as each record is pushed, refused with Guard) or record ids/paths and share the ChangeSummary (index or Rc) instead of cloning REPORTED (non-blocking): - [LOW] new lint relaxation `#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]` — crates/core/tests/curation_markdown.rs:6, crates/core/tests/curation_review.rs:6 (integration tests only, same line as every existing test file; not a security-rule suppression) - [LOW] pre-existing suppression `#![allow(clippy::disallowed_methods)]` — crates/core/src/bin/import_equine.rs:17 (the tool's declared I/O file, context) - [LOW] error echo size — crates/core/src/curation/report_guard.rs:29-31 (UnsupportedMarkdown carries the whole refused line, multi-MB on stderr; authored content, no secret) - [LOW] subfolder race — crates/core/src/bin/import_equine.rs:353-389 (write_exclusive re-checks the claimed root only, not the subfolders this run created; same-user swap, declared out of model in RUST.md §11.13; unchanged by this diff) PROOF: semgrep 128 rules on 26 files → 0 findings; checklist 12 checks → 6 findings (2 HIGH, 4 LOW) ``` ## Checklist detail | Check | Result | |---|---| | Hardcoded secret, token, key, credentialed URL | none in the added lines | | SQL by concatenation | none (no SQL in the diff) | | Unsanitized render (innerHTML, eval, raw) | none | | Sensitive endpoint without authz | not applicable (offline CLI and pure core) | | Stack trace or internal path to a user | none (CLI messages to the operator) | | Secret or PII in a log | none; `println!` lines print file names and counts | | Tracked `.env` or credential file | only `.env.example` tracked | | guardrails `scan.py --domain api,supabase` | 0 FAIL, 1 WARN (`SB-POLICY-NOT-OWNER`, `supabase/migrations/20261008110000_anatomical_sheets.sql:1177`, outside the diff: dropped) | | Anti-gaming (new suppressions) | two test-file lint allows, convention of all test files, LOW | | Report structure forgery (sections, list items, code spans, links, HTML) | held, see below | | SVG well-formedness and injection | held: serializer escapes `& < > "` and CR/TAB/LF in attributes, `first_unwritable` refuses non-XML-1.0 code points and CR, element and attribute names are fixed, no href or event attribute written | | Resource bounds and file safety | 2 HIGH (above); quadratic scans and `--out`/`--check` held, see below | ## Finding 1: CHANGELOG raw table amplified before its bound `render_changelog` builds one row per record, each carrying the change's title and rationale (`changelog.rs:89`, `:94`). `table()` joins every row, wraps it, and joins again. `format_report` then guards each line, and `align` splits every row into owned strings. Only after all of that does it compare `row_width × rows` with `MAX_TABLE_COLUMNS_TOTAL`. So the bound caps the padded copy only. The raw table, which already holds N × R bytes, gets built four to five times first. Measured with the full pipeline (`build_equine_draft` + `render_draft_artifacts` on the real legacy sources and the committed changeset, plus one appended change of `set` ops): | changes.json | rationale × set ops | Result | |---|---|---| | 545 KB | 20 KB × 3,000 | Guard refusal, peak 373 MB | | 506 KB | 100 KB × 2,000 | Guard refusal, peak 1.19 GB | | 1.04 MB | 400 KB × 4,000 | `memory allocation failed`, signal 6, at the 6 GB cap | | 1.92 MB | 80 KB × 14,000 (the case RUST.md declares held) | `memory allocation failed`, signal 6, at the 3 GB cap | The 16 MiB read cap allows inputs of hundreds of GB of raw table. Without a ulimit the process grows until the OOM killer acts. The failure is fail-closed: `folders()` finishes before `claim_destination`, so nothing gets written. The impact is availability of the developer machine, and that includes `--check`. The test `an_aligned_table_past_the_bound_is_refused_before_it_is_built` calls `format_markdown` on a table it built by hand, so it cannot see the pipeline's allocation. ## Finding 2: records deep-copy whole items `ChangeRecord` keeps a `ChangeSummary` clone plus deep copies of `before` and `after`, and for a rename or remove those copies are the whole item (`records.rs:18`). An `add` of a 5,000-child category followed by N renames that swap its id back and forth gives: | renames | build-only RSS | |---|---| | 0 | 56 MB | | 100 | 1.13 GB | | 200 | 2.20 GB | | 400 | 4.34 GB (810 KB changes.json) | `MAX_DOCUMENT_VALUES` is checked on the document after each op, not on what the records accumulate. The cloning lines are R5.3 code, but they sit in a file of this diff (`ops.rs`, whose `apply_rename` the diff modifies), and the R5.4 renderers consume every record. The TypeScript had the same amplification but V8's heap limit stopped it with a clean error. The Rust process has no such ceiling. ## What held Markdown guard. I ran a differential of `report_guard::format_report` (Rust) against Prettier 3.8.3 `format(…, parser: 'markdown')` with the repository options, on raw reports shaped like the generator's output: list items with title, rationale and question, CHANGELOG rows with `cell()` applied, bibliography and decision lines. Authored texts followed the same preconditions as the code (no backtick; no control character or wiki/liquid bracket in list items). Results: - 201,000 random probes over the admitted alphabet plus adversarial tokens (`&`, `&#`, URL starts, `**`, `_`, `\`, brackets, wide and zero-width characters). 20,969 were admitted and 0 diverged. - 960 targeted probes: reference-style links with a space, `[a]: b` mid-line, `1.`, `#`, `+`, `>` at a cell start, bare URLs with `_`, `)`, `&`, `x@y`, `**é**`, `a\|b` outside tables, `<3`, `<-`. 689 were admitted and 0 diverged. None of these forged a section, list item, code span, link or HTML. A newline in a list-item field is refused, and table cells turn newlines into spaces. The guard's scans stayed linear: 18 lines of 4 MB with 20,000 code spans each ran in 1.19 s. `--check` and `--out`: - `compare_file` falls back on trees only for `review/app-*` with the declared rule. `compare_drawing` returns an error with no rule, requires the committed file to rebuild byte for byte from its tree, and requires the rule to change it. - `inside_by_identity` now fails closed with an explicit error. - Reads stay canonical-inside-seed, regular-file-only and capped at 16 MiB. - Written names are `Component::Normal` only, and view ids are stable ids. - Writes use `create_new`, and the existing destination is identity-checked against the seed. SVG: `drawing_text` refuses unwritable text, and the overlay and the app layer only emit fixed element and attribute names. Depth is bounded by the core reader's prescan before `first_difference` or `TriggerNames::apply` recurse. ## Probes (scratchpad only, no tracked change, nothing deleted) - `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/probe/src/main.rs` (guard probe), `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/probe/src/bin/amp.rs` (pipeline memory probe; `BUILD_ONLY=1` stops after the build) - `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/scripts/fuzz.py`, `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/scripts/targeted.py`, `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/scripts/prettier.mjs` - `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/scripts/mkchg.py` (finding 1 inputs), `/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/scripts/mkren.py` (finding 2 inputs) Memory probes ran under `ulimit -v` (3 to 6 GB). Cargo built into a scratchpad `CARGO_TARGET_DIR`. `git status` stayed clean at `777c800`.