mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 11:43:20 +00:00
* refactor(ghidra)!: key analysis profiles on the producer identity instead of hand-bumped markers Ghidra snapshot validity depended on 53 hand-maintained "-vN" semantic markers in the analysis profile; a behaviour fix that forgot to bump its marker left old snapshots admissible (#3664). #10562 added a digest of the bridge sources, but TypeScript projection changes still needed a bump and the REA release was not committed. - src/filesystem/ProducerIdentity.ts owns the producer identity: the REA release plus a framed SHA-256 of a producer's packaged scripts, read once per process. - Ghidra profiles commit `producer` in place of `bridge_sources_sha256` and the constant revision markers (shared semantics block, load-image, entry seed, PDB, jump-table, DOL import, MIPS ISA-mode markers) are removed. - Runtime-selected values keep their meaning without a revision suffix (language_selection, annotation_policy, relocation/no-return/launch policy, MIPS/PowerPC/PSP lanes, MIPS ABI basis). Bridge wire policy ids shared with the Java scripts (ilp32-prototype-v1, o32-soft-float-prototype-v1) are unchanged. BREAKING CHANGE: Ghidra Evidence `analysis_profile.parameters` replace the semantic marker keys and `bridge_sources_sha256` with `producer` ({rea_version, sources_sha256}), and selection values lose their "-vN" suffix (for example `language_selection: "provider-pinned"`). Ghidra Evidence IDs and profile digests change, and analysis snapshots saved by earlier builds are refused at open. Migration: open the target without the old snapshot and save a fresh one; consumers reading the removed marker keys should read `producer` instead. * fix(hopper)!: commit the REA release and bridge script in Hopper analysis profiles (#11324) Hopper analysis profiles committed the launcher digest and one hand-bumped marker (function_dossier_coverage "...-v1"), but neither the REA release nor bridge/hopper_bridge.py. A snapshot saved before a bridge or REA change replayed results the current bridge would not produce. HopperBridgeSources owns the packaged bridge script URL (used to launch it) and hopperProducerIdentity() on the shared ProducerIdentity owner; the profile commits `producer` in place of the marker. BREAKING CHANGE: Hopper Evidence `analysis_profile.parameters` replace `function_dossier_coverage` with `producer` ({rea_version, sources_sha256}). Hopper profile digests and Evidence IDs change, and analysis snapshots saved by earlier builds are refused at open. Migration: open the target without the old snapshot and save a fresh one. * fix(ghidra): build the legacy reference snapshot from another producer and use the shared temp directory * refactor(providers): key Kuna exports and the Native AOT profile on the producer identity (#11353) * fix(ghidra): keep the bridge source table import-free for the Node-loaded verifier scripts/verify-ghidra-bridge-sources.mjs loads GhidraBridgeSources.ts with Node type stripping, which does not resolve .js specifiers to .ts sources. The producer identity import made every verifier run fail with ERR_MODULE_NOT_FOUND; the identity now lives in GhidraProducerIdentity.ts. * fix(artifacts): import the moved file source and abort check from their resources owner after merging main
189 lines
6.2 KiB
JavaScript
189 lines
6.2 KiB
JavaScript
import {
|
|
requireMcpEvidenceBundle,
|
|
requireMcpToolError,
|
|
requireMcpLifecycleResult,
|
|
requireMcpEvidenceResult,
|
|
} from "./mcp-verifier-results.mjs";
|
|
import assert from "node:assert/strict";
|
|
import { execFile } from "node:child_process";
|
|
import { randomUUID } from "node:crypto";
|
|
import { writeFile, rm } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { promisify } from "node:util";
|
|
import { parseBinaryTarget } from "../../dist/application/BinaryTargetResolver.js";
|
|
import { createAnalysisProfile } from "../../dist/domain/analysisProfile.js";
|
|
import {
|
|
createAnalysisSnapshotEntry,
|
|
parseAnalysisSnapshot,
|
|
serializeAnalysisSnapshot,
|
|
snapshotBinding,
|
|
snapshotTarget,
|
|
} from "../../dist/domain/analysisSnapshot.js";
|
|
import { createEvidence } from "../../dist/domain/evidence.js";
|
|
import { createEvidenceBundle } from "../../dist/domain/evidenceBundle.js";
|
|
|
|
/** Reject a valid older snapshot whose instruction-only collector omitted a real edge. */
|
|
export async function verifyLegacyGhidraReferenceSnapshot(
|
|
client,
|
|
{ target, procedure, omittedEdge, entrypoint, env },
|
|
) {
|
|
const bundle = requireMcpEvidenceBundle(
|
|
await client.callTool({
|
|
name: "get_evidence_bundle",
|
|
arguments: {},
|
|
}),
|
|
);
|
|
const observed = bundle.records.find(
|
|
(record) =>
|
|
record.operation === "analyze_function" &&
|
|
record.parameters.procedure === procedure,
|
|
);
|
|
assert.ok(observed);
|
|
// A snapshot from an earlier bridge: same profile, another producer digest.
|
|
const { producer } = observed.analysis_profile.parameters;
|
|
assert.match(
|
|
producer?.sources_sha256 ?? "",
|
|
/^[0-9a-f]{64}$/u,
|
|
"The producer identity must participate in snapshot identity",
|
|
);
|
|
const legacyProfile = createAnalysisProfile(observed.provider, {
|
|
...observed.analysis_profile.parameters,
|
|
producer: { ...producer, sources_sha256: "0".repeat(64) },
|
|
});
|
|
assert.notEqual(legacyProfile.digest, observed.analysis_profile.digest);
|
|
const parsed = await parseBinaryTarget(target.path, {
|
|
cwd: process.cwd(),
|
|
hostArchitecture: process.arch,
|
|
});
|
|
if (!parsed.ok) throw parsed.error;
|
|
const nativeTarget = parsed.value;
|
|
const result = structuredClone(observed.normalized_result);
|
|
// Reconstruct the observed pre-fix omission; all other data
|
|
// comes from the real provider and the file has a fully valid Evidence binding.
|
|
result.incoming_references = result.incoming_references.filter(
|
|
(edge) =>
|
|
edge.source_address !== omittedEdge.source_address ||
|
|
edge.target_address !== omittedEdge.target_address,
|
|
);
|
|
assert.equal(
|
|
result.incoming_references.length,
|
|
observed.normalized_result.incoming_references.length - 1,
|
|
);
|
|
const evidence = createEvidence(nativeTarget, observed.provider, {
|
|
operation: observed.operation,
|
|
parameters: observed.parameters,
|
|
result,
|
|
rawResult: result,
|
|
analysisProfile: legacyProfile,
|
|
limitations: observed.limitations,
|
|
locations: observed.locations,
|
|
});
|
|
const binding = snapshotBinding(legacyProfile);
|
|
const identity = snapshotTarget(nativeTarget);
|
|
const snapshot = parseAnalysisSnapshot({
|
|
target: identity,
|
|
binding,
|
|
entries: [
|
|
createAnalysisSnapshotEntry({
|
|
target: identity,
|
|
binding,
|
|
operation: observed.operation,
|
|
parameters: observed.parameters,
|
|
execution: {
|
|
result,
|
|
rawResult: result,
|
|
provider: observed.provider,
|
|
analysisProfile: legacyProfile,
|
|
limitations: observed.limitations,
|
|
locations: observed.locations,
|
|
subject: nativeTarget,
|
|
},
|
|
}),
|
|
],
|
|
workflow_entries: [],
|
|
evidence_bundle: createEvidenceBundle([evidence]),
|
|
});
|
|
assert.equal(
|
|
snapshot.entries.length,
|
|
1,
|
|
"The legacy query must remain valid and replayable under its own profile",
|
|
);
|
|
const path = join(env.TMPDIR, `legacy-reference-${randomUUID()}.json`);
|
|
await writeFile(path, serializeAnalysisSnapshot(snapshot), { flag: "wx" });
|
|
try {
|
|
const session = requireMcpLifecycleResult(
|
|
await client.callTool({ name: "binary_session", arguments: {} }),
|
|
"binary_session",
|
|
);
|
|
const reply = await client.callTool({
|
|
name: "open_binary",
|
|
arguments: {
|
|
path: target.path,
|
|
provider_id: "ghidra",
|
|
snapshot_path: path,
|
|
},
|
|
});
|
|
assert.equal(reply.isError, true);
|
|
const mcpRejection = requireMcpToolError(reply);
|
|
assert.equal(mcpRejection.code, "evidence_integrity_mismatch");
|
|
assert.deepEqual(mcpRejection.details.binding_mismatch.profile_digest, {
|
|
snapshot: legacyProfile.digest,
|
|
selected: observed.analysis_profile.digest,
|
|
});
|
|
assert.match(mcpRejection.remediation.action, /fresh snapshot/u);
|
|
assert.deepEqual(
|
|
requireMcpLifecycleResult(
|
|
await client.callTool({ name: "binary_session", arguments: {} }),
|
|
"binary_session",
|
|
),
|
|
session,
|
|
"A rejected snapshot must preserve the selected session",
|
|
);
|
|
const retained = requireMcpEvidenceResult(
|
|
await client.callTool({
|
|
name: "analyze_function",
|
|
arguments: { procedure, detail: "complete" },
|
|
}),
|
|
"analyze_function",
|
|
);
|
|
assert.ok(
|
|
retained.incoming_references.some(
|
|
(edge) =>
|
|
edge.source_address === omittedEdge.source_address &&
|
|
edge.target_address === omittedEdge.target_address,
|
|
),
|
|
"A rejected legacy snapshot must not replace complete live analysis",
|
|
);
|
|
await assert.rejects(
|
|
promisify(execFile)(
|
|
process.execPath,
|
|
[
|
|
entrypoint,
|
|
"function",
|
|
target.path,
|
|
procedure,
|
|
"--provider",
|
|
"ghidra",
|
|
"--snapshot",
|
|
path,
|
|
"--json",
|
|
],
|
|
{ env, timeout: 240000, maxBuffer: 72 * 1024 * 1024 },
|
|
),
|
|
(error) => {
|
|
assert.equal(error.code, 1);
|
|
const rejection = JSON.parse(error.stdout);
|
|
assert.equal(rejection.code, "evidence_integrity_mismatch");
|
|
assert.equal(rejection.details.reason, mcpRejection.details.reason);
|
|
assert.equal(
|
|
rejection.remediation.action,
|
|
mcpRejection.remediation.action,
|
|
);
|
|
return true;
|
|
},
|
|
);
|
|
} finally {
|
|
await rm(path);
|
|
}
|
|
}
|