Skip to content

Craft Anything: understand how any software works, and craft your own.

Rust

Check folder inventory evidence with the scope it was recorded with (#461)

NetterSilverb11554d7cc31
diff --git a/crates/engine/src/tools/application_tools.rs b/crates/engine/src/tools/application_tools.rs
index 3a50e1f8..d2a1d715 100644
--- a/crates/engine/src/tools/application_tools.rs
+++ b/crates/engine/src/tools/application_tools.rs
@@ -3,7 +3,7 @@
//! and coverage, and platform projections of artifact inventories. Pure computation over
//! evidence (or over a path, analysed on the spot).
-use super::artifact_tools::{WalkOptions, abs_path, env, inventory_path, is_path_input, resolve_evidence_input, walk_dir};
+use super::artifact_tools::{WalkOptions, abs_path, env, inventory_path, is_path_input, recorded_inventory, resolve_evidence_input, walk_dir};
use super::js_tools::load_graph;
use crate::tool::{Ctx, Effects, Requires, ToolOutput, ToolSpec, Toolset, parse_params, schema_of};
use craft_anything_analysis::js_inventory::{InvLimits, Inventory};
@@ -11,7 +11,7 @@ use craft_anything_analysis::js_ledger::{Binding, Review, build_ledger, evaluate
use craft_anything_analysis::js_source::{SourceGraph, build_source_graph, diff_source_and_bundle};
use craft_anything_analysis::js_trace::{Direction, SeedKind, find_seeds, follow_feature, trace_semantics};
use craft_anything_analysis::{js_compare, js_projection};
-use craft_anything_evidence::{Confidence, Coverage, CoverageStatus, ErrorCode, EvidenceBuilder, Limitation, Location, Subject, ToolError};
+use craft_anything_evidence::{Confidence, Coverage, CoverageStatus, EvidenceBuilder, Limitation, Location, Subject, ToolError};
use schemars::JsonSchema;
use serde::Deserialize;
use serde_json::{Value, json};
@@ -716,11 +716,7 @@ fn projection_inventory(ctx: &Ctx<'_>, p: &ProjectionParams) -> Result<(Inventor
let limits = InvLimits { max_depth: 2, ..InvLimits::default() };
if let Some(v) = &p.inventory {
let ev = resolve_evidence_input(ctx, v, &["core_archive_show"])?;
- let path = ev.params.get("path").and_then(Value::as_str).ok_or_else(|| ToolError::invalid("inventory evidence has no path"))?;
- let (inv, subject) = inventory_path(std::path::Path::new(path), limits, &ctx.cancel)?;
- if subject.sha256 != ev.subject.sha256 {
- return Err(ToolError::new(ErrorCode::FileChanged, format!("{path} changed since evidence {} was recorded", ev.id)));
- }
+ let (inv, subject) = recorded_inventory(&ev, limits, &ctx.cancel)?;
return Ok((inv, subject, Some(ev.id)));
}
let path = match &p.path {
diff --git a/crates/engine/src/tools/artifact_tools.rs b/crates/engine/src/tools/artifact_tools.rs
index 0c959a78..e5d52334 100644
--- a/crates/engine/src/tools/artifact_tools.rs
+++ b/crates/engine/src/tools/artifact_tools.rs
@@ -471,11 +471,45 @@ fn integrity_error(inv: &Inventory) -> ToolError {
.with_details(json!({"contradictions": inv.contradictions.iter().take(50).collect::<Vec<_>>()}))
}
+fn show_limits(max_depth: u32, max_entries: usize, max_total_bytes: u64) -> InvLimits {
+ InvLimits { max_entries: max_entries.clamp(1, 1_000_000), max_depth: max_depth.min(6), max_total_bytes, ..InvLimits::default() }
+}
+
+/// Re-read the path a core_archive_show record names and check it is unchanged, then return its inventory at `limits`.
+/// The check uses the scope the record was made with, since a folder's id covers only the entries that scope lists.
+pub(crate) fn recorded_inventory(ev: &Evidence, limits: InvLimits, cancel: &CancelToken) -> Result<(Inventory, Subject), ToolError> {
+ let path = ev.params.get("path").and_then(Value::as_str).ok_or_else(|| ToolError::invalid("inventory evidence has no path"))?;
+ let num = |k: &str| ev.params.get(k).and_then(Value::as_u64);
+ let recorded = show_limits(
+ num("max_depth").map_or(default_depth(), |v| u32::try_from(v).unwrap_or(u32::MAX)),
+ num("max_entries").map_or(default_max_entries(), |v| usize::try_from(v).unwrap_or(usize::MAX)),
+ num("max_total_bytes").unwrap_or_else(default_max_total),
+ );
+ // A file's id is the hash of its bytes, whatever the scope; a folder's depends on the scope.
+ let check = if ev.subject.kind == "directory" { recorded } else { limits };
+ let (inv, subject) = inventory_path(Path::new(path), check, cancel)?;
+ if subject.sha256 != ev.subject.sha256 {
+ return Err(ToolError::new(ErrorCode::FileChanged, format!("{path} changed since evidence {} was recorded", ev.id))
+ .with_remediation("Run core_archive_show again, or pass the path directly."));
+ }
+ if same_limits(&check, &limits) {
+ return Ok((inv, subject));
+ }
+ inventory_path(Path::new(path), limits, cancel)
+}
+
+fn same_limits(a: &InvLimits, b: &InvLimits) -> bool {
+ a.max_entries == b.max_entries
+ && a.max_depth == b.max_depth
+ && a.max_nested_bytes == b.max_nested_bytes
+ && a.max_entry_bytes == b.max_entry_bytes
+ && a.max_total_bytes == b.max_total_bytes
+}
+
fn core_archive_show(ctx: &mut Ctx<'_>, params: Value) -> Result<ToolOutput, ToolError> {
let p: InspectArtifactParams = parse_params(params)?;
let path = target_path(ctx, p.path.as_deref())?;
- let limits =
- InvLimits { max_entries: p.max_entries.clamp(1, 1_000_000), max_depth: p.max_depth.min(6), max_total_bytes: p.max_total_bytes, ..InvLimits::default() };
+ let limits = show_limits(p.max_depth, p.max_entries, p.max_total_bytes);
ctx.report(None, format!("Inventorying {}", path.display()));
let (inv, subject) = inventory_path(&path, limits, &ctx.cancel)?;
let blocking = inv.contradictions.iter().any(|c| c.get("reason").and_then(Value::as_str).is_some_and(|r| r.contains("integrity") || r.contains("CRC")));
@@ -505,7 +539,7 @@ fn core_archive_show(ctx: &mut Ctx<'_>, params: Value) -> Result<ToolOutput, Too
}
lims.push(Limitation::new("no_disk_images", "Disk images (DMG), installers (PKG/MSI) and compressed tarballs are listed as single files, not opened."));
let ev = EvidenceBuilder::new("core_archive_show", subject, env(ctx))
- .params(json!({"path": path, "if_tampered": p.if_tampered == IntegrityPolicy::Fail, "offset": p.offset, "limit": limit, "max_depth": limits.max_depth}))
+ .params(json!({"path": path, "if_tampered": p.if_tampered == IntegrityPolicy::Fail, "offset": p.offset, "limit": limit, "max_depth": limits.max_depth, "max_entries": limits.max_entries, "max_total_bytes": limits.max_total_bytes}))
.result(json!({
"path": path,
"root": inv.root, "root_kind": inv.root_kind, "content_id": inv.content_id(),
@@ -705,12 +739,7 @@ fn inventory_input(ctx: &Ctx<'_>, v: &Value) -> Result<(Inventory, Option<String
}
let ev = resolve_evidence_input(ctx, v, &["core_archive_show"])?;
// Evidence holds one page; re-read the recorded path for the full inventory and check it is unchanged.
- let path = ev.params.get("path").and_then(Value::as_str).ok_or_else(|| ToolError::invalid("inventory evidence has no path"))?;
- let (inv, subject) = inventory_path(Path::new(path), InvLimits::default(), &ctx.cancel)?;
- if subject.sha256 != ev.subject.sha256 {
- return Err(ToolError::new(ErrorCode::FileChanged, format!("{path} changed since evidence {} was recorded", ev.id))
- .with_remediation("Run core_archive_show again, or pass the path directly."));
- }
+ let (inv, _) = recorded_inventory(&ev, InvLimits::default(), &ctx.cancel)?;
Ok((inv, Some(ev.id)))
}
@@ -803,6 +832,55 @@ mod tests {
assert!(call(&e, "core_archives_compare", json!({"left": "relative/path", "right": b})).is_err());
}
+ #[test]
+ fn folder_evidence_scope_is_not_a_change() {
+ let dir = tempfile::tempdir().unwrap();
+ let app = dir.path().join("app");
+ std::fs::create_dir(&app).unwrap();
+ let l3 = fx::zip_stored(&[("leaf.txt", b"leaf")]);
+ let l2 = fx::zip_stored(&[("l3.zip", &l3)]);
+ let l1 = fx::zip_stored(&[("l2.zip", &l2)]);
+ std::fs::write(app.join("l1.zip"), &l1).unwrap();
+ std::fs::write(app.join("other.txt"), b"other").unwrap();
+ let e = Engine::new(crate::testing::session());
+ let tools = ["core_archives_compare", "android_app_graph_build", "apple_app_graph_build", "harmony_app_graph_build"];
+ let consume = |tool: &str, input: Value| {
+ let p = if tool == "core_archives_compare" { json!({"left": input, "right": app}) } else { json!({"inventory": input}) };
+ call(&e, tool, p)
+ };
+ let scopes = [json!({"max_depth": 2}), json!({"max_depth": 3}), json!({"max_entries": 2}), json!({"max_total_bytes": 10})];
+ let mut recorded = Vec::new();
+ for scope in scopes {
+ let mut p = scope.clone();
+ p["path"] = json!(app);
+ let inv = call(&e, "core_archive_show", p).unwrap();
+ let id = inv["id"].as_str().unwrap().to_string();
+ for tool in tools {
+ for input in [json!({"kind": "saved", "evidence_id": id}), inv.clone()] {
+ let out = consume(tool, input).unwrap_or_else(|err| panic!("{scope} {tool}: {err:?}"));
+ assert!(out["links"].as_array().unwrap().contains(&json!(id)), "{scope} {tool}");
+ if tool == "core_archives_compare" {
+ for k in ["added", "removed", "changed", "moved"] {
+ assert_eq!(out["result"]["counts"][k], 0, "{scope} {k}");
+ }
+ }
+ }
+ }
+ recorded.push((id, inv));
+ }
+ // Real changes are still refused (both files change, so each recorded scope covers one).
+ std::fs::write(app.join("l1.zip"), fx::zip_stored(&[("l2.zip", b"changed")])).unwrap();
+ std::fs::write(app.join("other.txt"), b"changed").unwrap();
+ for (id, inv) in recorded {
+ for tool in tools {
+ for input in [json!({"kind": "saved", "evidence_id": id}), inv.clone()] {
+ let err = consume(tool, input).unwrap_err();
+ assert_eq!(err.code, ErrorCode::FileChanged, "{tool}");
+ }
+ }
+ }
+ }
+
#[test]
fn if_tampered() {
let dir = tempfile::tempdir().unwrap();