mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 14:05:49 +00:00
* refactor(verify): run Ghidra verifier commands through the supervised owner (2 of 2) Route the remaining Ghidra verifier compiler and CLI launches through createVerifierCommands, close that owner before lineage observation, and assert the raw arm64 alignment refusal from its structured error. * fix(verify): stop detached Ghidra verifier commands on interrupt SIGINT and SIGTERM abort the command owner and the scripts wait for its cleanup, so a compiler started in its own process group cannot outlive the verifier. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(verify): stop Ghidra verifier analysis when interrupted Pass the verifier interruption signal into MCP and Ghidra waits, and stop waiting for calls that cannot observe it, so SIGINT does not continue the analysis before cleanup. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(verify): stop the switch evidence probe when the verifier is interrupted Pass the verifier interruption signal into the detached Ghidra control probe and end its wait so supervisor.stop() runs before a later SIGKILL. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(verify): observe work already started when a verifier interrupt wins untilInterrupted now settles the caller's promise after the signal has already aborted, so a connection started just before the check cannot reject with nobody listening. Co-authored-by: morluto <morluto@users.noreply.github.com> * refactor(verify): share verifier interrupt handling and keep it through release Move the SIGINT/SIGTERM abort wiring into bindVerifierCommandInterruption. Handlers stay installed until after fixture release, and untilInterrupted still observes a promise that was already started. Co-authored-by: morluto <morluto@users.noreply.github.com> * fix(verify): keep diagnostic workspaces and stop fixture builds on interrupt Check the interruption signal after finalization and before the fixture root is removed. MIPS and RISC-V fixture compilers and readers now run through the verifier command owner, so SIGTERM aborts them instead of waiting out their execFile deadline. Co-authored-by: morluto <morluto@users.noreply.github.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com> Co-authored-by: morluto <morluto@users.noreply.github.com>
453 lines
15 KiB
JavaScript
453 lines
15 KiB
JavaScript
#!/usr/bin/env node
|
|
import { withVerifierCleanup } from "./lib/verifier-cleanup.mjs";
|
|
import assert from "node:assert/strict";
|
|
import {
|
|
requireMcpOperationResult,
|
|
requireMcpOutput,
|
|
} from "./lib/mcp-verifier-results.mjs";
|
|
import { createHash } from "node:crypto";
|
|
import {
|
|
copyFile,
|
|
mkdir,
|
|
readFile,
|
|
readdir,
|
|
writeFile,
|
|
} from "node:fs/promises";
|
|
import { join, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { parseArgs } from "node:util";
|
|
import { Client } from "@modelcontextprotocol/client";
|
|
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
|
import {
|
|
buildSwitchSource,
|
|
switchSymbolOracle,
|
|
assertCompiledSwitchOracle,
|
|
} from "../tests/conformance/ghidra/switch-fixture.mjs";
|
|
import {
|
|
assertSwitchBoundary,
|
|
assertSwitchOracleControls,
|
|
} from "./verify-real-ghidra-switch-assertions.mjs";
|
|
import { createVerifierCommands } from "./lib/verify-commands.mjs";
|
|
import { bindVerifierCommandInterruption } from "./lib/verifier-command-interruption.mjs";
|
|
import {
|
|
assertVerifierCleanupComplete,
|
|
createVerifierRun,
|
|
completeVerifierRun,
|
|
} from "./lib/verifier-run.mjs";
|
|
import { verifySwitchEvidenceControls } from "./verify-real-ghidra-switch-controls.mjs";
|
|
import {
|
|
VerifierFixture,
|
|
withVerifierFixture,
|
|
} from "./lib/verifier-fixture.mjs";
|
|
|
|
// Narrow compiler-shape lane; no cross compiler or game artifact prerequisites.
|
|
const { values } = parseArgs({
|
|
options: {
|
|
"compiler-oracle-only": { type: "boolean", default: false },
|
|
entrypoint: { type: "string" },
|
|
},
|
|
});
|
|
const compilerOnly = values["compiler-oracle-only"];
|
|
const entrypoint =
|
|
values.entrypoint === undefined
|
|
? fileURLToPath(new URL("./rea.mjs", import.meta.url))
|
|
: resolve(values.entrypoint);
|
|
assert.ok(
|
|
process.platform === "linux" && process.arch === "x64",
|
|
"Ghidra switch compiler lane requires Linux x64; macOS/Windows and cross targets use their separate provider lanes.",
|
|
);
|
|
// Compiler, reader and CLI launches share one command owner, including the
|
|
// pre-workspace version probes. A timeout stops that process group.
|
|
const commands = await createVerifierCommands();
|
|
const commandInterruption = bindVerifierCommandInterruption(commands);
|
|
const execOwned = commandInterruption.exec;
|
|
const { untilInterrupted, throwIfInterrupted } = commandInterruption;
|
|
const finishCommandInterruption = () => commandInterruption.finish();
|
|
const toolchain = {
|
|
gcc: process.env.REA_GCC ?? "gcc",
|
|
clang: process.env.REA_CLANG ?? "clang",
|
|
nm: process.env.REA_NM ?? "nm",
|
|
objdump: process.env.REA_OBJDUMP ?? "objdump",
|
|
strip: process.env.REA_STRIP ?? "strip",
|
|
};
|
|
const versions = {};
|
|
try {
|
|
for (const [role, command] of Object.entries(toolchain)) {
|
|
try {
|
|
const { stdout } = await execOwned(command, ["--version"]);
|
|
versions[role] = stdout.split("\n")[0];
|
|
} catch (cause) {
|
|
if (commandInterruption.signal.aborted) throw cause;
|
|
throw new Error(
|
|
`Ghidra switch compiler lane prerequisite missing: ${role} '${command}'`,
|
|
{ cause },
|
|
);
|
|
}
|
|
}
|
|
} catch (cause) {
|
|
try {
|
|
await commands.close();
|
|
} catch (closeCause) {
|
|
throw new AggregateError(
|
|
[cause, closeCause],
|
|
"Switch toolchain probe failed and command cleanup failed",
|
|
);
|
|
}
|
|
throw cause;
|
|
}
|
|
let installation;
|
|
try {
|
|
if (!compilerOnly) {
|
|
const { inspectVerifierGhidraInstallation } =
|
|
await import("./lib/ghidra-installation-inspection.mjs");
|
|
assert.ok(
|
|
process.env.GHIDRA_INSTALL_DIR,
|
|
"Ghidra switch lane prerequisite missing: GHIDRA_INSTALL_DIR (bring your own)",
|
|
);
|
|
installation = await inspectVerifierGhidraInstallation({
|
|
environment: process.env,
|
|
installDir: process.env.GHIDRA_INSTALL_DIR,
|
|
...(process.env.JAVA_HOME === undefined
|
|
? {}
|
|
: { javaHome: process.env.JAVA_HOME }),
|
|
});
|
|
assert.equal(
|
|
installation.status,
|
|
"available",
|
|
JSON.stringify(installation),
|
|
);
|
|
}
|
|
} catch (cause) {
|
|
try {
|
|
await commands.close();
|
|
} catch (closeCause) {
|
|
throw new AggregateError(
|
|
[cause, closeCause],
|
|
"Switch prerequisite check failed and command cleanup failed",
|
|
);
|
|
}
|
|
throw cause;
|
|
}
|
|
const run = createVerifierRun();
|
|
// Ghidra children use the workspace as TMPDIR; a plain root admits them on every host.
|
|
const workspaceFixture = await VerifierFixture.open({
|
|
prefix: "rea-switch-proof-",
|
|
private: false,
|
|
});
|
|
const workspace = workspaceFixture.path;
|
|
const retainWorkspace = (message, options) => {
|
|
workspaceFixture.retain(message);
|
|
return new Error(message, options);
|
|
};
|
|
const runtime = join(workspace, "runtime");
|
|
await mkdir(runtime);
|
|
const source = join(workspace, "switch.c");
|
|
await writeFile(source, buildSwitchSource());
|
|
const flags = ["-O2", "-g", "-fno-pie", "-no-pie"];
|
|
const results = [];
|
|
let productionControls = null;
|
|
// The workspace is removed only once no owned runtime or process survives.
|
|
let lifecycle;
|
|
workspaceFixture.releaseAfter(async () => {
|
|
assert.deepEqual(
|
|
(await readdir(runtime)).filter((name) => name.startsWith("rea-ghidra-")),
|
|
[],
|
|
"Owned Ghidra runtime survived close",
|
|
);
|
|
lifecycle = await completeVerifierRun(run);
|
|
assertVerifierCleanupComplete(lifecycle.process_lineage);
|
|
});
|
|
commandInterruption.retainWorkspaceIfInterrupted(workspaceFixture);
|
|
await withVerifierFixture(workspaceFixture, async () => {
|
|
let primaryFailure;
|
|
try {
|
|
for (const compiler of ["gcc", "clang"]) {
|
|
const original = join(workspace, `${compiler}-optimized`);
|
|
await execOwned(toolchain[compiler], [...flags, source, "-o", original]);
|
|
const bytes = await readFile(original);
|
|
const { stdout: symbols } = await execOwned(toolchain.nm, [
|
|
"-n",
|
|
original,
|
|
]);
|
|
const { stdout: disassembly } = await execOwned(toolchain.objdump, [
|
|
"-d",
|
|
original,
|
|
]);
|
|
const fixtures = assertCompiledSwitchOracle(
|
|
bytes,
|
|
switchSymbolOracle(symbols),
|
|
disassembly,
|
|
);
|
|
const oracleFaultControls = assertSwitchOracleControls(fixtures);
|
|
if (!compilerOnly && productionControls === null) {
|
|
throwIfInterrupted();
|
|
productionControls = await verifySwitchEvidenceControls({
|
|
installation,
|
|
entrypoint,
|
|
target: original,
|
|
workspace,
|
|
runId: run.run_id,
|
|
signal: commandInterruption.signal,
|
|
});
|
|
assert.equal(
|
|
digest(await readFile(original)),
|
|
digest(bytes),
|
|
"Guard changed compiler-oracled input",
|
|
);
|
|
}
|
|
const stripped = join(workspace, `${compiler}-stripped`);
|
|
await copyFile(original, stripped);
|
|
await execOwned(toolchain.strip, ["--strip-all", stripped]);
|
|
// Byte/physical target oracle survives removal of the names that REA could use.
|
|
assertCompiledSwitchOracle(
|
|
await readFile(stripped),
|
|
fixtures,
|
|
disassembly,
|
|
);
|
|
for (const [variant, path] of [
|
|
["optimized", original],
|
|
["stripped", stripped],
|
|
]) {
|
|
const sha256 = digest(await readFile(path));
|
|
const observation = compilerOnly
|
|
? null
|
|
: await verifyTarget(path, sha256, fixtures, variant);
|
|
assert.equal(
|
|
digest(await readFile(path)),
|
|
sha256,
|
|
"REA analysis changed original compiled fixture",
|
|
);
|
|
results.push({
|
|
compiler,
|
|
variant,
|
|
oracle_fault_controls: oracleFaultControls,
|
|
sha256,
|
|
compiler_oracle: fixtures.map(
|
|
({
|
|
name,
|
|
address,
|
|
dispatch_address,
|
|
table_address,
|
|
slots,
|
|
default_address,
|
|
}) => ({
|
|
name,
|
|
address,
|
|
dispatch_address,
|
|
table_address,
|
|
slots,
|
|
default_address,
|
|
}),
|
|
),
|
|
observation,
|
|
});
|
|
}
|
|
}
|
|
} catch (cause) {
|
|
primaryFailure = cause;
|
|
}
|
|
// Close the command owner before release observes the parent tree.
|
|
let cleanupFailure;
|
|
try {
|
|
await workspaceFixture.closeEarly([() => commands.close()]);
|
|
} catch (cause) {
|
|
cleanupFailure = cause;
|
|
}
|
|
if (cleanupFailure !== undefined || primaryFailure !== undefined)
|
|
throw retainWorkspace(
|
|
`Switch verification failed; retained diagnostic workspace: ${workspace}`,
|
|
{
|
|
cause:
|
|
cleanupFailure === undefined
|
|
? primaryFailure
|
|
: primaryFailure === undefined
|
|
? cleanupFailure
|
|
: new AggregateError(
|
|
[primaryFailure, cleanupFailure],
|
|
"Switch verification and command cleanup both failed",
|
|
),
|
|
},
|
|
);
|
|
const interrupted = commandInterruption.reason();
|
|
if (interrupted !== undefined)
|
|
throw retainWorkspace(
|
|
`Switch verification interrupted; retained diagnostic workspace: ${workspace}`,
|
|
{ cause: interrupted },
|
|
);
|
|
});
|
|
const releaseInterrupted = finishCommandInterruption();
|
|
if (releaseInterrupted !== undefined) throw releaseInterrupted;
|
|
process.stdout.write(
|
|
`${JSON.stringify({ lane: "linux-x64-compiler-switch", compiler_only: compilerOnly, entrypoint, versions, compiler_flags: flags, verifier_run: lifecycle, production_controls: productionControls, results, limitations: ["Exact compiler oracle admits absolute 8-byte native x86-64 ELF tables and fails explicitly when a compiler changes lowering.", "Compiled binaries are analyzed read-only; target programs are never executed.", "Comparison-only control proves absence of a fabricated table and preservation of provider limitations, not recovery of C source.", "Detached Ghidra object controls exercise actual bridge methods through reflection; they do not claim naturally compiled ambiguous dispatches.", "CLI/MCP comparison covers switch observations, excluding process-specific Evidence IDs."], cleanup: "complete" })}\n`,
|
|
);
|
|
|
|
function digest(bytes) {
|
|
return createHash("sha256").update(bytes).digest("hex");
|
|
}
|
|
async function verifyTarget(path, sha256, fixtures, variant) {
|
|
const env = {
|
|
PATH: process.env.PATH ?? "/usr/bin:/bin",
|
|
TMPDIR: runtime,
|
|
REA_LOG_LEVEL: "silent",
|
|
REA_ANALYSIS_PROVIDER: "ghidra",
|
|
REA_PROCESS_RUN_ID: run.run_id,
|
|
GHIDRA_INSTALL_DIR: process.env.GHIDRA_INSTALL_DIR,
|
|
...(process.env.JAVA_HOME === undefined
|
|
? {}
|
|
: { JAVA_HOME: process.env.JAVA_HOME }),
|
|
};
|
|
const transport = new StdioClientTransport({
|
|
command: process.execPath,
|
|
args: [entrypoint, "mcp"],
|
|
env,
|
|
stderr: "pipe",
|
|
});
|
|
const client = new Client({ name: "rea-real-switch-proof", version: "1" });
|
|
let opened = false;
|
|
let stderr = "";
|
|
const observations = [];
|
|
return withVerifierCleanup(async () => {
|
|
await untilInterrupted(
|
|
client.connect(transport, { signal: commandInterruption.signal }),
|
|
);
|
|
transport.stderr?.on("data", (chunk) => {
|
|
stderr = (stderr + chunk.toString()).slice(-65536);
|
|
});
|
|
const target = await call(client, "open_binary", {
|
|
path,
|
|
provider_id: "ghidra",
|
|
});
|
|
opened = true;
|
|
assert.equal(target.sha256, sha256);
|
|
assert.equal(target.architecture, "x86_64");
|
|
assert.equal(target.format, "elf");
|
|
const procedures = await call(client, "list_procedures");
|
|
for (const fixture of fixtures) {
|
|
const observationFixture = {
|
|
...fixture,
|
|
allow_unsigned_32_labels:
|
|
variant === "stripped" && fixture.name === "negative",
|
|
};
|
|
const procedure = procedures.find(
|
|
({ address }) => address === fixture.address,
|
|
);
|
|
assert.ok(
|
|
procedure,
|
|
`Source-owned function at ${fixture.address} not discovered in optimized/stripped fixture`,
|
|
);
|
|
const observed = await toolResult(client, "inspect_native_api", {
|
|
procedure: procedure.address,
|
|
});
|
|
assertWorkflowIdentity(observed, sha256);
|
|
assert.equal(
|
|
observed.normalized_result.procedure.address,
|
|
procedure.address,
|
|
);
|
|
const summary = assertSwitchBoundary(
|
|
observed.normalized_result.boundary,
|
|
observationFixture,
|
|
);
|
|
assert.deepEqual(
|
|
[...observed.normalized_result.residual_unknowns].sort(),
|
|
expectedResidualUnknowns(
|
|
observed.normalized_result.boundary,
|
|
fixture,
|
|
).sort(),
|
|
"Residual unknowns must preserve unresolved ABI types and exactly the expected switch uncertainty",
|
|
);
|
|
const cli = await cliSwitchEvidence(
|
|
entrypoint,
|
|
path,
|
|
procedure.address,
|
|
env,
|
|
);
|
|
assertWorkflowIdentity(cli, sha256);
|
|
assert.equal(cli.normalized_result.procedure.address, procedure.address);
|
|
assertSwitchBoundary(cli.normalized_result.boundary, observationFixture);
|
|
assert.deepEqual(
|
|
cli.normalized_result.boundary.jump_tables,
|
|
observed.normalized_result.boundary.jump_tables,
|
|
"CLI/MCP switch mappings/defaults/data-source evidence differ",
|
|
);
|
|
assert.deepEqual(
|
|
cli.normalized_result.residual_unknowns,
|
|
observed.normalized_result.residual_unknowns,
|
|
);
|
|
observations.push({
|
|
name: fixture.name,
|
|
...summary,
|
|
cli_mcp_equal: true,
|
|
limitations: observed.normalized_result.boundary.limitations,
|
|
residual_unknowns: observed.normalized_result.residual_unknowns,
|
|
jump_tables: observed.normalized_result.boundary.jump_tables,
|
|
});
|
|
}
|
|
return { observations, stderr };
|
|
}, [
|
|
async () => {
|
|
if (opened) await call(client, "close_binary");
|
|
},
|
|
() => client.close(),
|
|
() => transport.close(),
|
|
]);
|
|
}
|
|
function assertWorkflowIdentity(evidence, sha256) {
|
|
assert.equal(evidence.subject.identity.sha256, sha256);
|
|
assert.equal(evidence.operation, "inspect_native_api");
|
|
assert.equal(evidence.provider.id, "rea-workflow");
|
|
assert.equal(evidence.analysis_profile.provider.id, "rea-workflow");
|
|
assert.equal(
|
|
evidence.analysis_profile.parameters.upstream_analysis_profile.parameters
|
|
.language_id,
|
|
"auto-from-header",
|
|
);
|
|
}
|
|
|
|
function expectedResidualUnknowns(boundary, fixture) {
|
|
const unknowns = [boundary.return_type, ...boundary.parameters]
|
|
.filter(({ confidence }) => confidence === "low")
|
|
.map(
|
|
({ role, data_type: type }) =>
|
|
`Can the inferred ${role} type ${type} be confirmed with imported metadata or an ABI probe?`,
|
|
);
|
|
if (fixture.unsafe_integer)
|
|
unknowns.push(
|
|
`Which source-level case values correspond to every target dispatched at ${boundary.jump_tables[0].dispatch_address}?`,
|
|
);
|
|
return [...new Set(unknowns)];
|
|
}
|
|
async function toolResult(client, name, arguments_ = {}) {
|
|
throwIfInterrupted();
|
|
const result = await client.callTool(
|
|
{ name, arguments: arguments_ },
|
|
{ timeout: 240000, signal: commandInterruption.signal },
|
|
);
|
|
assert.ok(result.structuredContent, `${name} omitted structured result`);
|
|
return requireMcpOutput(result, name);
|
|
}
|
|
async function call(client, name, arguments_ = {}) {
|
|
throwIfInterrupted();
|
|
const result = await client.callTool(
|
|
{ name, arguments: arguments_ },
|
|
{ timeout: 240000, signal: commandInterruption.signal },
|
|
);
|
|
return requireMcpOperationResult(result, name);
|
|
}
|
|
|
|
async function cliSwitchEvidence(entrypoint, path, procedure, env) {
|
|
const { stdout } = await execOwned(
|
|
process.execPath,
|
|
[
|
|
entrypoint,
|
|
"inspect-native-api",
|
|
path,
|
|
procedure,
|
|
"--provider",
|
|
"ghidra",
|
|
"--json",
|
|
],
|
|
{ env, timeout: 240000, maxBuffer: 16 * 1024 * 1024 },
|
|
);
|
|
return JSON.parse(stdout);
|
|
}
|