reverseport 0.0.0-stage → 1.2.0

package/dist/ghidra/GhidraSessionValues.js

@@ -0,0 +1,86 @@
+import { ghidraSeedReportSchema } from "./GhidraAnalysisSeeds.js";
+import { z } from "zod";
+import { err, ok } from "../domain/result.js";
+import { GHIDRA_INVENTORY_OPERATIONS, GHIDRA_NAMING_OPERATIONS, } from "./GhidraInventoryValues.js";
+import { GHIDRA_FUNCTION_OPERATIONS } from "./GhidraFunctionValues.js";
+import { ghidraExtensionResultSchema } from "./extensions/GhidraExtensions.js";
+import { GHIDRA_MIPS_SOFT_FLOAT_STORAGE } from "./GhidraMipsProfile.js";
+/** Exact methods proved by the bridge handshake after auto-analysis. */
+export const GHIDRA_SESSION_CAPABILITIES = [
+    "ping",
+    "shutdown",
+    ...GHIDRA_INVENTORY_OPERATIONS,
+    ...GHIDRA_FUNCTION_OPERATIONS,
+];
+/** Methods that edit the session database; read-only bridges omit them. */
+export const GHIDRA_MUTATING_OPERATIONS = new Set([
+    "annotate_native_function",
+    ...GHIDRA_NAMING_OPERATIONS,
+]);
+const capabilitySchema = z.enum(GHIDRA_SESSION_CAPABILITIES);
+const sessionInfoSchema = z
+    .object({
+    name: z.literal("REA Ghidra bridge"),
+    run_id: z.string().uuid(),
+    profile_digest: z.string().regex(/^[a-f0-9]{64}$/u),
+    provider: z
+        .object({
+        id: z.literal("ghidra"),
+        version: z.string().min(1),
+    })
+        .strict(),
+    read_only: z.boolean(),
+    analysis_complete: z.boolean(),
+    analysis_timed_out: z.boolean(),
+    analysis_extensions: z.array(ghidraExtensionResultSchema).optional(),
+    analysis_seeds: ghidraSeedReportSchema.optional(),
+    mips_soft_float_storage: z
+        .object({
+        policy: z.literal(GHIDRA_MIPS_SOFT_FLOAT_STORAGE),
+        functions: z.number().int().nonnegative(),
+        definitions: z.number().int().nonnegative(),
+    })
+        .strict()
+        .optional(),
+    capabilities: z.array(capabilitySchema),
+    target: z
+        .object({
+        name: z.string().min(1),
+        language_id: z.string().min(1),
+        compiler_spec_id: z.string().min(1),
+        image_base: z.string().regex(/^0x[0-9a-f]+$/u),
+        default_address_space: z.string().min(1),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    })
+        .strict(),
+})
+    .strict();
+/** Require exact run, provider, and profile identity from the Java bridge. */
+export const parseGhidraSessionInfo = (value, expected) => {
+    const parsed = sessionInfoSchema.safeParse(value);
+    const readOnly = expected.expectedReadOnly ?? false;
+    const expectedCapabilities = GHIDRA_SESSION_CAPABILITIES.filter((capability) => !readOnly || !GHIDRA_MUTATING_OPERATIONS.has(capability));
+    if (!parsed.success ||
+        parsed.data.run_id !== expected.runId ||
+        parsed.data.read_only !== readOnly ||
+        parsed.data.capabilities.length !== expectedCapabilities.length ||
+        parsed.data.provider.version !== expected.providerVersion ||
+        parsed.data.profile_digest !== expected.profileDigest ||
+        parsed.data.target.sha256 !== expected.targetSha256 ||
+        (expected.expectedLanguageId !== undefined &&
+            parsed.data.target.language_id !== expected.expectedLanguageId) ||
+        (expected.expectedCompilerSpecId !== undefined &&
+            parsed.data.target.compiler_spec_id !==
+                expected.expectedCompilerSpecId) ||
+        new Set(parsed.data.capabilities).size !== expectedCapabilities.length ||
+        expectedCapabilities.some((capability) => !parsed.data.capabilities.includes(capability)) ||
+        parsed.data.analysis_complete === parsed.data.analysis_timed_out)
+        return err(new Error("Ghidra bridge handshake identity is invalid"));
+    return ok(parsed.data);
+};
+/** Require acknowledgement that the private bridge loop has ended. */
+export const isGhidraShutdownAcknowledgement = (value) => typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    value.shutdown === true &&
+    value.project_ephemeral === true;

