fix(anatomy): R5.3 final gates: NUL field segments refused, field path and document depth bounded, --out writes exclusive, .. / missing parent / seed destination refused

This commit is contained in:
bchanot committed 2026-10-23 01:08:07 +02:00
1 parent 865490512e
commit 9f11499f2c
4 files changed
+215 -37

No files matched your search

+76 -37
View File
@@ -14,7 +14,9 @@
//! `report-compare`, this file is the only one of its tool allowed the file system.
#![allow(clippy::disallowed_methods)]
use std::path::{Path, PathBuf};
use std::fs::OpenOptions;
use std::io::Write;
use std::path::{Component, Path, PathBuf};
use std::{env, fs, process};
use faunosteo_core::curation::draft::{
@@ -179,47 +181,55 @@ fn check(folder: &Folder) -> Result<Vec<String>, String> {
Ok(problems)
}
/// Claims a destination this tool may fill and returns its canonical path: a non-empty path
/// that is absent (created here, so nothing can appear between the check and the writes) or
/// an empty folder that is not a symbolic link. The canonical path is where the files land,
/// symbolic links of the parent folders resolved, and is what the success line prints.
/// Claims a destination this tool may fill and returns its canonical path. The typed path
/// must be non-empty, hold no `..`, have an existing parent folder, and name either nothing
/// (the folder is created here, its parent's symbolic links resolved) or an empty folder that
/// is not a symbolic link. A destination inside the seed folder is refused: the tool never
/// writes into the official seed. The writes that follow are exclusive (`write_exclusive`).
fn claim_destination(typed: &Path) -> Result<PathBuf, String> {
let refuse = |why: &str| format!("{}: {why}, nothing written", typed.display());
if typed.as_os_str().is_empty() {
return Err("--out needs a destination path".to_owned());
}
if typed.components().any(|c| c == Component::ParentDir) {
return Err(refuse("`..` is not accepted"));
}
// Rebuilt from its components: a trailing `/` would make the system resolve a final
// symbolic link before the check below could see it.
let out: PathBuf = typed.components().collect();
let out = out.as_path();
match fs::symlink_metadata(out) {
Err(_) => {
if let Some(parent) = out.parent().filter(|p| !p.as_os_str().is_empty()) {
fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
}
fs::create_dir(out).map_err(|e| format!("{}: {e}, nothing written", out.display()))?;
}
Ok(metadata) if metadata.file_type().is_symlink() => {
return Err(format!(
"{}: a symbolic link, nothing written",
out.display()
));
}
Ok(metadata) if !metadata.is_dir() => {
return Err(format!("{}: not a folder, nothing written", out.display()));
let parent = out.parent().filter(|p| !p.as_os_str().is_empty());
let parent = match parent {
Some(parent) => {
fs::canonicalize(parent).map_err(|_| refuse("the parent folder does not exist"))?
}
None => return Err(refuse("not a destination folder")),
};
let seed = fs::canonicalize(SEED).map_err(|error| format!("{SEED}: {error}"))?;
if parent.starts_with(&seed) {
return Err(refuse("inside the seed folder"));
}
let name = out
.file_name()
.ok_or_else(|| format!("{}: not a destination folder", typed.display()))?;
let root = parent.join(name);
match fs::symlink_metadata(&root) {
Err(_) => fs::create_dir(&root).map_err(|error| refuse(&error.to_string()))?,
Ok(metadata) if metadata.file_type().is_symlink() => return Err(refuse("a symbolic link")),
Ok(metadata) if !metadata.is_dir() => return Err(refuse("not a folder")),
Ok(_) => {
let mut entries =
fs::read_dir(out).map_err(|error| format!("{}: {error}", out.display()))?;
fs::read_dir(&root).map_err(|error| format!("{}: {error}", root.display()))?;
if entries.next().is_some() {
return Err(format!("{}: not empty, nothing written", out.display()));
return Err(refuse("not empty"));
}
}
}
fs::canonicalize(out).map_err(|error| format!("{}: {error}", out.display()))
Ok(root)
}
/// Where a relative destination is typed from: `INIT_CWD` when pnpm set it to an absolute
/// path, else the current folder.
/// path, else the current folder (the repository root when the script is run directly: it
/// moves there first).
fn base_dir() -> PathBuf {
env::var_os("INIT_CWD")
.map(PathBuf::from)
@@ -228,22 +238,42 @@ fn base_dir() -> PathBuf {
.unwrap_or_default()
}
/// Writes every file under the claimed destination; returns it and the file count.
fn write(folders: &[Folder], out: &Path) -> Result<(PathBuf, usize), String> {
let root = claim_destination(out)?;
/// Creates `path` and the folders leading to it under `root`, each one new: an entry that
/// appeared since the claim, file, folder or symbolic link, is refused, never followed or
/// truncated (`create_dir`, `create_new`).
fn write_exclusive(root: &Path, relative: &Path, bytes: &[u8]) -> Result<(), String> {
let mut folder = root.to_path_buf();
let components: Vec<_> = relative.components().collect();
let (file, folders) = components.split_last().ok_or("an empty file name")?;
for component in folders {
folder.push(component);
match fs::create_dir(&folder) {
Ok(()) => {}
Err(_) if fs::symlink_metadata(&folder).is_ok_and(|m| m.is_dir()) => {}
Err(error) => return Err(format!("{}: {error}", folder.display())),
}
}
let path = folder.join(file);
let mut handle = OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
.map_err(|error| format!("{}: {error}", path.display()))?;
handle
.write_all(bytes)
.map_err(|error| format!("{}: {error}", path.display()))
}
/// Writes every file under the claimed destination; returns the file count.
fn write(folders: &[Folder], root: &Path) -> Result<usize, String> {
let mut written = 0;
for folder in folders {
for (name, bytes) in &folder.files {
let path = root.join(folder.name).join(name);
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)
.map_err(|error| format!("{}: {error}", parent.display()))?;
}
fs::write(&path, bytes).map_err(|error| format!("{}: {error}", path.display()))?;
write_exclusive(root, &Path::new(folder.name).join(name), bytes)?;
written += 1;
}
}
Ok((root, written))
Ok(written)
}
fn run(args: &[String]) -> Result<i32, String> {
@@ -270,7 +300,9 @@ fn run(args: &[String]) -> Result<i32, String> {
if dir.is_empty() {
return Err("--out needs a destination path".to_owned());
}
let (root, written) = write(&folders, &base_dir().join(dir))?;
let root = claim_destination(&base_dir().join(dir))?;
println!("writing to {}", root.display());
let written = write(&folders, &root)?;
println!("{written} files written to {}", root.display());
Ok(0)
}
@@ -279,7 +311,14 @@ fn run(args: &[String]) -> Result<i32, String> {
}
fn main() {
let args: Vec<String> = env::args().skip(1).collect();
let args: Option<Vec<String>> = env::args_os()
.skip(1)
.map(|a| a.into_string().ok())
.collect();
let Some(args) = args else {
eprintln!("an argument is not valid UTF-8");
process::exit(2);
};
match run(&args) {
Ok(code) => process::exit(code),
Err(message) => {
+31
View File
@@ -106,6 +106,7 @@ fn apply_change(
for (index, op) in change.ops.iter().enumerate() {
let mut recorder = Recorder::new(&summary, op, records, &mut next_touch);
apply_op(doc, &mut recorder)
.and_then(|()| assert_depth(doc))
.map_err(|error| fail(format!("{} op {index}: {error}", change.id)))?;
}
if change.level.needs_confirmation() {
@@ -115,6 +116,36 @@ fn apply_change(
Ok(())
}
/// Nesting a valid sheet document never approaches (the equine document has 10 levels): a
/// resource bound checked after every op, so repeated adds, moves or deep values cannot grow
/// the document until a recursive walk overflows the stack.
pub const MAX_DOCUMENT_DEPTH: usize = 64;
/// The nesting of `value`, walked with an explicit stack (no recursion).
fn depth_of(value: &Value) -> usize {
let mut deepest = 0;
let mut pending = vec![(value, 1)];
while let Some((value, depth)) = pending.pop() {
let children: Box<dyn Iterator<Item = &Value>> = match value {
Value::Object(map) => Box::new(map.values()),
Value::Array(items) => Box::new(items.iter()),
_ => continue,
};
deepest = deepest.max(depth);
pending.extend(children.map(|child| (child, depth + 1)));
}
deepest
}
fn assert_depth(doc: &Value) -> Result<(), PipelineError> {
if depth_of(doc) > MAX_DOCUMENT_DEPTH {
return Err(fail(format!(
"the document nests more than {MAX_DOCUMENT_DEPTH} levels"
)));
}
Ok(())
}
fn describe(issues: &[SheetIssue]) -> String {
issues
.iter()
+15
View File
@@ -80,11 +80,26 @@ impl FieldKind {
}
}
/// More segments than any settable path needs (the deepest has two): a resource bound, so a
/// field path cannot nest the document without limit.
pub const MAX_FIELD_SEGMENTS: usize = 8;
/// The segments of a dot path. A segment starting with NUL is reserved for the applier's
/// touch marks (`records::TOUCH_MARK`): written, it would be stripped with them and the
/// author's value lost, so it is refused (the TypeScript refused such a key at the gate).
pub fn split_field(field: &str) -> Result<Vec<&str>, PipelineError> {
let path: Vec<&str> = field.split('.').collect();
if path.iter().any(|key| key.is_empty()) {
return Err(fail(format!("malformed field \"{field}\"")));
}
if path.len() > MAX_FIELD_SEGMENTS {
return Err(fail(format!(
"field \"{field}\" has more than {MAX_FIELD_SEGMENTS} segments"
)));
}
if let Some(key) = path.iter().find(|key| key.starts_with('\0')) {
return Err(fail(format!("reserved key {key:?} in field \"{field}\"")));
}
Ok(path)
}
+93
View File
@@ -608,3 +608,96 @@ fn the_migration_map_replays_cascade_records_by_their_op_as_the_typescript_does(
"should be hip-joint/hip-dysfunctions/motion"
);
}
// ---------------------------------------------------------------------------------------------
// Resource bounds and reserved names reached through a field path (final R5.3 gates).
#[test]
fn a_reserved_or_unbounded_field_path_is_refused_without_writing() {
for field in [
"name.\u{0}touched",
"description.\u{0}touched",
"name.\u{0}other",
] {
let op = json!({ "op": "set", "target": MOBILITY, "field": field, "value": "author text" });
let error = mini_apply(json!([op])).unwrap_err();
assert!(
error.contains("CHG-001 op 0: reserved key"),
"{field}: {error}"
);
}
// 20,000 segments overflowed the stack before the bound (security gate, MEDIUM-1).
let deep = format!("name{}", ".a".repeat(20_000));
let op = json!({ "op": "set", "target": MOBILITY, "field": deep, "value": "x" });
let error = mini_apply(json!([op])).unwrap_err();
assert!(error.contains("more than 8 segments"), "{error}");
}
#[test]
fn the_document_cannot_be_nested_past_the_bound_by_repeated_adds() {
let mut ops = Vec::new();
let mut parent = MOBILITY.to_owned();
for level in 0..40 {
let id = format!("n{level}");
ops.push(json!({ "op": "add", "target": parent, "value": { "id": id, "name": { "fr": "a", "en": "a" } } }));
parent = format!("{parent}/{id}");
}
let error = mini_apply(Value::Array(ops)).unwrap_err();
assert!(error.contains("nests more than 64 levels"), "{error}");
}
fn import_equine(args: &[&str]) -> (i32, String) {
let output = std::process::Command::new(env!("CARGO_BIN_EXE_import-equine"))
.args(args)
.env_remove("INIT_CWD")
.output()
.unwrap();
let text = String::from_utf8_lossy(&output.stderr).into_owned();
(output.status.code().unwrap_or(-1), text)
}
/// Fixed fixtures under the test target's temporary folder: created once, never deleted, and
/// never written by the refusals checked here.
fn out_fixtures() -> std::path::PathBuf {
let base = std::path::Path::new(env!("CARGO_TARGET_TMPDIR")).join("import-equine-out");
for folder in ["empty", "full"] {
std::fs::create_dir_all(base.join(folder)).unwrap();
}
std::fs::write(base.join("full/keep.txt"), b"keep").unwrap();
std::fs::write(base.join("file"), b"file").unwrap();
let link = base.join("link");
if std::fs::symlink_metadata(&link).is_err() {
std::os::unix::fs::symlink(base.join("empty"), &link).unwrap();
}
base
}
#[test]
fn out_refuses_every_unsafe_destination_and_writes_nothing() {
let base = out_fixtures();
let at = |rest: &str| format!("{}/{rest}", base.display());
let seed = std::fs::canonicalize(common::repo_path("supabase/seed/anatomical-sheets/equine"))
.unwrap()
.join("new-folder")
.display()
.to_string();
let cases = [
(at("link"), "a symbolic link"),
(at("link/"), "a symbolic link"),
(at("link/."), "a symbolic link"),
(at("file"), "not a folder"),
(at("full"), "not empty"),
(at("empty/../new"), "`..` is not accepted"),
(at("absent/new"), "the parent folder does not exist"),
(seed.clone(), "inside the seed folder"),
];
for (path, why) in &cases {
let (code, stderr) = import_equine(&["--out", path]);
assert_eq!(code, 2, "{path}: {stderr}");
assert!(stderr.contains(why), "{path}: {stderr}");
}
assert_eq!(std::fs::read_dir(base.join("empty")).unwrap().count(), 0);
assert_eq!(std::fs::read_dir(base.join("full")).unwrap().count(), 1);
assert!(std::fs::symlink_metadata(&seed).is_err());
assert!(std::fs::symlink_metadata(base.join("absent")).is_err());
}