Skip to content

armgit / rea

Public Imported from GitHub
0

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

perf(snapshot): avoid redundant result copies and serialization

N0zoM1z0569d2bc6b9f6
diff --git a/src/application/binary/AnalysisSnapshotCache.test.ts b/src/application/binary/AnalysisSnapshotCache.test.ts
index 096d50111..2a0c975b8 100644
--- a/src/application/binary/AnalysisSnapshotCache.test.ts
+++ b/src/application/binary/AnalysisSnapshotCache.test.ts
@@ -13,6 +13,7 @@ import { createAnalysisExecution } from "../AnalysisProvider.js";
import {
createAnalysisSnapshotWorkflowEntry,
parseAnalysisSnapshot,
+ serializeAnalysisSnapshot,
snapshotBinding,
snapshotTarget,
} from "../../domain/analysisSnapshot.js";
@@ -30,6 +31,89 @@ import {
isSnapshotCacheable,
} from "./AnalysisSnapshotCache.js";
+it("exports independent nested query, workflow and Evidence payloads", () => {
+ const cache = new AnalysisSnapshotCache();
+ const target = ANALYSIS_SNAPSHOT_TARGET;
+ const profile = ANALYSIS_SNAPSHOT_PROFILE;
+ const result = { nested: [{ text: "ret" }], name: "main" };
+ const parameters = { address: "0x1000", document: "fixture" };
+ const workflowProfile = workflowAnalysisProfile(profile);
+ cache.record({
+ target,
+ profile,
+ operation: "procedure_info",
+ parameters,
+ execution: createAnalysisExecution(result, ANALYSIS_SNAPSHOT_PROVIDER, {
+ subject: target,
+ analysisProfile: profile,
+ rawResult: result,
+ }),
+ });
+ cache.recordWorkflow({
+ target,
+ profile,
+ operation: "analyze_function",
+ parameters,
+ execution: {
+ ...createAnalysisExecution(result, REA_WORKFLOW_PROVIDER, {
+ subject: target,
+ rawResult: result,
+ }),
+ analysisProfile: workflowProfile,
+ },
+ });
+ const bundle = createEvidenceBundle([
+ createEvidence(target, ANALYSIS_SNAPSHOT_PROVIDER, {
+ operation: "procedure_info",
+ parameters,
+ result,
+ rawResult: result,
+ analysisProfile: profile,
+ }),
+ createEvidence(target, REA_WORKFLOW_PROVIDER, {
+ operation: "analyze_function",
+ parameters,
+ result,
+ rawResult: result,
+ analysisProfile: workflowProfile,
+ }),
+ ]);
+ const exported = cache.export(target, profile, bundle);
+ if (!exported.ok) throw exported.error;
+ const expected = serializeAnalysisSnapshot(exported.value);
+ const changed = JSON.stringify(exported.value).replaceAll(
+ '"ret"',
+ '"changed"',
+ );
+ // Mutate the returned graph itself, including every duplicated JSON result.
+ for (const payload of [
+ ...exported.value.entries.flatMap(({ execution }) => [
+ execution.result,
+ execution.raw_result,
+ ]),
+ ...(exported.value.workflow_entries ?? []).flatMap(({ execution }) => [
+ execution.result,
+ execution.raw_result,
+ ]),
+ ...exported.value.evidence_bundle.records.flatMap((record) => [
+ record.normalized_result,
+ record.raw_result,
+ ]),
+ ]) {
+ if (
+ typeof payload !== "object" ||
+ payload === null ||
+ Array.isArray(payload)
+ )
+ throw new Error("Expected nested fixture result");
+ Reflect.set(payload, "nested", [{ text: "changed" }]);
+ }
+ expect(JSON.stringify(exported.value)).toBe(changed);
+ const fresh = cache.export(target, profile, bundle);
+ if (!fresh.ok) throw fresh.error;
+ expect(serializeAnalysisSnapshot(fresh.value)).toBe(expected);
+});
+
describe("analysis snapshot cache capacity", () => {
it("shares capacity across query kinds while allowing replacements and fresh partitions", () => {
const cache = new AnalysisSnapshotCache();
diff --git a/src/application/binary/AnalysisSnapshotCache.ts b/src/application/binary/AnalysisSnapshotCache.ts
index 240bd2b61..c7e3b7c58 100644
--- a/src/application/binary/AnalysisSnapshotCache.ts
+++ b/src/application/binary/AnalysisSnapshotCache.ts
@@ -143,16 +143,21 @@ export class AnalysisSnapshotCache {
try {
const snapshotTargetIdentity = snapshotTarget(target);
const binding = snapshotBinding(profile);
- const retainedEvidence = structuredClone(evidenceBundle);
+ const entries = [...this.#entries.values()].sort((left, right) =>
+ left.query_id.localeCompare(right.query_id),
+ );
+ const workflows = [...this.#workflowEntries.values()].sort(
+ (left, right) => left.query_id.localeCompare(right.query_id),
+ );
+ // Parsing owns the returned JSON and metadata; pre-cloning the same
+ // payloads here only adds another full materialization.
return ok(
parseAnalysisSnapshot({
target: snapshotTargetIdentity,
binding,
- entries: this.entries(),
- ...(this.workflowEntries().length === 0
- ? {}
- : { workflow_entries: this.workflowEntries() }),
- evidence_bundle: retainedEvidence,
+ entries,
+ ...(workflows.length === 0 ? {} : { workflow_entries: workflows }),
+ evidence_bundle: evidenceBundle,
}),
);
} catch (cause: unknown) {
diff --git a/src/domain/analysisSnapshot.test.ts b/src/domain/analysisSnapshot.test.ts
index 1ee8cc620..5f5d7b4e4 100644
--- a/src/domain/analysisSnapshot.test.ts
+++ b/src/domain/analysisSnapshot.test.ts
@@ -138,6 +138,72 @@ describe("analysis snapshot contract", () => {
});
});
+describe("analysis snapshot canonical ordering and scope", () => {
+ it("rejects reordered queries and foreign-target records while retaining legacy Evidence", () => {
+ const { snapshot } = snapshotWithHistoricalEvidence();
+ const first = snapshot.entries[0];
+ if (first === undefined) throw new Error("Missing fixture query");
+ const parameters = { procedure: "other" };
+ const second = {
+ ...first,
+ parameters,
+ query_id: analysisQueryId(
+ snapshot.target,
+ snapshot.binding,
+ first.operation,
+ parameters,
+ ),
+ };
+ const entries = [first, second].sort((left, right) =>
+ left.query_id.localeCompare(right.query_id),
+ );
+ const canonical = { ...snapshot, entries };
+ expect(parseAnalysisSnapshot(canonical).entries).toEqual([first]);
+ expect(() =>
+ parseAnalysisSnapshot({ ...canonical, entries: [...entries].reverse() }),
+ ).toThrow(/entries are not canonical/u);
+ const workflows = entries.map((entry) => ({
+ ...entry,
+ execution: {
+ ...entry.execution,
+ analysis_profile: ANALYSIS_SNAPSHOT_PROFILE,
+ },
+ }));
+ expect(
+ parseAnalysisSnapshot({
+ ...snapshot,
+ entries: [],
+ workflow_entries: workflows,
+ }).workflow_entries,
+ ).toEqual([]);
+ expect(() =>
+ parseAnalysisSnapshot({
+ ...snapshot,
+ entries: [],
+ workflow_entries: [...workflows].reverse(),
+ }),
+ ).toThrow(/workflow entries are not canonical/u);
+ const foreign = createEvidence(
+ { ...ANALYSIS_SNAPSHOT_TARGET, sha256: "b".repeat(64) },
+ ANALYSIS_SNAPSHOT_PROVIDER,
+ {
+ operation: "legacy_query",
+ parameters: {},
+ result: null,
+ },
+ );
+ expect(() =>
+ parseAnalysisSnapshot({
+ ...snapshot,
+ evidence_bundle: createEvidenceBundle([
+ ...snapshot.evidence_bundle.records,
+ foreign,
+ ]),
+ }),
+ ).toThrow(/another target/u);
+ });
+});
+
describe("analysis snapshot Evidence binding", () => {
it("finds only Evidence committed to the exact binding and profile", () => {
const { current, snapshot } = snapshotWithHistoricalEvidence();
diff --git a/src/domain/analysisSnapshot.ts b/src/domain/analysisSnapshot.ts
index c91144802..f3a221ced 100644
--- a/src/domain/analysisSnapshot.ts
+++ b/src/domain/analysisSnapshot.ts
@@ -372,10 +372,15 @@ export const createAnalysisSnapshotEntry = (input: {
export const parseAnalysisSnapshot = (input: unknown): AnalysisSnapshot => {
const parsed = analysisSnapshotSchema.parse(input);
parseEvidenceBundle(parsed.evidence_bundle);
+ const scopedEvidence = evidenceBundleForTarget(
+ parsed.evidence_bundle,
+ parsed.target.sha256,
+ );
+ // The validated canonical bundle is filtered, never extended. Equal counts
+ // establish that no record or unknown was removed without serializing results.
if (
- JSON.stringify(
- evidenceBundleForTarget(parsed.evidence_bundle, parsed.target.sha256),
- ) !== JSON.stringify(parsed.evidence_bundle)
+ scopedEvidence.records.length !== parsed.evidence_bundle.records.length ||
+ scopedEvidence.unknowns.length !== parsed.evidence_bundle.unknowns.length
)
throw new TypeError(
"Analysis snapshot evidence contains records for another target",
@@ -448,17 +453,11 @@ export const parseAnalysisSnapshot = (input: unknown): AnalysisSnapshot => {
}
boundWorkflowEntries.push(entry);
}
- const sorted = [...parsed.entries].sort((left, right) =>
- left.query_id.localeCompare(right.query_id),
- );
- if (JSON.stringify(parsed.entries) !== JSON.stringify(sorted))
+ if (!hasCanonicalQueryOrder(parsed.entries))
throw new TypeError("Analysis snapshot entries are not canonical");
- const sortedWorkflows = [...(parsed.workflow_entries ?? [])].sort(
- (left, right) => left.query_id.localeCompare(right.query_id),
- );
if (
parsed.workflow_entries !== undefined &&
- JSON.stringify(parsed.workflow_entries) !== JSON.stringify(sortedWorkflows)
+ !hasCanonicalQueryOrder(parsed.workflow_entries)
)
throw new TypeError("Analysis snapshot workflow entries are not canonical");
return {
@@ -470,6 +469,18 @@ export const parseAnalysisSnapshot = (input: unknown): AnalysisSnapshot => {
};
};
+const hasCanonicalQueryOrder = (
+ entries: readonly { readonly query_id: string }[],
+): boolean => {
+ let previous: string | undefined;
+ for (const { query_id: queryId } of entries) {
+ if (previous !== undefined && previous.localeCompare(queryId) > 0)
+ return false;
+ previous = queryId;
+ }
+ return true;
+};
+
/** Check that a cached provider execution is represented by bundled Evidence. */
interface EvidenceIndex {
readonly matching: ReadonlySet<string>;