package/dist/ghidra/GhidraSocketConnection.js

@@ -0,0 +1,83 @@
+import { createConnection } from "node:net";
+import { err, ok } from "../domain/result.js";
+import { GhidraSessionError, } from "./GhidraSessionError.js";
+import { observeGhidraEndpoint, } from "./GhidraTransport.js";
+/** Attach decoded bridge listeners and return an idempotent detach callback. */
+const attachGhidraSocket = (socket, handlers) => {
+    socket.setEncoding("utf8");
+    socket.on("data", handlers.data);
+    socket.on("error", handlers.error);
+    socket.on("close", handlers.close);
+    return () => {
+        socket.off("data", handlers.data);
+        socket.off("error", handlers.error);
+        socket.off("close", handlers.close);
+    };
+};
+/** Poll the endpoint and attach the first ready bridge socket. */
+export const connectGhidraSocket = async (options) => {
+    while (options.deadline.remainingMs() > 0) {
+        if (options.deadline.signal.aborted)
+            return err(interruptionFailure(options));
+        if (options.isClosed())
+            return err(options.failure("cancelled", "Ghidra startup was closed"));
+        if (options.processExited())
+            return err(options.failure("process", "Ghidra exited before bridge startup"));
+        const observed = await observeGhidraEndpoint(options.endpoint);
+        if (!observed.ok)
+            return observed;
+        if (observed.value === null) {
+            if ((await options.deadline.wait(50)) === "aborted")
+                return err(interruptionFailure(options));
+            continue;
+        }
+        const connected = await connectGhidraSocketOnce(observed.value, options.deadline.signal);
+        if (connected.ok) {
+            const detach = attachGhidraSocket(connected.value, options.handlers);
+            return ok({ socket: connected.value, detach });
+        }
+        if ((await options.deadline.wait(50)) === "aborted")
+            return err(interruptionFailure(options));
+    }
+    return err(options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
+        timeoutMs: options.startupTimeoutMs,
+    }));
+};
+/** Open one abort-aware connection to an observed local Ghidra endpoint. */
+const connectGhidraSocketOnce = (target, signal) => new Promise((resolve) => {
+    const socket = "path" in target
+        ? createConnection(target.path)
+        : createConnection({ host: target.host, port: target.port });
+    const detach = () => {
+        socket.off("connect", onConnect);
+        socket.off("error", onError);
+        signal.removeEventListener("abort", onAbort);
+    };
+    const onConnect = () => {
+        detach();
+        resolve(ok(socket));
+    };
+    const onError = (cause) => {
+        detach();
+        socket.destroy();
+        resolve(err(new GhidraSessionError("start", "Ghidra bridge connection failed", {
+            endpoint: target,
+            error: cause.message,
+        })));
+    };
+    const onAbort = () => {
+        detach();
+        socket.destroy();
+        resolve(err(new GhidraSessionError("cancelled", "Ghidra bridge connection was cancelled", { endpoint: target })));
+    };
+    socket.once("connect", onConnect);
+    socket.once("error", onError);
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+});
+const interruptionFailure = (options) => options.deadline.interruption === "cancelled"
+    ? options.failure("cancelled", "Ghidra startup was cancelled")
+    : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
+        timeoutMs: options.startupTimeoutMs,
+    });

