reverseport 0.0.0-stage → 1.2.0

package/dist/ghidra/GhidraLauncher.js

@@ -0,0 +1,490 @@
+import { GHIDRA_SEED_SCRIPT, snapshotGhidraAnalysisSeeds, } from "./GhidraAnalysisSeeds.js";
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
+import { mkdir, realpath } from "node:fs/promises";
+import { basename, dirname, join, posix, win32 } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { windowsPrivateRuntime } from "../windows/WindowsPrivateRuntime.js";
+import { quoteWindowsBatchToken, windowsBatchCommand, WindowsBatchCommandError, } from "../process/WindowsBatchCommand.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { err, ok } from "../domain/result.js";
+import { execFileOutputFailure } from "../process/ExecFileOutput.js";
+import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, } from "../process/ProcessOwnership.js";
+import { spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
+import { ghidraJavaEnvironment } from "./GhidraInstallation.js";
+import { ghidraJavaLaunch } from "./GhidraJavaLaunch.js";
+import { snapshotGhidraExtensions, } from "./extensions/GhidraExtensions.js";
+import { inspectGhidraPspExtension, } from "./GhidraPspExtension.js";
+/** Local launch failure retained as the cause of a provider-neutral error. */
+export class GhidraLaunchError extends Error {
+    #partialLaunch;
+    #capturedOutput;
+    constructor(message, options) {
+        const { partialLaunch, capturedOutput, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
+        this.name = "GhidraLaunchError";
+        this.#partialLaunch = partialLaunch;
+        this.#capturedOutput =
+            capturedOutput === undefined ? undefined : { ...capturedOutput };
+    }
+    /** Process ownership retained for the client to retry an incomplete rollback. */
+    get partialLaunch() {
+        return this.#partialLaunch;
+    }
+    /** Launcher command outcome retained when a launch command reported one. */
+    get capturedOutput() {
+        return this.#capturedOutput === undefined
+            ? undefined
+            : { ...this.#capturedOutput };
+    }
+}
+/**
+ * Retain a failed launcher command's exit/signal and output in the shared
+ * captured-output envelope. Bounds apply at projection; truncation there stays
+ * explicit, matching the compiler-outcome diagnostics.
+ */
+const ghidraLaunchCommandOutput = (cause) => {
+    const failure = execFileOutputFailure(cause);
+    if (failure === undefined)
+        return undefined;
+    return {
+        stdout: failure.stdout,
+        stderr: failure.stderr,
+        truncated: failure.outputTruncated,
+        exit_code: typeof failure.code === "number" ? failure.code : null,
+        signal: failure.signal,
+    };
+};
+/** Launch Ghidra without copying scripts into or modifying its installation. */
+export class GhidraHeadlessLauncher {
+    options;
+    constructor(options) {
+        this.options = {
+            ...options,
+            environment: snapshotEnvironment(options.environment, options.platform),
+        };
+    }
+    async launch(session, options = {}) {
+        if (isAborted(options.signal))
+            return err(new AnalysisCancelledError("open_binary"));
+        const paths = ghidraRuntimePaths(session.runtimeRoot);
+        const platform = this.options.platform ?? process.platform;
+        let started;
+        try {
+            const psp = this.options.pspExtension;
+            if (psp !== undefined) {
+                const installedRoot = await realpath(join(dirname(this.options.analyzeHeadlessPath), "..", "Ghidra", "Extensions", "ghidra-allegrex"));
+                if (installedRoot !== psp.root)
+                    throw new GhidraLaunchError("Allegrex profile does not belong to the selected Ghidra installation.");
+                const inspected = await inspectGhidraPspExtension(psp.root, psp.ghidra_version, options.signal);
+                if (inspected.sha256 !== psp.sha256)
+                    throw new GhidraLaunchError("Installed Allegrex content changed since profile resolution; reopen the target to resolve a fresh profile.");
+            }
+            await createGhidraRuntimeDirectories(paths, platform);
+            const seedPath = this.options.analysisSeeds === undefined
+                ? undefined
+                : await snapshotGhidraAnalysisSeeds(this.options.analysisSeeds, session.runtimeRoot);
+            const extensions = await snapshotGhidraExtensions(this.options.analysisExtensions ?? [], session.runtimeRoot);
+            await writeGhidraRuntimeFile(paths.descriptorPath, `${JSON.stringify({
+                transport: session.transport,
+                endpoint_path: session.endpointPath,
+                token: session.token,
+                run_id: session.runId,
+                target_sha256: session.targetSha256,
+                provider_version: session.providerVersion,
+                profile_digest: session.profileDigest,
+                ...(extensions.length === 0
+                    ? {}
+                    : { analysis_extensions: extensions }),
+            })}\n`, platform);
+            if (isAborted(options.signal))
+                return err(new AnalysisCancelledError("open_binary"));
+            const headlessArguments = ghidraHeadlessArguments({
+                platform,
+                ...(psp === undefined ? {} : { psp: true }),
+                ...(this.options.mipsSoftFloat === undefined
+                    ? {}
+                    : { mipsSoftFloat: this.options.mipsSoftFloat }),
+                projectRoot: paths.projectRoot,
+                targetPath: session.targetPath,
+                bridgeScriptPath: this.options.bridgeScriptPath,
+                descriptorPath: paths.descriptorPath,
+                ghidraLogPath: paths.ghidraLogPath,
+                scriptLogPath: paths.scriptLogPath,
+                ...(this.options.dosCom === undefined
+                    ? {}
+                    : { dosCom: this.options.dosCom }),
+                ...(this.options.dosMz === undefined
+                    ? {}
+                    : { dosMz: this.options.dosMz }),
+                ...(this.options.rawBinary === undefined
+                    ? {}
+                    : { rawBinary: this.options.rawBinary }),
+                ...(this.options.languageOverride === undefined
+                    ? {}
+                    : { languageOverride: this.options.languageOverride }),
+                ...(seedPath === undefined ? {} : { seedPath }),
+                ...(this.options.disabledAnalyzers === undefined
+                    ? {}
+                    : { disabledAnalyzers: this.options.disabledAnalyzers }),
+            });
+            const scriptCommand = ghidraHeadlessCommand({
+                environment: this.options.environment,
+                platform,
+                analyzeHeadlessPath: this.options.analyzeHeadlessPath,
+                arguments: headlessArguments,
+                ...(this.options.comSpec === undefined
+                    ? {}
+                    : { comSpec: this.options.comSpec }),
+            });
+            const environment = ghidraLaunchEnvironment(paths, this.options.javaHome, platform, scriptCommand.command, this.options.environment);
+            if (platform !== "win32" && this.options.javaHome === undefined)
+                throw new GhidraLaunchError("POSIX Ghidra requires its inspected JDK home");
+            const command = platform !== "win32" && this.options.javaHome !== undefined
+                ? await ghidraJavaLaunch({
+                    platform,
+                    analyzeHeadlessPath: this.options.analyzeHeadlessPath,
+                    javaHome: this.options.javaHome,
+                    homeRoot: paths.homeRoot,
+                    tempRoot: paths.tempRoot,
+                    arguments: headlessArguments,
+                    environment,
+                    ...(options.signal === undefined
+                        ? {}
+                        : { signal: options.signal }),
+                })
+                : { ...scriptCommand, environment };
+            started = await (this.options.spawnProcess ?? spawnOwnedProviderProcess)({
+                command: command.command,
+                arguments: command.arguments,
+                runId: session.runId,
+                // POSIX launches the inspected JVM directly; script wrappers cannot
+                // preserve JVM property paths containing spaces as single arguments.
+                expectedCommand: platform !== "win32" ? command.command : null,
+                windowsVerbatimArguments: platform === "win32",
+                platform,
+                env: command.environment,
+                hostEnvironment: {},
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+            });
+            const partialLaunch = ownedGhidraLaunch(started, paths, platform);
+            await writeGhidraRuntimeFile(paths.ownershipPath, `${JSON.stringify({
+                run_id: session.runId,
+                transport: session.transport,
+                endpoint_path: session.endpointPath,
+                pid: started.ownership.leaderPid,
+                process_group_id: started.ownership.processGroupId,
+                parent_pid: process.pid,
+                ownership_kind: platform === "win32" ? "windows-job-object" : "posix-process-group",
+                launcher: command.command,
+                headless_script: this.options.analyzeHeadlessPath,
+                created_at: new Date().toISOString(),
+            })}\n`, platform);
+            if (isAborted(options.signal)) {
+                throw new AnalysisCancelledError("open_binary");
+            }
+            return ok(partialLaunch);
+        }
+        catch (cause) {
+            const capturedOutput = ghidraLaunchCommandOutput(cause);
+            const primary = isAborted(options.signal)
+                ? new AnalysisCancelledError("open_binary", { cause })
+                : new GhidraLaunchError("Ghidra headless launch failed", {
+                    cause,
+                    ...(capturedOutput === undefined ? {} : { capturedOutput }),
+                });
+            if (started === undefined)
+                return err(primary);
+            let cleanupFailure;
+            try {
+                const cleanup = await cleanupStartedProcess(started, platform);
+                if (!cleanup.cleaned)
+                    cleanupFailure = new Error(`Ghidra process cleanup was incomplete: ${cleanup.reason}`);
+            }
+            catch (failure) {
+                cleanupFailure = failure;
+            }
+            if (cleanupFailure !== undefined) {
+                const partialLaunch = ownedGhidraLaunch(started, paths, platform);
+                const primaryMessage = isAborted(options.signal)
+                    ? primary.message
+                    : `Ghidra headless launch failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+                return err(new GhidraLaunchError(`${primaryMessage}; process cleanup remains incomplete`, {
+                    cause: new AggregateError([primary, cleanupFailure], "Ghidra launch rollback did not release its process", { cause: primary }),
+                    partialLaunch,
+                    ...(capturedOutput === undefined ? {} : { capturedOutput }),
+                }));
+            }
+            return err(primary);
+        }
+    }
+}
+const ownedGhidraLaunch = (spawned, paths, platform) => ({
+    ...ownedGhidraProcess(spawned, platform),
+    projectRoot: paths.projectRoot,
+    ghidraLogPath: paths.ghidraLogPath,
+    scriptLogPath: paths.scriptLogPath,
+});
+const ownedGhidraProcess = (spawned, platform) => ({
+    process: spawned.process,
+    ownsProcessLifetime: true,
+    ownership: spawned.ownership,
+    cleanup: () => cleanupStartedProcess(spawned, platform),
+});
+/** Build a direct POSIX launch or a conservatively quoted Windows batch call. */
+export const ghidraHeadlessCommand = (options) => {
+    if (options.platform !== "win32")
+        return {
+            command: options.analyzeHeadlessPath,
+            arguments: [...options.arguments],
+        };
+    const command = ghidraBatchStep(() => windowsBatchCommand({
+        environment: options.environment,
+        batchPath: options.analyzeHeadlessPath,
+        arguments: options.arguments,
+        ...(options.comSpec === undefined ? {} : { comSpec: options.comSpec }),
+    }));
+    if ((command.arguments.at(-1)?.length ?? 0) > 30_000)
+        throw new GhidraLaunchError("Windows Ghidra command exceeds the P0 length limit");
+    return command;
+};
+/** Keep Ghidra's launch error type and P0 wording for shared batch checks. */
+const ghidraBatchStep = (step) => {
+    try {
+        return step();
+    }
+    catch (cause) {
+        if (!(cause instanceof WindowsBatchCommandError))
+            throw cause;
+        throw new GhidraLaunchError(cause.reason === "metacharacter"
+            ? "Windows Ghidra P0 paths cannot contain command-interpreter metacharacters"
+            : cause.message, { cause });
+    }
+};
+const cleanupStartedProcess = (started, platform) => started.cleanup !== undefined
+    ? started.cleanup()
+    : platform === "win32"
+        ? cleanupWindowsProcessTree(started.ownership.leaderPid)
+        : cleanupOwnedProcessGroup(started.ownership);
+/** Build the complete read-only headless invocation in deterministic order. */
+export const ghidraHeadlessArguments = (options) => {
+    // Bridge script paths use the target platform's syntax, which differs from
+    // the host when building a cross-platform invocation.
+    const scriptPath = (options.platform ?? process.platform) === "win32" ? win32 : posix;
+    const bridgeDirectory = scriptPath.dirname(options.bridgeScriptPath);
+    const override = options.languageOverride;
+    const rawBinary = options.rawBinary;
+    if (options.psp === true &&
+        (options.dosMz === true ||
+            options.dosCom === true ||
+            override !== undefined))
+        throw new Error("A PSP ELF import cannot be combined with DOS or a generic Ghidra language override.");
+    if (options.psp === true && rawBinary !== undefined)
+        throw new Error("A PSP ELF import cannot be combined with a raw-binary import.");
+    if (options.mipsSoftFloat === true &&
+        (options.psp === true ||
+            options.dosMz === true ||
+            options.dosCom === true ||
+            rawBinary !== undefined))
+        throw new Error("MIPS soft-float storage applies only to a generic MIPS ELF import.");
+    if (override !== undefined &&
+        (options.dosMz === true || options.dosCom === true))
+        throw new Error("A Ghidra language override cannot be combined with a DOS import.");
+    if (override !== undefined && rawBinary !== undefined)
+        throw new Error("A Ghidra language override cannot be combined with a raw-binary import.");
+    if (rawBinary !== undefined &&
+        (options.dosMz === true || options.dosCom === true))
+        throw new Error("A raw-binary import cannot be combined with a DOS import.");
+    return [
+        options.projectRoot,
+        "rea-project",
+        "-import",
+        options.targetPath,
+        ...(options.dosMz === true
+            ? [
+                "-loader",
+                "MzLoader",
+                "-processor",
+                "x86:LE:16:Real Mode",
+                "-cspec",
+                "default",
+            ]
+            : options.dosCom === true
+                ? [
+                    "-loader",
+                    "BinaryLoader",
+                    "-loader-baseAddr",
+                    "1000:0100",
+                    "-processor",
+                    "x86:LE:16:Real Mode",
+                    "-cspec",
+                    "default",
+                ]
+                : rawBinary === undefined
+                    ? options.psp === true
+                        ? [
+                            "-loader",
+                            "PspElfLoader",
+                            "-processor",
+                            "Allegrex:LE:32:default",
+                            "-cspec",
+                            "default",
+                        ]
+                        : override !== undefined
+                            ? [
+                                "-processor",
+                                override.languageId,
+                                ...(override.compilerSpecId === undefined
+                                    ? []
+                                    : ["-cspec", override.compilerSpecId]),
+                            ]
+                            : []
+                    : [
+                        "-loader",
+                        "BinaryLoader",
+                        "-loader-baseAddr",
+                        rawBinary.baseAddr,
+                        "-processor",
+                        rawBinary.languageId,
+                        "-cspec",
+                        rawBinary.compilerSpecId,
+                    ]),
+        "-readOnly",
+        "-deleteProject",
+        "-log",
+        options.ghidraLogPath,
+        "-scriptlog",
+        options.scriptLogPath,
+        "-scriptPath",
+        bridgeDirectory,
+        ...(options.dosCom === true
+            ? [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraPrepareCom.java"),
+            ]
+            : []),
+        ...(rawBinary === undefined
+            ? []
+            : [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraPrepareRaw.java"),
+                rawBinary.languageId,
+                rawBinary.baseAddr,
+            ]),
+        // Seeds follow any loader preparation and precede default auto-analysis.
+        ...(options.seedPath === undefined
+            ? []
+            : [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, GHIDRA_SEED_SCRIPT),
+                options.seedPath,
+            ]),
+        // Analyzer options must apply before default auto-analysis and before the
+        // post-analysis repair and bridge scripts start serving.
+        ...(options.disabledAnalyzers === undefined ||
+            options.disabledAnalyzers.length === 0
+            ? []
+            : [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraAnalysisOptions.java"),
+                options.disabledAnalyzers.join(","),
+            ]),
+        ...((options.platform ?? process.platform) === "win32"
+            ? []
+            : [
+                "-postScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraNoReturnFix.java"),
+            ]),
+        // After analysis and the no-return refit, before the bridge serves results.
+        ...(options.mipsSoftFloat === true
+            ? [
+                "-postScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraMipsSoftFloat.java"),
+            ]
+            : []),
+        "-postScript",
+        // Ghidra checks the caller's cwd before scriptPath for a basename. Select
+        // the packaged source explicitly so unrelated entries cannot shadow it.
+        options.bridgeScriptPath,
+        options.descriptorPath,
+    ];
+};
+const ghidraRuntimePaths = (runtimeRoot) => ({
+    projectRoot: join(runtimeRoot, "project"),
+    homeRoot: join(runtimeRoot, "home"),
+    tempRoot: join(runtimeRoot, "tmp"),
+    cacheRoot: join(runtimeRoot, "cache"),
+    configRoot: join(runtimeRoot, "config"),
+    dataRoot: join(runtimeRoot, "data"),
+    descriptorPath: join(runtimeRoot, "session.json"),
+    ownershipPath: join(runtimeRoot, "ownership.json"),
+    ghidraLogPath: join(runtimeRoot, "ghidra.log"),
+    scriptLogPath: join(runtimeRoot, "script.log"),
+});
+const createGhidraRuntimeDirectories = async (paths, platform) => {
+    if (platform === "win32") {
+        const runtime = windowsPrivateRuntime(dirname(paths.projectRoot));
+        for (const path of [
+            paths.projectRoot,
+            paths.homeRoot,
+            paths.tempRoot,
+            paths.cacheRoot,
+            paths.configRoot,
+            paths.dataRoot,
+        ])
+            runtime.mkdir(basename(path));
+        return;
+    }
+    await Promise.all([
+        paths.projectRoot,
+        paths.homeRoot,
+        paths.tempRoot,
+        paths.cacheRoot,
+        paths.configRoot,
+        paths.dataRoot,
+    ].map((path) => mkdir(path, { recursive: true, mode: 0o700 })));
+};
+const writeGhidraRuntimeFile = async (path, content, platform) => {
+    if (platform === "win32") {
+        windowsPrivateRuntime(dirname(path)).writeFile(basename(path), content);
+        return;
+    }
+    await writeFileAtomic(path, content, { encoding: "utf8", mode: 0o600 });
+};
+const ghidraLaunchEnvironment = (paths, javaHome, platform, executable, selectedEnvironment) => {
+    return {
+        ...ghidraJavaEnvironment(javaHome, selectedEnvironment, platform),
+        ...ghidraHeadlessJavaOptions(paths.homeRoot, paths.tempRoot, platform),
+        HOME: paths.homeRoot,
+        TMPDIR: paths.tempRoot,
+        ...(platform === "win32"
+            ? {
+                // Batch FOR /F launches another command interpreter through ComSpec.
+                // Use the same executable with the spelling consumed by cmd.exe.
+                ComSpec: executable.replaceAll("/", "\\"),
+                USERPROFILE: paths.homeRoot,
+                APPDATA: paths.configRoot,
+                LOCALAPPDATA: paths.cacheRoot,
+                TEMP: paths.tempRoot,
+                TMP: paths.tempRoot,
+            }
+            : {}),
+        XDG_CACHE_HOME: paths.cacheRoot,
+        XDG_CONFIG_HOME: paths.configRoot,
+        XDG_DATA_HOME: paths.dataRoot,
+    };
+};
+/** Encode provider-owned JVM paths for the platform launcher that consumes them. */
+export const ghidraHeadlessJavaOptions = (homeRoot, tempRoot, platform) => {
+    const options = [`-Duser.home=${homeRoot}`, `-Djava.io.tmpdir=${tempRoot}`];
+    if (platform === "win32")
+        return {
+            JDK_JAVA_OPTIONS: [...options, "-XX:-UsePerfData"]
+                .map((option) => ghidraBatchStep(() => quoteWindowsBatchToken(option)))
+                .join(" "),
+            GHIDRA_HEADLESS_JAVA_OPTIONS: "",
+        };
+    // POSIX launches the JVM directly, so these properties travel as separate
+    // argv items instead of the shell-split analyzeHeadless option list.
+    return { JDK_JAVA_OPTIONS: "", GHIDRA_HEADLESS_JAVA_OPTIONS: "" };
+};
+const isAborted = (signal) => signal?.aborted === true;

package/dist/ghidra/GhidraLoadImageAttest.js

@@ -0,0 +1,103 @@
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { nativeLoadImageObservationSchema, nativeLoadImageSchema, } from "../domain/native/nativeLoadImage.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { err, ok } from "../domain/result.js";
+import { attestGhidraDosComLoadImage, attestGhidraDosLoadImage, attestGhidraRawBinaryLoadImage, } from "./GhidraLoadImageValues.js";
+const isSignalAborted = (signal) => signal?.aborted === true;
+/** Independently verify measured load-image observations for admitted DOS and raw-binary targets. */
+export const attestGhidraNativeLoadImage = async (input) => {
+    const { target, operation, measured, client, mapSessionError, nativeAotResult, signal, } = input;
+    if (isSignalAborted(signal))
+        return err(new AnalysisCancelledError(operation));
+    const observations = nativeLoadImageObservationSchema.parse(measured);
+    if (target.format === "pe") {
+        if (nativeAotResult === undefined)
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: "The Ghidra provider did not produce read-only NativeAOT metadata for this admitted PE snapshot.",
+                },
+            }));
+        if (isSignalAborted(signal))
+            return err(new AnalysisCancelledError(operation));
+        try {
+            return ok(jsonValueSchema.parse(nativeLoadImageSchema.parse({
+                status: "unsupported",
+                reason: "Independent load-image verification currently supports DOS MZ, explicit DOS COM, and caller-supplied raw-binary targets only.",
+                observations: {
+                    ...observations,
+                    metadata_recovery: [
+                        ...(observations.metadata_recovery ?? []),
+                        nativeAotResult.summary,
+                    ],
+                },
+                limitations: [
+                    "Load-image verification is not performed for PE targets; NativeAOT metadata observations are derived separately from the exact admitted snapshot.",
+                ],
+            })));
+        }
+        catch (cause) {
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: cause instanceof Error
+                        ? cause.message
+                        : "NativeAOT metadata could not be represented in the load-image result",
+                },
+            }));
+        }
+    }
+    if (target.format !== "dos-mz" &&
+        target.format !== "dos-com" &&
+        target.format !== "raw-binary") {
+        return ok(jsonValueSchema.parse(nativeLoadImageSchema.parse({
+            status: "unsupported",
+            reason: "Independent load-image verification currently supports DOS MZ, explicit DOS COM, and caller-supplied raw-binary targets only.",
+            observations,
+            limitations: [
+                "Other formats expose measured mappings and source identities; no format-specific verification was performed.",
+            ],
+        })));
+    }
+    if (target.format === "raw-binary") {
+        if (client.hashTargetSnapshot === undefined)
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: "The Ghidra client does not expose its immutable target snapshot identity for independent raw-binary load-image verification.",
+                },
+            }));
+        const snapshot = await client.hashTargetSnapshot(signal);
+        if (!snapshot.ok)
+            return err(mapSessionError(snapshot.error));
+        if (isSignalAborted(signal))
+            return err(new AnalysisCancelledError(operation));
+        const attested = attestGhidraRawBinaryLoadImage(snapshot.value, target, observations);
+        return attested.ok
+            ? ok(jsonValueSchema.parse(attested.value))
+            : err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: { reason: attested.error },
+            }));
+    }
+    if (client.readTargetSnapshot === undefined)
+        return err(new ProviderAdapterError("ghidra", operation, {
+            diagnostics: {
+                reason: "The Ghidra client does not expose its immutable target snapshot for independent load-image verification.",
+            },
+        }));
+    const snapshot = await client.readTargetSnapshot(undefined, signal);
+    if (!snapshot.ok)
+        return err(mapSessionError(snapshot.error));
+    if (snapshot.value.kind !== "captured")
+        return err(new ProviderAdapterError("ghidra", operation, {
+            diagnostics: {
+                reason: "The uncapped load-image snapshot was unexpectedly not captured.",
+            },
+        }));
+    const attested = (target.format === "dos-com"
+        ? attestGhidraDosComLoadImage
+        : attestGhidraDosLoadImage)(snapshot.value.bytes, target.sha256 ?? "", observations);
+    if (!attested.ok)
+        return err(new ProviderAdapterError("ghidra", operation, {
+            diagnostics: { reason: attested.error },
+        }));
+    return ok(jsonValueSchema.parse(attested.value));
+};