Files
faunosteo/.claude/audits/2026-10-23-rust-r5-review-security-7.md

9.8 KiB
Raw Permalink Blame History

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 (&amp, &#, 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.