Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

perf(evidence): reuse authenticated file snapshots during session import (#1721)

Ysopwnable966dc3acde28
diff --git a/src/application/EvidenceBundleFiles.ts b/src/application/EvidenceBundleFiles.ts
index 4c7e310c7..f3441c64d 100644
--- a/src/application/EvidenceBundleFiles.ts
+++ b/src/application/EvidenceBundleFiles.ts
@@ -1,4 +1,5 @@
import {
+ createImmutableEvidenceBundle,
describeEvidenceBundleFailure,
describeValidationFailure,
parseEvidenceBundle,
@@ -30,14 +31,29 @@ type EvidenceWriteFailure =
| AnalysisCancelledError;
/** Read and validate an evidence bundle at the caller-supplied path. */
-export const readEvidenceBundle = async (
+export const readEvidenceBundle = (
path: string,
+): Promise<Result<EvidenceBundle, EvidenceReadFailure>> =>
+ readBundle(path, parseEvidenceBundle);
+
+/** Read an authenticated immutable snapshot for a subsequent session import. */
+export const readImmutableEvidenceBundle = (
+ path: string,
+): Promise<Result<EvidenceBundle, EvidenceReadFailure>> =>
+ readBundle(path, (input) => {
+ const bundle = parseEvidenceBundle(input);
+ return createImmutableEvidenceBundle(bundle.records, bundle.unknowns);
+ });
+
+const readBundle = async (
+ path: string,
+ parseBundle: (input: unknown) => EvidenceBundle,
): Promise<Result<EvidenceBundle, EvidenceReadFailure>> => {
const loaded = await readJsonFile(path);
if (!loaded.ok) return loaded;
let bundle: EvidenceBundle;
try {
- bundle = parseEvidenceBundle(loaded.value);
+ bundle = parseBundle(loaded.value);
} catch (cause: unknown) {
return err(
new EvidenceIntegrityError("Evidence bundle validation failed", {
diff --git a/src/application/investigation/EvidenceLedger.ts b/src/application/investigation/EvidenceLedger.ts
index 6a2900c6f..1b88c5737 100644
--- a/src/application/investigation/EvidenceLedger.ts
+++ b/src/application/investigation/EvidenceLedger.ts
@@ -417,8 +417,9 @@ export class EvidenceLedger {
unknowns: ReadonlyMap<string, ResidualUnknown>,
): Result<void, EvidenceIntegrityError | UnknownRegistryError> {
try {
- parseEvidenceBundle(
- createEvidenceBundle([...records.values()], [...unknowns.values()]),
+ createImmutableEvidenceBundle(
+ [...records.values()],
+ [...unknowns.values()],
);
} catch (cause: unknown) {
return err(new UnknownRegistryError("integrity", { cause }));
diff --git a/src/server/registerSessionRecordTools.ts b/src/server/registerSessionRecordTools.ts
index 998fa5d59..4b8856bfd 100644
--- a/src/server/registerSessionRecordTools.ts
+++ b/src/server/registerSessionRecordTools.ts
@@ -2,7 +2,7 @@ import type { EvidenceMcpServer } from "./EvidenceMcpServer.js";
import type { BinarySessionPort } from "../application/binary/BinarySessionPort.js";
import {
- readEvidenceBundle,
+ readImmutableEvidenceBundle,
writeEvidenceBundle,
} from "../application/EvidenceBundleFiles.js";
import { toolContract } from "../contracts/toolContracts.js";
@@ -91,7 +91,7 @@ const registerImportEvidenceTool = ({
toolRegistrationOptions(importContract),
async (input) => {
const path = input.path;
- const loaded = await readEvidenceBundle(path);
+ const loaded = await readImmutableEvidenceBundle(path);
if (!loaded.ok)
return server.delivery.toCallToolResult(loaded, importContract);
const retainedUnknownRevisions = new Set(
diff --git a/tests/boundary/filesystem/evidenceBundleFiles.test.ts b/tests/boundary/filesystem/evidenceBundleFiles.test.ts
index d5a92938a..661a2b18a 100644
--- a/tests/boundary/filesystem/evidenceBundleFiles.test.ts
+++ b/tests/boundary/filesystem/evidenceBundleFiles.test.ts
@@ -14,9 +14,11 @@ import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
import {
readEvidenceBundle,
+ readImmutableEvidenceBundle,
writeEvidenceBundle,
} from "../../../src/application/EvidenceBundleFiles.js";
import { compareEvidenceBundlesCommand } from "../../../src/application/EvidenceBundleCommands.js";
+import { EvidenceLedger } from "../../../src/application/investigation/EvidenceLedger.js";
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
import { createEvidence } from "../../../src/domain/evidence.js";
import { writeTextParts } from "../../../src/application/JsonFiles.js";
@@ -209,6 +211,46 @@ describe("evidence bundle publication", () => {
});
});
+it("reuses authenticated file snapshots while isolating mutable public reads", async () => {
+ const directory = await createTestTempDirectory("rea-evidence-owned-");
+ const path = join(directory, "bundle.json");
+ const evidence = createEvidence(
+ {
+ path: "/local/observed-target",
+ sha256: "a".repeat(64),
+ format: "file",
+ },
+ { id: "fixture", name: "Fixture", version: "1" },
+ { operation: "health", parameters: {}, result: { nested: [true] } },
+ );
+ const source = serializeEvidenceBundle(createEvidenceBundle([evidence]));
+ await writeFile(path, source);
+ const mutable = await readEvidenceBundle(path);
+ if (!mutable.ok) throw mutable.error;
+ expect(Object.isFrozen(mutable.value.records[0])).toBe(false);
+ const loaded = await readImmutableEvidenceBundle(path);
+ if (!loaded.ok) throw loaded.error;
+ const record = loaded.value.records[0];
+ if (record === undefined) throw new Error("Expected an imported record");
+ expect(record).toEqual(evidence);
+ expect(Object.isFrozen(loaded.value)).toBe(true);
+ expect(Object.isFrozen(record.normalized_result)).toBe(true);
+ expect(Reflect.set(record, "operation", "forged")).toBe(false);
+
+ const ledger = new EvidenceLedger();
+ const imported = ledger.import(loaded.value);
+ if (!imported.ok) throw imported.error;
+ expect(imported.value).toMatchObject({ recordsAdded: 1, changed: true });
+ expect(ledger.forAnalysis(evidence.evidence_id)).toBe(record);
+ const detached = ledger.get(evidence.evidence_id);
+ if (detached === undefined) throw new Error("Expected a detached record");
+ expect(Reflect.set(detached, "normalized_result", false)).toBe(true);
+ expect(ledger.record(detached).ok).toBe(false);
+ expect(ledger.export()).toEqual(loaded.value);
+ expect(await readFile(path, "utf8")).toBe(source);
+ ledger.clear();
+});
+
describe("evidence bundle filesystem adapter", () => {
it("round trips canonical bytes and requires explicit overwrite", async () => {
const directory = await createTestTempDirectory("rea-evidence-");
@@ -290,34 +332,37 @@ describe("evidence bundle filesystem adapter", () => {
);
});
- it("rejects malformed and tampered input", async () => {
- const directory = await createTestTempDirectory("rea-evidence-");
- const malformed = join(directory, "malformed.json");
- await writeFile(malformed, "{");
- expect(await readEvidenceBundle(malformed)).toMatchObject({
- ok: false,
- error: { _tag: "EvidenceFileError", reason: "invalid-json" },
- });
+ it.each([readEvidenceBundle, readImmutableEvidenceBundle])(
+ "rejects malformed and tampered input (%s)",
+ async (readBundle) => {
+ const directory = await createTestTempDirectory("rea-evidence-");
+ const malformed = join(directory, "malformed.json");
+ await writeFile(malformed, "{");
+ expect(await readBundle(malformed)).toMatchObject({
+ ok: false,
+ error: { _tag: "EvidenceFileError", reason: "invalid-json" },
+ });
- const tampered = bundle();
- const tamperedPath = join(directory, "tampered.json");
- await writeFile(
- tamperedPath,
- JSON.stringify({
- ...tampered,
- records: [{ ...tampered.records[0], normalized_result: "changed" }],
- }),
- );
- expect(await readEvidenceBundle(tamperedPath)).toMatchObject({
- ok: false,
- error: {
- _tag: "EvidenceIntegrityError",
- userMessage: expect.stringContaining(
- "at records.0.evidence_id: Evidence semantic identifier does not match its record",
- ),
- },
- });
- });
+ const tampered = bundle();
+ const tamperedPath = join(directory, "tampered.json");
+ await writeFile(
+ tamperedPath,
+ JSON.stringify({
+ ...tampered,
+ records: [{ ...tampered.records[0], normalized_result: "changed" }],
+ }),
+ );
+ expect(await readBundle(tamperedPath)).toMatchObject({
+ ok: false,
+ error: {
+ _tag: "EvidenceIntegrityError",
+ userMessage: expect.stringContaining(
+ "at records.0.evidence_id: Evidence semantic identifier does not match its record",
+ ),
+ },
+ });
+ },
+ );
it("names the failed bundle constraint for a single record or schema mismatch", async () => {
const directory = await createTestTempDirectory("rea-evidence-");