feat(ghidra): integrate optional NativeAOT metadata recovery (#748)
* feat(ghidra): integrate optional NativeAOT metadata recovery * fix(ghidra): bind extension snapshots to configured artifacts * test(ghidra): verify lazy NativeAOT startup failures * fix(ghidra): preserve NativeAOT failure reasons and coverage * fix(ghidra): preserve NativeAOT x64 calling conventions * test(ghidra): guard recovered NativeAOT method conventions * fix(ghidra): reject blocking extension file inputs * fix(ghidra): diagnose incompatible NativeAOT extension classes * test(ghidra): verify real extension initialization failures * fix(ghidra): keep extension descriptor fields optional
This commit is contained in:
@@ -0,0 +1,140 @@
|
||||
#!/usr/bin/env node
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import {
|
||||
mkdir,
|
||||
mkdtemp,
|
||||
readdir,
|
||||
readFile,
|
||||
rm,
|
||||
writeFile,
|
||||
} from "node:fs/promises";
|
||||
import { dirname, join, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
|
||||
const source = resolve(
|
||||
process.env.REA_NATIVEAOT_SOURCE ??
|
||||
join(root, "third_party/ghidra-nativeaot"),
|
||||
);
|
||||
const install = process.env.GHIDRA_INSTALL_DIR;
|
||||
if (!install)
|
||||
throw new Error(
|
||||
"NativeAOT build lane requires existing GHIDRA_INSTALL_DIR (Ghidra 12.1.4).",
|
||||
);
|
||||
const properties = await readFile(
|
||||
join(install, "Ghidra/application.properties"),
|
||||
"utf8",
|
||||
);
|
||||
if (!/^application.version=12\.1\.4\s*$/m.test(properties))
|
||||
throw new Error("NativeAOT build lane requires Ghidra 12.1.4.");
|
||||
const output = resolve(
|
||||
process.env.REA_NATIVEAOT_BUILD_ROOT ??
|
||||
join(root, "_reference/nativeaot-integration/extension"),
|
||||
);
|
||||
const java = process.env.JAVA_HOME ? join(process.env.JAVA_HOME, "bin") : null;
|
||||
const run = (command, args) => {
|
||||
const result = spawnSync(command, args, {
|
||||
cwd: root,
|
||||
encoding: "utf8",
|
||||
timeout: 120_000,
|
||||
maxBuffer: 4 * 1024 * 1024,
|
||||
});
|
||||
if (result.error || result.status !== 0)
|
||||
throw new Error(
|
||||
`NativeAOT build prerequisite/action ${command} failed: ${result.error?.message ?? ""}\n${result.stdout ?? ""}${result.stderr ?? ""}`,
|
||||
);
|
||||
return result.stdout.trim();
|
||||
};
|
||||
const javac = java ? join(java, "javac") : "javac";
|
||||
if (!/^javac 21(?:\.|$)/u.test(run(javac, ["-version"])))
|
||||
throw new Error(
|
||||
"NativeAOT build lane requires an existing JDK 21 javac; REA does not install or upgrade Java.",
|
||||
);
|
||||
const revision = run("git", ["-C", source, "rev-parse", "HEAD"]);
|
||||
if (
|
||||
revision !== "effeb734fc570c32650f88b159608979dc7b423e" ||
|
||||
run("git", ["-C", source, "status", "--porcelain"])
|
||||
)
|
||||
throw new Error(
|
||||
"NativeAOT build requires the clean pinned upstream source; initialize third_party/ghidra-nativeaot.",
|
||||
);
|
||||
const files = async (path, extension) => {
|
||||
const result = [];
|
||||
for (const entry of await readdir(path, { withFileTypes: true })) {
|
||||
const child = join(path, entry.name);
|
||||
if (entry.isDirectory()) result.push(...(await files(child, extension)));
|
||||
else if (entry.isFile() && child.endsWith(extension)) result.push(child);
|
||||
}
|
||||
return result.sort();
|
||||
};
|
||||
await mkdir(output, { recursive: true });
|
||||
const classes = await mkdtemp(join(output, "classes-"));
|
||||
try {
|
||||
const sources = [
|
||||
...(await files(join(source, "src/main/java"), ".java")),
|
||||
...(await files(join(root, "bridge/ghidra/extensions/nativeaot"), ".java")),
|
||||
];
|
||||
const jars = await files(join(install, "Ghidra"), ".jar");
|
||||
const args = [
|
||||
"-proc:none",
|
||||
"-cp",
|
||||
jars.join(process.platform === "win32" ? ";" : ":"),
|
||||
"-d",
|
||||
classes,
|
||||
...sources,
|
||||
];
|
||||
await writeFile(
|
||||
join(output, "javac.args"),
|
||||
args
|
||||
.map((s) => `"${s.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`)
|
||||
.join("\n"),
|
||||
);
|
||||
run(javac, [
|
||||
"-J-Xmx512m",
|
||||
"-J-XX:ActiveProcessorCount=1",
|
||||
`@${join(output, "javac.args")}`,
|
||||
]);
|
||||
await writeFile(
|
||||
join(classes, "LICENSE-ghidra-nativeaot.md"),
|
||||
await readFile(join(source, "LICENSE.md")),
|
||||
);
|
||||
const jar = join(output, "rea-ghidra-nativeaot.jar");
|
||||
run(java ? join(java, "jar") : "jar", [
|
||||
"--create",
|
||||
"--file",
|
||||
jar,
|
||||
"--date=2025-01-01T00:00:00Z",
|
||||
"-C",
|
||||
classes,
|
||||
".",
|
||||
]);
|
||||
const sha256 = createHash("sha256")
|
||||
.update(await readFile(jar))
|
||||
.digest("hex");
|
||||
await writeFile(
|
||||
join(output, "build.json"),
|
||||
JSON.stringify(
|
||||
{
|
||||
jar,
|
||||
sha256,
|
||||
upstream_revision: revision,
|
||||
ghidra_version: "12.1.4",
|
||||
integration_api: 1,
|
||||
},
|
||||
null,
|
||||
2,
|
||||
) + "\n",
|
||||
);
|
||||
console.log(
|
||||
JSON.stringify({
|
||||
jar,
|
||||
sha256,
|
||||
upstream_revision: revision,
|
||||
ghidra_version: "12.1.4",
|
||||
integration_api: 1,
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
await rm(classes, { recursive: true, force: true });
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
#!/usr/bin/env node
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
|
||||
import { dirname, join, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
|
||||
if (process.arch !== "x64" || !["linux", "win32"].includes(process.platform))
|
||||
throw new Error(
|
||||
"NativeAOT fixture lane requires Linux or Windows x64; it does not cross-compile NativeAOT.",
|
||||
);
|
||||
const runtime = process.platform === "win32" ? "win-x64" : "linux-x64";
|
||||
const directory = resolve(
|
||||
process.env.REA_NATIVEAOT_FIXTURE_ROOT ??
|
||||
join(root, "_reference/nativeaot-integration/generated"),
|
||||
);
|
||||
const output = join(directory, runtime);
|
||||
await mkdir(output, { recursive: true });
|
||||
const env = {
|
||||
...process.env,
|
||||
DOTNET_CLI_HOME: join(output, "cli-home"),
|
||||
DOTNET_CLI_TELEMETRY_OPTOUT: "1",
|
||||
DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1",
|
||||
DOTNET_PROCESSOR_COUNT: "1",
|
||||
COMPlus_GCHeapHardLimit: "30000000",
|
||||
NUGET_PACKAGES: process.env.NUGET_PACKAGES ?? join(directory, "nuget"),
|
||||
};
|
||||
await writeFile(
|
||||
join(output, "global.json"),
|
||||
JSON.stringify({ sdk: { version: "8.0.416", rollForward: "disable" } }) +
|
||||
"\n",
|
||||
);
|
||||
const run = (command, args) => {
|
||||
const result = spawnSync(command, args, {
|
||||
cwd: output,
|
||||
env,
|
||||
encoding: "utf8",
|
||||
timeout: 300_000,
|
||||
maxBuffer: 8 * 1024 * 1024,
|
||||
});
|
||||
if (result.error || result.status !== 0)
|
||||
throw new Error(
|
||||
`NativeAOT fixture lane requires/action failed ${command}: ${result.error?.message ?? ""}\n${result.stdout ?? ""}${result.stderr ?? ""}`,
|
||||
);
|
||||
return result.stdout;
|
||||
};
|
||||
const dotnet = process.env.REA_NATIVEAOT_DOTNET ?? "dotnet";
|
||||
if (run(dotnet, ["--version"]).trim() !== "8.0.416")
|
||||
throw new Error(
|
||||
"NativeAOT fixtures require existing .NET SDK 8.0.416; REA does not install SDKs.",
|
||||
);
|
||||
if (process.platform === "linux") {
|
||||
run(process.env.REA_NATIVEAOT_STRIP ?? "strip", ["--version"]);
|
||||
run(process.env.REA_NATIVEAOT_NM ?? "nm", ["--version"]);
|
||||
run(process.env.REA_NATIVEAOT_CC ?? "cc", ["--version"]);
|
||||
run("clang", ["--version"]);
|
||||
}
|
||||
const map = join(output, "NativeAotFixture.map");
|
||||
run(dotnet, [
|
||||
"publish",
|
||||
join(root, "tests/fixtures/nativeaot/NativeAotFixture.csproj"),
|
||||
"-r",
|
||||
runtime,
|
||||
"-c",
|
||||
"Release",
|
||||
"-o",
|
||||
join(output, "symbols"),
|
||||
"--maxcpucount:1",
|
||||
`-p:BaseIntermediateOutputPath=${join(output, "obj")}/`,
|
||||
`-p:BaseOutputPath=${join(output, "bin")}/`,
|
||||
`-p:NativeAotMapPath=${map}`,
|
||||
]);
|
||||
const name =
|
||||
process.platform === "win32" ? "NativeAotFixture.exe" : "NativeAotFixture";
|
||||
const binary = join(output, "symbols", name);
|
||||
let symbols = "";
|
||||
if (process.platform === "linux") {
|
||||
// Preserve the symbol table as an independent oracle while avoiding a full
|
||||
// runtime DWARF import in this metadata-specific lane.
|
||||
run(process.env.REA_NATIVEAOT_STRIP ?? "strip", ["--strip-debug", binary]);
|
||||
symbols = run(process.env.REA_NATIVEAOT_NM ?? "nm", ["-n", binary]);
|
||||
await mkdir(join(output, "stripped"), { recursive: true });
|
||||
const stripped = join(output, "stripped", name);
|
||||
await copyFile(binary, stripped);
|
||||
run(process.env.REA_NATIVEAOT_STRIP ?? "strip", ["--strip-all", stripped]);
|
||||
} else {
|
||||
symbols = await readFile(map, "utf8");
|
||||
}
|
||||
const bytes = await readFile(binary);
|
||||
const candidates = [];
|
||||
for (let offset = 0; offset <= bytes.length - 16; offset++) {
|
||||
if (
|
||||
bytes.readUInt32LE(offset) !== 0x00525452 ||
|
||||
bytes[offset + 14] !== 24 ||
|
||||
bytes[offset + 15] !== 1
|
||||
)
|
||||
continue;
|
||||
const count = bytes.readUInt16LE(offset + 12);
|
||||
if (count === 0 || count > 80 || offset + 16 + count * 24 > bytes.length)
|
||||
continue;
|
||||
candidates.push({
|
||||
offset,
|
||||
major: bytes.readUInt16LE(offset + 4),
|
||||
minor: bytes.readUInt16LE(offset + 6),
|
||||
sections: Array.from({ length: count }, (_, index) => {
|
||||
const row = offset + 16 + index * 24;
|
||||
return {
|
||||
type: bytes.readUInt32LE(row),
|
||||
flags: bytes.readUInt32LE(row + 4),
|
||||
start: `0x${bytes.readBigUInt64LE(row + 8).toString(16)}`,
|
||||
end: `0x${bytes.readBigUInt64LE(row + 16).toString(16)}`,
|
||||
};
|
||||
}),
|
||||
});
|
||||
}
|
||||
if (
|
||||
candidates.length !== 1 ||
|
||||
candidates[0].major !== 9 ||
|
||||
candidates[0].minor !== 1
|
||||
)
|
||||
throw new Error(
|
||||
"NativeAOT fixture did not produce exactly one independent RTR 9.1 directory.",
|
||||
);
|
||||
const sha256 = createHash("sha256").update(bytes).digest("hex");
|
||||
await writeFile(join(output, "symbols.txt"), symbols);
|
||||
await writeFile(
|
||||
join(output, "oracle.json"),
|
||||
JSON.stringify(
|
||||
{
|
||||
sdk: "8.0.416",
|
||||
runtime_version: "8.0.22",
|
||||
runtime,
|
||||
binary,
|
||||
sha256,
|
||||
headers: candidates,
|
||||
expected_strings: [
|
||||
"REA_NATIVEAOT_FROZEN",
|
||||
"REA_NATIVEAOT_BASE",
|
||||
"REA_NATIVEAOT_DERIVED",
|
||||
],
|
||||
},
|
||||
null,
|
||||
2,
|
||||
) + "\n",
|
||||
);
|
||||
// A source-built negative input, not a downloaded third-party target.
|
||||
if (process.platform === "linux") {
|
||||
const source = join(output, "ordinary.c");
|
||||
await writeFile(
|
||||
source,
|
||||
"int ordinary_probe(int x) { return x * 3 + 1; }\nint main(void) { return ordinary_probe(1); }\n",
|
||||
);
|
||||
run(process.env.REA_NATIVEAOT_CC ?? "cc", [
|
||||
"-g",
|
||||
"-O0",
|
||||
source,
|
||||
"-o",
|
||||
join(output, "ordinary"),
|
||||
]);
|
||||
// Small source-built producer regressions run in seconds: no executable
|
||||
// patching, large runtime import, or downloaded opaque negative inputs.
|
||||
const row = "struct Row { unsigned type, flags; const char *start, *end; };";
|
||||
const header =
|
||||
"struct Header { unsigned signature; unsigned short major, minor; unsigned flags; unsigned short count; unsigned char size, type; struct Row row; };";
|
||||
for (const kind of ["unsupported", "malformed", "ambiguous"]) {
|
||||
const major = kind === "unsupported" ? 99 : 9;
|
||||
const declaration = `const struct Header __attribute__((aligned(8))) probe = {0x00525452, ${major}, 1, 0, 1, 24, 1, {207, 1, data + 8, data}};`;
|
||||
const extra =
|
||||
kind === "ambiguous" ? declaration.replace("probe", "second_probe") : "";
|
||||
const negative = join(output, `${kind}.c`);
|
||||
await writeFile(
|
||||
negative,
|
||||
`${row}\n${header}\nconst char data[16] = {0};\n${declaration}\n${extra}\nint main(void) { return 0; }\n`,
|
||||
);
|
||||
run(process.env.REA_NATIVEAOT_CC ?? "cc", [
|
||||
"-O0",
|
||||
"-fno-pie",
|
||||
"-no-pie",
|
||||
negative,
|
||||
"-o",
|
||||
join(output, kind),
|
||||
]);
|
||||
}
|
||||
}
|
||||
console.log(
|
||||
`PASS source-built ${runtime} NativeAOT fixture, independent RTR 9.1 oracle and SHA-256 ${sha256}; no target execution`,
|
||||
);
|
||||
@@ -0,0 +1,403 @@
|
||||
#!/usr/bin/env node
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import {
|
||||
mkdtemp,
|
||||
mkdir,
|
||||
readFile,
|
||||
readdir,
|
||||
rm,
|
||||
writeFile,
|
||||
} from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { basename, isAbsolute, join, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { promisify } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { parseEvidence } from "../dist/domain/evidence.js";
|
||||
import { nativeDataTypeSchema } from "../dist/domain/nativeDataType.js";
|
||||
import { nativeLoadImageSchema } from "../dist/domain/nativeLoadImage.js";
|
||||
|
||||
const mode = process.argv[2] ?? "symbols";
|
||||
if (
|
||||
![
|
||||
"symbols",
|
||||
"stripped",
|
||||
"ordinary",
|
||||
"unsupported",
|
||||
"malformed",
|
||||
"ambiguous",
|
||||
"loader-failure",
|
||||
"default-native",
|
||||
].includes(mode) ||
|
||||
process.argv.length > 3
|
||||
)
|
||||
throw new Error(
|
||||
"Usage: verify-real-ghidra-nativeaot.mjs [symbols|stripped|ordinary|unsupported|malformed|ambiguous|loader-failure|default-native]",
|
||||
);
|
||||
if (process.platform !== "linux" || process.arch !== "x64")
|
||||
throw new Error(
|
||||
"verify:ghidra:nativeaot requires a Linux x64 host; Windows host mutation is not supported.",
|
||||
);
|
||||
for (const key of ["loader-failure", "default-native"].includes(mode)
|
||||
? ["GHIDRA_INSTALL_DIR"]
|
||||
: ["GHIDRA_INSTALL_DIR", "REA_GHIDRA_NATIVEAOT_JAR"])
|
||||
if (!process.env[key] || !isAbsolute(process.env[key]))
|
||||
throw new Error(
|
||||
`verify:ghidra:nativeaot prerequisite missing: absolute ${key}`,
|
||||
);
|
||||
const fixtureRoot = resolve(
|
||||
process.env.REA_NATIVEAOT_PROOF_FIXTURE_ROOT ??
|
||||
"_reference/nativeaot-integration/generated/linux-x64",
|
||||
);
|
||||
const oracle = JSON.parse(
|
||||
await readFile(join(fixtureRoot, "oracle.json"), "utf8"),
|
||||
);
|
||||
const symbolTarget = join(
|
||||
fixtureRoot,
|
||||
"symbols",
|
||||
oracle.runtime === "win-x64" ? "NativeAotFixture.exe" : "NativeAotFixture",
|
||||
);
|
||||
const target =
|
||||
mode === "stripped"
|
||||
? join(fixtureRoot, "stripped", basename(symbolTarget))
|
||||
: [
|
||||
"ordinary",
|
||||
"unsupported",
|
||||
"malformed",
|
||||
"ambiguous",
|
||||
"loader-failure",
|
||||
"default-native",
|
||||
].includes(mode)
|
||||
? join(
|
||||
fixtureRoot,
|
||||
["loader-failure", "default-native"].includes(mode)
|
||||
? "ordinary"
|
||||
: mode,
|
||||
)
|
||||
: symbolTarget;
|
||||
const bytes = await readFile(target);
|
||||
const sha256 = hash(bytes);
|
||||
const workspace = await mkdtemp(join(tmpdir(), "rea-nativeaot-proof-"));
|
||||
const runtime = join(workspace, "runtime");
|
||||
await mkdir(runtime);
|
||||
const packageRoot = process.env.REA_NATIVEAOT_PROOF_PACKAGE_ROOT;
|
||||
if (packageRoot !== undefined && !isAbsolute(packageRoot))
|
||||
throw new Error("REA_NATIVEAOT_PROOF_PACKAGE_ROOT must be absolute");
|
||||
const entrypoint =
|
||||
packageRoot === undefined
|
||||
? fileURLToPath(new URL("./rea.mjs", import.meta.url))
|
||||
: join(packageRoot, "scripts/rea.mjs");
|
||||
const env = {
|
||||
PATH: process.env.PATH ?? "/usr/bin:/bin",
|
||||
TMPDIR: runtime,
|
||||
REA_LOG_LEVEL: "silent",
|
||||
REA_ANALYSIS_PROVIDER: "ghidra",
|
||||
GHIDRA_INSTALL_DIR: process.env.GHIDRA_INSTALL_DIR,
|
||||
REA_GHIDRA_NATIVEAOT_JAR: process.env.REA_GHIDRA_NATIVEAOT_JAR,
|
||||
GHIDRA_HEADLESS_MAXMEM: process.env.GHIDRA_HEADLESS_MAXMEM ?? "768M",
|
||||
...(process.env.JAVA_HOME === undefined
|
||||
? {}
|
||||
: { JAVA_HOME: process.env.JAVA_HOME }),
|
||||
};
|
||||
if (mode === "default-native") delete env.REA_GHIDRA_NATIVEAOT_JAR;
|
||||
// Source-built linkage failure exercises the actual JVM loader boundary, not
|
||||
// a simulated producer report. Its class/JAR exist only in the owned workspace.
|
||||
if (mode === "loader-failure")
|
||||
env.REA_GHIDRA_NATIVEAOT_JAR = join(workspace, "bad-extension.jar");
|
||||
async function prepareLoaderFailure() {
|
||||
const source = join(workspace, "NativeAotExtension.java");
|
||||
const classes = join(workspace, "classes");
|
||||
await mkdir(classes);
|
||||
await writeFile(
|
||||
source,
|
||||
`package rea.extensions.nativeaot;
|
||||
public final class NativeAotExtension {
|
||||
static { fail(); }
|
||||
private static void fail() { throw new IllegalStateException("REA_INITIALIZER_FIXTURE"); }
|
||||
public NativeAotExtension() {}
|
||||
}
|
||||
`,
|
||||
);
|
||||
const command = (name) =>
|
||||
process.env.JAVA_HOME === undefined
|
||||
? name
|
||||
: join(process.env.JAVA_HOME, "bin", name);
|
||||
await promisify(execFile)(
|
||||
command("javac"),
|
||||
["-J-Xmx512m", "-J-XX:ActiveProcessorCount=1", "-d", classes, source],
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
await promisify(execFile)(
|
||||
command("jar"),
|
||||
["--create", "--file", env.REA_GHIDRA_NATIVEAOT_JAR, "-C", classes, "."],
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
}
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
env,
|
||||
stderr: "pipe",
|
||||
});
|
||||
const client = new Client({ name: "rea-nativeaot-proof", version: "1" });
|
||||
let stderr = "";
|
||||
transport.stderr?.on("data", (chunk) => {
|
||||
stderr = (stderr + chunk.toString()).slice(-65536);
|
||||
});
|
||||
let opened = false;
|
||||
let report;
|
||||
try {
|
||||
if (mode === "loader-failure") await prepareLoaderFailure();
|
||||
await client.connect(transport);
|
||||
const response = await client.callTool(
|
||||
{ name: "open_binary", arguments: { path: target, provider_id: "ghidra" } },
|
||||
{ timeout: 360000 },
|
||||
);
|
||||
if (
|
||||
["unsupported", "malformed", "ambiguous", "loader-failure"].includes(mode)
|
||||
) {
|
||||
// MCP open binds a lazy session; the first inspection starts import.
|
||||
let failure = response;
|
||||
if (failure.isError !== true) {
|
||||
opened = true;
|
||||
failure = await client.callTool(
|
||||
{ name: "inspect_native_load_image", arguments: {} },
|
||||
{ timeout: 360000 },
|
||||
);
|
||||
}
|
||||
assert.equal(failure.isError, true, JSON.stringify(failure));
|
||||
const diagnostic = JSON.stringify(failure);
|
||||
assert.match(
|
||||
diagnostic,
|
||||
mode === "unsupported"
|
||||
? /Unsupported NativeAOT RTR format/
|
||||
: mode === "malformed"
|
||||
? /Reversed NativeAOT section/
|
||||
: mode === "loader-failure"
|
||||
? /ExceptionInInitializerError.*REA_INITIALIZER_FIXTURE/
|
||||
: /Ambiguous NativeAOT directory candidates/,
|
||||
);
|
||||
report = { mode, target, sha256, typed_failure: failure };
|
||||
} else if (mode === "default-native") {
|
||||
assert.notEqual(response.isError, true, JSON.stringify(response));
|
||||
opened = true;
|
||||
const image = nativeLoadImageSchema.parse(
|
||||
await call("inspect_native_load_image"),
|
||||
);
|
||||
assert.equal(image.observations.metadata_recovery, undefined);
|
||||
report = { mode, target, sha256, image };
|
||||
} else {
|
||||
assert.notEqual(response.isError, true, JSON.stringify(response));
|
||||
opened = true;
|
||||
const image = nativeLoadImageSchema.parse(
|
||||
await call("inspect_native_load_image"),
|
||||
);
|
||||
const summary = image.observations.metadata_recovery?.[0];
|
||||
assert.ok(
|
||||
summary,
|
||||
"Loaded-image inspection omitted inline runtime-format discovery",
|
||||
);
|
||||
assert.equal(summary.format, "dotnet-nativeaot");
|
||||
assert.equal(
|
||||
summary.analysis_artifact_sha256,
|
||||
hash(await readFile(env.REA_GHIDRA_NATIVEAOT_JAR)),
|
||||
);
|
||||
if (mode === "ordinary") {
|
||||
assert.equal(summary.status, "not_applicable");
|
||||
assert.equal(summary.method_tables, 0);
|
||||
assert.deepEqual(summary.types, []);
|
||||
report = { mode, target, sha256, summary };
|
||||
} else {
|
||||
assert.ok(["complete", "partial"].includes(summary.status));
|
||||
assert.equal(summary.format_major, 9);
|
||||
assert.equal(summary.format_minor, 1);
|
||||
assert.equal(summary.types.length, summary.method_tables);
|
||||
assert.ok(summary.method_tables > 0);
|
||||
assert.equal(
|
||||
summary.discovery,
|
||||
mode === "stripped" || oracle.runtime === "win-x64"
|
||||
? "signature-heuristic"
|
||||
: "symbol",
|
||||
);
|
||||
assert.equal(summary.derived_memory.file_offset, null);
|
||||
assert.ok(summary.coverage.frozen_objects_annotated > 0);
|
||||
// Independent compiler/linker symbols identify fixture classes. Recovered
|
||||
// Class_address names are never treated as the original source identities.
|
||||
const symbols = await readFile(join(fixtureRoot, "symbols.txt"), "utf8");
|
||||
const bias =
|
||||
oracle.runtime === "linux-x64"
|
||||
? BigInt(image.observations.image_base)
|
||||
: 0n;
|
||||
const addressOf = (name) => {
|
||||
const line = symbols
|
||||
.split(/\r?\n/u)
|
||||
.find((line) => line.split(/\s+/u).includes(name));
|
||||
assert.ok(line, `Independent symbol missing: ${name}`);
|
||||
const match =
|
||||
oracle.runtime === "linux-x64"
|
||||
? line.match(/^([a-f0-9]+)\s/iu)
|
||||
: line.match(/\s([a-f0-9]{16})\s/iu);
|
||||
assert.ok(match, `Unrecognized independent symbol line: ${line}`);
|
||||
return `0x${(BigInt(`0x${match[1]}`) + bias).toString(16)}`;
|
||||
};
|
||||
const fixtureSymbols =
|
||||
oracle.symbols ??
|
||||
(oracle.runtime === "win-x64"
|
||||
? {
|
||||
base: "??_7NativeAotFixture_BaseProbe@@6B@",
|
||||
derived: "??_7NativeAotFixture_DerivedProbe@@6B@",
|
||||
interface: "??_7NativeAotFixture_IProbe@@6B@",
|
||||
compute: "NativeAotFixture_DerivedProbe__Compute",
|
||||
dispatch: "NativeAotFixture_Program__Dispatch",
|
||||
}
|
||||
: {
|
||||
base: "_ZTV26NativeAotFixture_BaseProbe",
|
||||
derived: "_ZTV29NativeAotFixture_DerivedProbe",
|
||||
interface: "_ZTV23NativeAotFixture_IProbe",
|
||||
compute: "NativeAotFixture_DerivedProbe__Compute",
|
||||
dispatch: "NativeAotFixture_Program__Dispatch",
|
||||
});
|
||||
const lookup = (address) => {
|
||||
const identity = summary.types.find((type) => type.address === address);
|
||||
assert.ok(identity?.type, `Recovered identity missing at ${address}`);
|
||||
return identity.type;
|
||||
};
|
||||
const derivedAddress = addressOf(fixtureSymbols.derived);
|
||||
const baseAddress = addressOf(fixtureSymbols.base);
|
||||
const interfaceAddress = addressOf(fixtureSymbols.interface);
|
||||
const derived = nativeDataTypeSchema.parse(
|
||||
await call("inspect_native_data_type", {
|
||||
type: lookup(derivedAddress),
|
||||
}),
|
||||
);
|
||||
const metadata = derived.metadata_recovery;
|
||||
assert.ok(metadata);
|
||||
assert.equal(metadata.original_name, null);
|
||||
assert.equal(metadata.name_origin, "generated");
|
||||
assert.equal(metadata.method_table_address, derivedAddress);
|
||||
assert.equal(metadata.related_type.address, baseAddress);
|
||||
assert.ok(
|
||||
metadata.interfaces.some((type) => type.address === interfaceAddress),
|
||||
);
|
||||
assert.ok(
|
||||
metadata.virtual_slots.some(
|
||||
(slot) => slot.target_address === addressOf(fixtureSymbols.compute),
|
||||
),
|
||||
);
|
||||
const compute = await call("analyze_function", {
|
||||
procedure: addressOf(fixtureSymbols.compute),
|
||||
});
|
||||
assert.ok(compute.pseudocode.trim());
|
||||
assert.doesNotMatch(
|
||||
compute.pseudocode,
|
||||
/\b__thiscall\b/u,
|
||||
"Upstream x64 calling-convention rewrite leaked into recovered pseudocode",
|
||||
);
|
||||
assert.match(compute.pseudocode, /(?:0xb|\b11\b|<<)/u);
|
||||
const dispatch = await call("analyze_function", {
|
||||
procedure: addressOf(fixtureSymbols.dispatch),
|
||||
});
|
||||
assert.ok(dispatch.pseudocode.trim());
|
||||
for (const literal of oracle.expected_strings)
|
||||
assert.ok(
|
||||
(await call("search_strings", { pattern: literal })).length > 0,
|
||||
`Frozen string missing: ${literal}`,
|
||||
);
|
||||
const observed = await call("read_bytes", {
|
||||
address: metadata.virtual_slots[0].slot_address,
|
||||
length: 8,
|
||||
});
|
||||
assert.equal(observed.complete, true);
|
||||
assert.equal(
|
||||
`0x${Buffer.from(observed.bytes_hex, "hex").readBigUInt64LE().toString(16)}`,
|
||||
metadata.virtual_slots[0].target_address,
|
||||
);
|
||||
report = { mode, target, sha256, summary, derived, compute, dispatch };
|
||||
await call("close_binary");
|
||||
opened = false;
|
||||
// One representative CLI boundary, selected explicitly to avoid repeated
|
||||
// full NativeAOT auto-analysis during each focused iteration.
|
||||
if (process.env.REA_NATIVEAOT_PROOF_CLI === "1") {
|
||||
const { stdout } = await promisify(execFile)(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"inspect-native-data-type",
|
||||
target,
|
||||
"--type",
|
||||
lookup(derivedAddress),
|
||||
"--provider",
|
||||
"ghidra",
|
||||
"--json",
|
||||
],
|
||||
{ env, timeout: 360000, maxBuffer: 16 * 1024 * 1024 },
|
||||
);
|
||||
const evidence = parseEvidence(JSON.parse(stdout));
|
||||
assert.equal(evidence.subject.digest.sha256, sha256);
|
||||
assert.deepEqual(
|
||||
evidence.normalized_result.metadata_recovery,
|
||||
metadata,
|
||||
);
|
||||
report.cli_metadata = evidence.normalized_result.metadata_recovery;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert.equal(
|
||||
hash(await readFile(target)),
|
||||
sha256,
|
||||
"Input executable changed",
|
||||
);
|
||||
if (opened) {
|
||||
await call("close_binary");
|
||||
opened = false;
|
||||
}
|
||||
await client.close();
|
||||
assert.deepEqual(
|
||||
await readdir(runtime),
|
||||
[],
|
||||
"Owned runtime/project/extension files leaked after close",
|
||||
);
|
||||
const capture = process.env.REA_NATIVEAOT_PROOF_CAPTURE_DIR;
|
||||
if (capture !== undefined) {
|
||||
assert.ok(isAbsolute(capture));
|
||||
await mkdir(capture, { recursive: true });
|
||||
await writeFile(
|
||||
join(capture, `${oracle.runtime}-${mode}.json`),
|
||||
JSON.stringify(report, null, 2) + "\n",
|
||||
);
|
||||
}
|
||||
console.log(
|
||||
`PASS real Ghidra NativeAOT ${oracle.runtime}/${mode}: MCP metadata, source identity and owned cleanup${report?.compute ? ", independent type/slot oracle and pseudocode" : ""}${report?.cli_metadata ? ", equivalent CLI" : ""}`,
|
||||
);
|
||||
} catch (error) {
|
||||
console.error(stderr);
|
||||
throw error;
|
||||
} finally {
|
||||
if (opened)
|
||||
await client
|
||||
.callTool({ name: "close_binary", arguments: {} })
|
||||
.catch(() => {});
|
||||
await client.close().catch(() => {});
|
||||
await rm(workspace, { recursive: true, force: true });
|
||||
}
|
||||
function hash(bytes) {
|
||||
return createHash("sha256").update(bytes).digest("hex");
|
||||
}
|
||||
async function call(name, args = {}) {
|
||||
const response = await client.callTool(
|
||||
{ name, arguments: args },
|
||||
{ timeout: 360000 },
|
||||
);
|
||||
assert.notEqual(response.isError, true, JSON.stringify(response));
|
||||
if (name === "close_binary") return response.structuredContent;
|
||||
const evidence = parseEvidence(response.structuredContent.evidence);
|
||||
assert.equal(evidence.subject.digest.sha256, sha256);
|
||||
assert.deepEqual(
|
||||
evidence.normalized_result,
|
||||
response.structuredContent.result,
|
||||
);
|
||||
return response.structuredContent.result;
|
||||
}
|
||||
Reference in New Issue
Block a user