package/dist/ghidra/GhidraTargetSnapshot.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open, rm } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { AnalysisArtifactChangedError, AnalysisAccessDeniedError, } from "../domain/analysisErrorCore.js";
+import { windowsPrivateRuntime } from "../windows/WindowsPrivateRuntime.js";
+/** Copy one target and require its bytes to match the parsed target identity. */
+export const createGhidraTargetSnapshot = async (sourcePath, runtimeRoot, expectedSha256, options = {}) => {
+    if (!/^[a-f0-9]{64}$/u.test(expectedSha256))
+        throw new TypeError("Ghidra target SHA-256 commitment is invalid");
+    const suffix = safeExtension(sourcePath);
+    const snapshotPath = join(runtimeRoot, `target-${expectedSha256.slice(0, 12)}${suffix}`);
+    if ((options.platform ?? process.platform) === "win32") {
+        const observed = await windowsPrivateRuntime(runtimeRoot).snapshot(sourcePath, `target-${expectedSha256.slice(0, 12)}${suffix}`, options.signal);
+        if (observed.sha256 !== expectedSha256)
+            throw new AnalysisArtifactChangedError("open_binary", sourcePath, `Ghidra target snapshot digest mismatch: expected ${expectedSha256}, observed ${observed.sha256}`);
+        return {
+            path: snapshotPath,
+            sha256: observed.sha256,
+            admission: { source: observed.source, snapshot: observed.snapshot },
+        };
+    }
+    let source;
+    let destination;
+    try {
+        source = await openSnapshotSource(sourcePath);
+        if (!(await source.stat()).isFile())
+            throw new AnalysisArtifactChangedError("open_binary", sourcePath, "The selected Ghidra source is no longer a regular file");
+        destination = await open(snapshotPath, "wx", 0o600);
+        await destination.chmod(0o600);
+        const hash = createHash("sha256");
+        const digest = new Transform({
+            transform(chunk, _encoding, done) {
+                if (!Buffer.isBuffer(chunk)) {
+                    done(new TypeError("Ghidra snapshot stream must contain bytes"));
+                    return;
+                }
+                hash.update(chunk);
+                done(null, chunk);
+            },
+        });
+        await pipeline(source.createReadStream(), digest, destination.createWriteStream(), options.signal === undefined ? {} : { signal: options.signal });
+        const observedSha256 = hash.digest("hex");
+        if (observedSha256 !== expectedSha256)
+            throw new AnalysisArtifactChangedError("open_binary", sourcePath, `Ghidra target snapshot digest mismatch: expected ${expectedSha256}, observed ${observedSha256}`);
+        return { path: snapshotPath, sha256: observedSha256 };
+    }
+    catch (cause) {
+        if (destination !== undefined)
+            await rm(snapshotPath, { force: true }).catch((cause) => {
+                // best-effort cleanup: snapshot removal must not mask the copy failure.
+                void cause;
+            });
+        throw cause;
+    }
+    finally {
+        await Promise.all([source?.close(), destination?.close()]);
+    }
+};
+const openSnapshotSource = async (path) => {
+    try {
+        // A path replaced by a FIFO must not block startup before its type is checked.
+        return await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
+    }
+    catch (cause) {
+        const code = cause instanceof Error && "code" in cause ? cause.code : undefined;
+        if (code === "EACCES" || code === "EPERM")
+            throw new AnalysisAccessDeniedError("open_binary", path, code, { cause });
+        if (code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP")
+            throw new AnalysisArtifactChangedError("open_binary", path, `The selected Ghidra source could not be opened (${code})`, { cause });
+        throw cause;
+    }
+};
+const safeExtension = (path) => {
+    const extension = extname(path);
+    return /^\.[A-Za-z0-9]{1,12}$/u.test(extension) ? extension : ".bin";
+};

package/dist/ghidra/GhidraTransport.js

@@ -0,0 +1,101 @@
+import { access, open } from "node:fs/promises";
+import { join } from "node:path";
+import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
+import { readWindowsPrivateRuntimeFile } from "../windows/WindowsPrivateRuntime.js";
+import { err, ok } from "../domain/result.js";
+import { GhidraSessionError } from "./GhidraSessionError.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
+/** Allocate an endpoint that fits the host's Unix sockaddr without moving the project. */
+export const createGhidraEndpoint = async (runtimeRoot, transport, platform) => {
+    const path = join(runtimeRoot, transport === "unix-socket" ? "bridge.sock" : "bridge-endpoint.json");
+    // sockaddr_un includes a terminating NUL: macOS has 104 bytes, Linux 108.
+    const maximumPathBytes = platform === "darwin" ? 103 : 107;
+    if (transport !== "unix-socket" ||
+        Buffer.byteLength(path, "utf8") <= maximumPathBytes)
+        return { endpoint: { transport, path } };
+    const socketRoot = await PrivateRuntimeRoot.create({
+        parent: "/tmp",
+        prefix: "rea-ghidra-socket-",
+        platform,
+    });
+    return {
+        endpoint: { transport, path: join(socketRoot.path, "s") },
+        socketRoot,
+    };
+};
+/** Observe a ready endpoint, returning null while its bridge is not listening. */
+export const observeGhidraEndpoint = async (endpoint) => {
+    if (endpoint.transport === "unix-socket") {
+        try {
+            await access(endpoint.path);
+            return ok({ path: endpoint.path });
+        }
+        catch (cause) {
+            return isMissing(cause)
+                ? ok(null)
+                : err(endpointFailure(endpoint, "Ghidra socket observation failed", cause));
+        }
+    }
+    if (process.platform === "win32") {
+        try {
+            return parseTcpEndpoint(endpoint, readWindowsPrivateRuntimeFile(endpoint.path));
+        }
+        catch (cause) {
+            return isMissing(cause) || isWindowsEndpointWriterBusy(cause)
+                ? ok(null)
+                : err(endpointFailure(endpoint, "Ghidra endpoint observation failed", cause));
+        }
+    }
+    let handle;
+    try {
+        handle = await open(endpoint.path, "r");
+    }
+    catch (cause) {
+        return isMissing(cause)
+            ? ok(null)
+            : err(endpointFailure(endpoint, "Ghidra endpoint observation failed", cause));
+    }
+    try {
+        const encoded = await handle.readFile("utf8");
+        if (encoded.length === 0)
+            return err(endpointFailure(endpoint, "Ghidra TCP endpoint is invalid"));
+        return parseTcpEndpoint(endpoint, encoded);
+    }
+    catch (cause) {
+        return err(endpointFailure(endpoint, "Ghidra endpoint read failed", cause));
+    }
+    finally {
+        await handle.close();
+    }
+};
+const parseTcpEndpoint = (endpoint, encoded) => {
+    try {
+        const value = JSON.parse(encoded);
+        if (typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value) ||
+            !hasExactKeys(value, ["host", "port"]) ||
+            value.host !== "127.0.0.1" ||
+            !Number.isSafeInteger(value.port) ||
+            typeof value.port !== "number" ||
+            value.port < 1 ||
+            value.port > 65_535)
+            return err(endpointFailure(endpoint, "Ghidra TCP endpoint is invalid"));
+        return ok({ host: "127.0.0.1", port: value.port });
+    }
+    catch (cause) {
+        return err(endpointFailure(endpoint, "Ghidra TCP endpoint is invalid", cause));
+    }
+};
+const hasExactKeys = (value, expected) => {
+    const keys = Object.keys(value).sort((left, right) => compareUnicodeCodePoints(left, right));
+    return (keys.length === expected.length &&
+        keys.every((key, index) => key === expected[index]));
+};
+const endpointFailure = (endpoint, message, cause) => new GhidraSessionError("start", message, {
+    transport: endpoint.transport,
+    endpoint_path: endpoint.path,
+    ...(cause instanceof Error ? { error: cause.message } : {}),
+}, cause instanceof Error ? { cause } : undefined);
+const isMissing = (cause) => cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+const isWindowsEndpointWriterBusy = (cause) => cause instanceof Error && "win32Code" in cause && cause.win32Code === 32;

