212 lines
12 KiB
Markdown
212 lines
12 KiB
Markdown
# 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`
|