Files
faunosteo/.claude/audits/2026-10-23-rust-r5-draft-security-final2.md

212 lines
12 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Security gate (fresh): R5.3 draft port, final 2
Branch `feature/rust-r5-pipeline-core`, HEAD `314cf04`, scope `git diff 5e114da..HEAD`
(32 files), focus on `9f11499`. Fresh run: no earlier verdict consulted.
```
SECURITY — VERDICT: PASS
TOOL: semgrep 1.168.0 — p/security-audit, p/secrets, p/owasp-top-ten
SCOPE: 32 files
BLOCKING:
(none)
REPORTED (non-blocking):
- [MEDIUM] resource-cap/memory-amplification — crates/core/src/curation/draft/records.rs:68
- [LOW] resource-cap/cpu-quadratic — crates/core/src/curation/draft/apply.rs:109
- [LOW] check-follows-symlinks — crates/core/src/bin/import_equine.rs:148
- [LOW] out-toctou-residual — crates/core/src/bin/import_equine.rs:203
- [LOW] write-exclusive-components — crates/core/src/bin/import_equine.rs:246
- [LOW] silent-input-normalisation — crates/core/src/bin/import_equine.rs:66
- [LOW] test-targets-real-seed — crates/core/tests/curation_draft.rs:681
- [LOW] suppression-context (new, test crate, documented policy) — crates/core/tests/curation_draft.rs:7
- [LOW] suppression-context (pre-existing) + lint list gaps — crates/core/src/bin/import_equine.rs:15
PROOF: semgrep 129 rules on 32 files → 0 findings; checklist 10 checks → 9 findings
```
## Tool notes
- semgrep 1.168.0, pinned packs only, `--metrics=off`. The first run died inside semgrep-core
(`io_uring_queue_init: Cannot allocate memory`, sandbox memlock limit). The rerun with
`EIO_BACKEND=posix` scanned all 32 files: 0 errors, 129 rules run (163 loaded), 0 findings.
- These packs carry almost no Rust rules. The Rust analysis below therefore rests on a full
read of every changed product file plus runtime probes, not on semgrep.
- Guardrails scanner (`api,supabase`): 0 FAIL, 1 WARN (`SB-POLICY-NOT-OWNER` in
`supabase/migrations/20261008110000_anatomical_sheets.sql`, outside the diff, dropped).
## Checklist
| # | Check | Result |
|---|---|---|
| 1 | Hardcoded secret, token, key, auth URL (diff incl. docs, `.claude`, oracle JSON) | none (only `https://example.org/a`) |
| 2 | SQL by concatenation / interpolation | none: `seed.rs` interpolates constants only, `sql_text` doubles quotes, the document goes into `$equine_doc$…$equine_doc$`, and a document holding the tag is refused. The trimmed document always ends with `}`, so no prefix of the tag can join the closing tag. `config.toml` `sql_paths` lists literal files, so an `--out` under `supabase/seed/` is never executed by `db reset` |
| 3 | Unsanitised render / `eval` | none (no rendering; the TS oracle test has no sink) |
| 4 | Sensitive endpoint without authz | N/A (dev tool, no endpoint) |
| 5 | Stack trace / internal path to end users | none (operator CLI only) |
| 6 | Secret / PII in a log | none |
| 7 | Tracked `.env` / credential file | none (`.env.example` only, outside the diff) |
| 8 | Guardrails scanner | 0 findings in diff files |
| 9 | New suppressions (anti-gaming) | no `nosemgrep` / `nosec` / `eslint-disable` / `ts-ignore` / `noqa`; one clippy allow (L7) |
| 10 | Brief-specific: seed protection, `--check` read-only, `--out` semantics, caps, strict validation, author data | M1, L1 to L6 |
## Findings
### M1 [MEDIUM] No memory cap: hostile `changes.json` amplifies about 10,000× (non-blocking)
`records.rs:68-75`: every record deep-clones the whole `Op`, value included, plus
`before`/`after`. `ops.rs:145-164`: a subtree `set` writes the value into every entry and
records it once per entry. `ops.rs:193,197`: a `rename` records the whole item twice, subtree
included. `import_equine.rs:60-68`: input reads have no size bound. The depth and segment
caps of `9f11499` bound the stack. Nothing bounds memory, the document size or the record
volume.
Measured with the release probe under `ulimit -v 3000000`:
| input | size | peak RSS | outcome |
|---|---|---|---|
| real `changes.json` | 227 KB | 14 MB | OK, 825 records |
| add 1,000 nodes + subtree `set` of a 100 KB description | 154 KB | 1.10 GB | OK, accepted and rendered |
| same, 2,000 nodes | 211 KB | > 2.38 GB | abort: `memory allocation of 804175406 bytes failed` |
| 5,000-node category + 200 rename ping-pongs | 300 KB | 2.13 GB | OK |
| same, 500 renames | 326 KB | > 3 GB | abort |
Growth is linear in (ops × item size): one 90-byte rename op on that category costs about
10 MB. A 1 MB hostile file asks for tens of GB. This host has 14 GB of RAM with its 3 GB of
swap already full, so the result is an OOM kill or thrashing, during `--check` as well. No
data is lost and nothing is written. The input is an authored repository file, which can come
from a contributor PR on an MIT project. The TypeScript cloned the same way, so this is a
parity issue. It still falls short of the owner's explicit "depth and resource caps"
requirement.
Fix direction:
- Cap the input files in the binary (for example `changes.json` ≤ 4 MiB; the real file is
227 KB).
- Bound the curated document next to `assert_depth`: node count or serialised size, plus
string length.
- Optionally, records reference the op (index or `Rc<Op>`) instead of cloning it.
### L1 [LOW] Quadratic CPU: whole-document depth walk after every op
`apply.rs:109,125-147`: `depth_of` (new in `9f11499`) walks the whole document after each op.
A 2.4 MB input (20,000-node added subtree, then 10,000 one-field `set` ops) takes 9.9 s. The
cost is O(ops × document). Fix direction: the input cap of M1. Otherwise compute depth
incrementally (the depth of the touched item's path plus the depth of the written or inserted
value).
### L2 [LOW] `--check` and input reads follow symbolic links of the committed seed
`import_equine.rs:148`: `listed` decides recursion with `entry.path().is_dir()`, which follows
links. `import_equine.rs:60-62,163`: `fs::read` follows links and has no size bound. Two
consequences:
- A committed `draft/x -> /` makes `--check` walk the filesystem and print file names to
stderr, bounded only by ELOOP and time.
- `curation/changes.json -> /dev/zero`, or a FIFO, ends in OOM or a hang.
Both stay read-only and local, with no exfiltration. Traced by reading: no symlink was planted
in the repository. Fix direction: use `entry.file_type()` (no follow) and report a symlink as a
difference; read inputs only after a `symlink_metadata` regular-file check and under a size
cap.
### L3 [LOW] Residual check-then-use window in `--out`
The path is canonicalised at `import_equine.rs:203`, then the folder is created at `:216`.
Each intermediate folder is checked with `symlink_metadata` at `:252`, then the file is opened
at `:257-261`. All of these are path-based. A concurrent local actor with write access to the
destination's parent, or the owner of a pre-existing empty destination, could swap a
component for a symlink between check and use. The impact is bounded: every file is
`create_new` (O_EXCL) with a fixed name, so nothing is overwritten, truncated or deleted. The
worst case is new fixed-name files in another folder the user can write. Fix direction, only
if wanted: hold the claimed root as a directory fd and create children with
`openat`/`mkdirat` + `O_NOFOLLOW` (rustix or cap-std). Otherwise document the single-user
machine assumption.
### L4 [LOW] `write_exclusive` accepts any path component
`import_equine.rs:244-255` pushes each component of `relative` without refusing `RootDir`,
`ParentDir` or `Prefix`. Today every name is a compile-time constant (`render_artifacts`,
`render_draft_artifacts`, `assets/Horse.svg`), so this is not exploitable. It becomes a
traversal if R5.4 derives a file name from data, for example review drawings named after view
ids. Fix direction: refuse any component other than `Component::Normal`.
### L5 [LOW] Silent input normalisation, against "author data never dropped silently"
- `import_equine.rs:66-68`: invalid UTF-8 in `changes.json` or `references.json` silently
becomes U+FFFD.
- `schema.rs:382-384` (`js::parse_json`): a duplicated key keeps its last value, and the first
is dropped without notice.
Both are declared parity with `readFile(..., 'utf8')` and `JSON.parse`. Fix direction: refuse
invalid UTF-8 (`String::from_utf8`) and duplicate keys in the authored files, or warn.
### L6 [LOW] A test runs the real binary against the official seed path
`curation_draft.rs:676-701` runs `import-equine --out <seed>/new-folder`. If the seed guard
regressed, the test itself would create `new-folder/` with 12 files inside the official seed
before its assertion fails (no overwrite). For the same reason this gate did not run
`cargo test --test curation_draft`: the brief forbids `--out` against a repository path. Fix
direction: assert the seed refusal through the pure claim logic with an injectable seed root,
or keep it and accept the regression risk knowingly.
### L7 [LOW, context] New lint allow in a test crate: not a security suppression
`curation_draft.rs:7` adds
`#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]`. It sits on an
integration-test crate, uses the same line as 10 existing test files, and follows the policy
written in `clippy.toml` ("Tests … allow these lints locally where they own I/O"). It silences
no security scanner and no security finding, so it is not blocking.
### L8 [LOW, context] Pre-existing allow, and gaps in the I/O ban list
`import_equine.rs:15` `#![allow(clippy::disallowed_methods)]` was already present at
`5e114da`. Separately, `clippy.toml` bans only `fs::read`, `read_to_string`, `write`,
`File::open`/`create`, `env::var`/`var_os` and the clocks. `fs::create_dir*`,
`OpenOptions::open`, `read_dir`, `canonicalize`, `remove_*`, `env::current_dir`,
`env::args_os` and `process::Command` would pass the lint inside the library. A grep confirms
that `crates/core/src` outside `src/bin` uses none of them today. Fix direction: extend the
list.
## Verified, no finding
Stack and validation. The probe linked `faunosteo-core` with the `curation` feature and ran
in debug on a 2 MiB thread, in debug on the main thread, and in release:
- a 20,000-segment field and a 9-segment field are refused; the 8-segment field is refused
later by the strict shape check;
- `name.\0touched` is refused; a `\0touched` key inside a value is refused at parse;
- a value at serde's 128 nesting limit is refused with "recursion limit exceeded";
- a 122-deep object value, a 58-level children chain and 40 chained adds (refused at op 29)
all end with "nests more than 64 levels";
- moving an item into itself is refused;
- no crash, no panic in any mode.
Margins on real data: document depth 10 against the cap of 64; field segments at most 2
against the cap of 8.
`--check`, as briefed: `legacy-import` 6 files, 0 differences; `draft` 6 files, 0 differences
(6 pending R5.4). `git status` clean afterwards.
`--out`, 20 cases in a fresh `mktemp -d`. A copy of the binary was built there; the
repository stayed clean.
- Written:
- an absent folder: 12 files, `document.json` byte-identical to the seed;
- an existing empty folder;
- a parent symlink: the files land at the canonical path;
- an interior `./`;
- a relative path with an absolute `INIT_CWD`; a relative `INIT_CWD` is ignored.
- Refused with exit code 2 and nothing created:
- an existing non-empty folder; a file;
- a symlink, `symlink/`, `symlink/.`, a dangling symlink (its target is not created);
- a missing parent; `..`; `""`; `/`; an extra argument; a non-UTF-8 argument.
Scratch total: 74 files = 6 × 12 + 2 fixtures.
Seed protection, traced by reading and not run against the repository:
- the parent is canonicalised, then compared with `starts_with` component by component
against the canonical seed;
- a root equal to the seed, or to any ancestor, is non-empty and refused;
- a final-component symlink is refused;
- `folders()` is computed before the claim, so a refused changeset creates nothing.
The library performs no file system, environment or process access. The Rust ownership model
rules out reference cycles from `move`.
Probe artefacts (scratch only):
`/tmp/claude-1000/-home-bchanot-Documents-faunosteo/9b0edf59-ccd2-4662-b90c-e473dd78028e/scratchpad/secfinal2.SbMNbq`