package/dist/ghidra/extensions/GhidraExtensionFailures.js

@@ -0,0 +1,20 @@
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { validateGhidraExtensionResults, } from "./GhidraExtensions.js";
+/** Preserve unsupported recovery separately from malformed or failed producers. */
+export const ghidraExtensionFailure = (extensions, results, operation) => {
+    const reports = results;
+    const invalid = validateGhidraExtensionResults(extensions, reports);
+    const failed = reports.find((value) => value.status === "unsupported" || value.status === "failed");
+    if (invalid === null && failed === undefined)
+        return undefined;
+    return invalid === null && failed?.status === "unsupported"
+        ? new AnalysisCapabilityUnavailableError("ghidra", operation, `${failed.id}: ${failed.reason}. Omit REA_GHIDRA_NATIVEAOT_JAR to continue ordinary native analysis.`)
+        : new ProviderAdapterError("ghidra", operation, {
+            diagnostics: {
+                reason: invalid ?? failed?.reason ?? "Ghidra extension failed",
+                analysis_extensions: jsonValueSchema.parse(reports),
+            },
+        });
+};

package/dist/ghidra/extensions/GhidraExtensions.js

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open, realpath, writeFile, mkdir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisUnsupportedTargetError, } from "../../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { err, ok } from "../../domain/result.js";
+import { nativeAotAdapter } from "./nativeaot/NativeAotAdapter.js";
+const digest = z.string().regex(/^[a-f0-9]{64}$/u);
+/** Exact executable extension artifact committed before the session starts. */
+export const ghidraExtensionSchema = z.strictObject({
+    id: z.string().regex(/^[a-z][a-z0-9\x2d]*$/u),
+    path: z.string().refine(isAbsolute, "Extension path must be absolute"),
+    configured_path: z
+        .string()
+        .refine(isAbsolute, "Extension path must be absolute"),
+    sha256: digest,
+    entry_class: z.string().min(1),
+    integration_api: z.literal(1),
+});
+/** Shared extension envelope; each adapter validates its own producer result. */
+export const ghidraExtensionResultSchema = z.strictObject({
+    id: z.string().min(1),
+    sha256: digest,
+    status: z.enum([
+        "complete",
+        "partial",
+        "not_applicable",
+        "unsupported",
+        "failed",
+    ]),
+    reason: z.string().nullable(),
+    result: jsonObjectSchema,
+});
+const adapters = [nativeAotAdapter];
+const MAX_EXTENSION_BYTES = 8 * 1024 * 1024;
+/** Read a bounded regular artifact through its open handle, without ambient state changes. */
+const readJar = async (path) => {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size < 4 || stat.size > MAX_EXTENSION_BYTES)
+            throw new Error(`Ghidra extension must be a regular JAR of 4..${MAX_EXTENSION_BYTES} bytes: ${path}`);
+        const bytes = Buffer.alloc(stat.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const read = await file.read(bytes, offset, bytes.length - offset, offset);
+            if (read.bytesRead === 0)
+                throw new Error(`Incomplete Ghidra extension read: ${path}`);
+            offset += read.bytesRead;
+        }
+        const extra = Buffer.alloc(1);
+        if ((await file.read(extra, 0, 1, offset)).bytesRead !== 0 ||
+            bytes.readUInt32LE(0) !== 0x04034b50)
+            throw new Error(`Ghidra extension changed during read or is not a JAR: ${path}`);
+        return bytes;
+    }
+    finally {
+        await file.close();
+    }
+};
+/** Resolve explicitly configured optional extensions into the immutable analysis profile. */
+export const resolveGhidraExtensions = async (config, target, platform, signal) => {
+    const extensions = [];
+    for (const adapter of adapters) {
+        if (signal?.aborted)
+            return err(new AnalysisCancelledError("open_binary"));
+        const configured = adapter.configuredPath(config);
+        if (configured === undefined)
+            continue;
+        const refusal = adapter.unsupportedReason(target, platform);
+        if (refusal !== null)
+            return err(extensionRefusalError(refusal, target));
+        try {
+            const path = await realpath(configured);
+            const bytes = await readJar(path);
+            extensions.push({
+                id: adapter.id,
+                path,
+                configured_path: configured,
+                sha256: createHash("sha256").update(bytes).digest("hex"),
+                entry_class: adapter.entryClass,
+                integration_api: 1,
+            });
+        }
+        catch (cause) {
+            return err(new ProviderAdapterError("ghidra", "resolve_analysis_profile", {
+                cause,
+                diagnostics: {
+                    extension: adapter.id,
+                    path: configured,
+                    reason: cause instanceof Error ? cause.message : String(cause),
+                },
+            }));
+        }
+    }
+    if (signal?.aborted)
+        return err(new AnalysisCancelledError("open_binary"));
+    return ok(extensions);
+};
+/** Require explicit local configuration before admitting executable code from a profile. */
+export const validateGhidraExtensionProfile = (extensions, config, target, platform) => {
+    const enabled = adapters.filter((adapter) => adapter.configuredPath(config) !== undefined);
+    if (enabled.length !== extensions.length ||
+        new Set(extensions.map((extension) => extension.id)).size !==
+            extensions.length)
+        return "Configured Ghidra extension inventory differs from the resolved analysis profile.";
+    for (const extension of extensions) {
+        const adapter = enabled.find((value) => value.id === extension.id);
+        if (adapter === undefined ||
+            adapter.entryClass !== extension.entry_class ||
+            adapter.configuredPath(config) !== extension.configured_path)
+            return `Ghidra extension profile lacks matching explicit local configuration: ${extension.id}`;
+        const refusal = adapter.unsupportedReason(target, platform);
+        if (refusal !== null)
+            return refusal.reason;
+    }
+    return null;
+};
+/**
+ * A deliberate host or target refusal is not an execution failure: retrying
+ * cannot change it, and its reason already names the remedy.
+ */
+const extensionRefusalError = (refusal, target) => refusal.constraint === "host"
+    ? new AnalysisCapabilityUnavailableError("ghidra", "resolve_analysis_profile", refusal.reason, { userMessage: refusal.reason })
+    : new AnalysisUnsupportedTargetError("resolve_analysis_profile", target.path, refusal.reason, 
+    // The reason names the workflows that remain available.
+    { remediationAction: refusal.reason });
+/** Snapshot committed extension bytes into the private runtime before Java loads them. */
+export const snapshotGhidraExtensions = async (extensions, runtimeRoot) => {
+    if (extensions.length === 0)
+        return [];
+    for (const extension of extensions) {
+        ghidraExtensionSchema.parse(extension);
+        const adapter = adapters.find((value) => value.id === extension.id);
+        if (adapter === undefined || adapter.entryClass !== extension.entry_class)
+            throw new Error(`Unregistered Ghidra extension identity: ${extension.id}`);
+        if ((await realpath(extension.configured_path)) !== extension.path)
+            throw new Error(`Ghidra extension resolved path differs from explicit configuration: ${extension.id}`);
+    }
+    const directory = join(runtimeRoot, "extensions");
+    await mkdir(directory, { mode: 0o700 });
+    const result = [];
+    for (const extension of extensions) {
+        const bytes = await readJar(extension.path);
+        if (createHash("sha256").update(bytes).digest("hex") !== extension.sha256)
+            throw new Error(`Ghidra extension digest differs from committed profile: ${extension.id} (${extension.path})`);
+        const path = join(directory, `${extension.id}.jar`);
+        await writeFile(path, bytes, { flag: "wx", mode: 0o600 });
+        result.push({ ...extension, path });
+    }
+    return result;
+};
+/** Require every configured producer result to match its artifact and registered ABI. */
+export const validateGhidraExtensionResults = (expected, results) => {
+    if (results.length !== expected.length ||
+        new Set(results.map((result) => result.id)).size !== results.length)
+        return "Ghidra extension result inventory differs from its committed profile.";
+    for (const extension of expected) {
+        const result = results.find((value) => value.id === extension.id);
+        const adapter = adapters.find((value) => value.id === extension.id);
+        if (result === undefined ||
+            adapter === undefined ||
+            result.sha256 !== extension.sha256)
+            return `Ghidra extension identity mismatch: ${extension.id}`;
+        const invalid = adapter.validate(result);
+        if (invalid !== null)
+            return invalid;
+    }
+    return null;
+};
+/** Exact adapter limitations for explicitly configured session extensions. */
+export const ghidraExtensionLimitations = (extensions) => adapters
+    .filter((adapter) => extensions.some((extension) => extension.id === adapter.id))
+    .flatMap((adapter) => adapter.limitations);

package/dist/ghidra/extensions/nativeaot/NativeAotAdapter.js

@@ -0,0 +1,27 @@
+import { validateNativeAotReport } from "./NativeAotReport.js";
+/** NativeAOT-specific prerequisites and report interpretation behind the extension boundary. */
+export const nativeAotAdapter = {
+    id: "nativeaot",
+    entryClass: "rea.extensions.nativeaot.NativeAotExtension",
+    configuredPath: (config) => config.ghidraNativeAotJar,
+    unsupportedReason: (target, platform) => platform !== "linux"
+        ? {
+            constraint: "host",
+            reason: "NativeAOT recovery is verified on Linux only; omit REA_GHIDRA_NATIVEAOT_JAR for ordinary native analysis.",
+        }
+        : !["elf", "pe"].includes(target.format) ||
+            target.architecture !== "x86_64" ||
+            target.managed === true
+            ? {
+                constraint: "target",
+                reason: "NativeAOT recovery requires an x86-64 ELF or native PE target on Linux; PE/CLI and ReadyToRun assemblies use inspect_managed_artifact; omit REA_GHIDRA_NATIVEAOT_JAR for ordinary native analysis.",
+            }
+            : null,
+    validate: validateNativeAotReport,
+    limitations: [
+        "Optional NativeAOT recovery is verified for .NET 8.0.22 RTR 9.1 Linux x64 ELF and Windows x64 PE targets on a Linux host. Other runtime layouts, target architectures and hosts are unsupported.",
+        "Type names and relationships use recovery heuristics; original C# source and custom field layouts are not recovered. Rehydrated analysis-memory bytes are derived, without original file offsets or runtime observations.",
+        "Method prototypes are Ghidra inferences, not original signatures. Pre-recovery conventions are retained; new functions use the loaded compiler default. Verify parameter roles against instructions and call sites.",
+        "The configured extension retains its actual JAR digest. Its reported source revision is not an attestation of caller-supplied build bytes.",
+    ],
+};