Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(ghidra): discover installations from resolved PATH launchers
morluto86afc040e5c9
diff --git a/docs/installation.md b/docs/installation.mdindex 4e95e548e..bb6a2dd5c 100644--- a/docs/installation.md+++ b/docs/installation.md@@ -290,6 +290,15 @@ configuration without changing them. Without options, it audits every detectedregistration, the installed skill and optional analysis engines; its overall`healthy` value can be false while your chosen workflow works.+Doctor's `providerInspections` are host-level engine and registration checks,+not a readiness row for every advertised MCP adapter surface. `tools/list`+remains the complete stable catalog. Call `binary_session` with `{}` before+choosing an operation; it works before a target is opened, and+`result.tool_availability` reports per-operation availability, reasons and+client requirements for the current session state. It does not guarantee that+a particular caller-supplied input will be valid. See+[MCP discovery](mcp-contracts.md#identity-and-discovery).+Select the part you want to check:| Task | Readiness check |@@ -736,6 +745,14 @@ installation remains unavailable on Windows. Setup never installs Ghidra,Java, or Python. It preserves valid detected Ghidra/JDK settings in agentregistrations. See [Windows Ghidra P0](windows-ghidra-p0.md) for provider diagnostics.+When `GHIDRA_INSTALL_DIR` is unset, doctor and the Ghidra provider also search+`PATH` for `ghidra` or `ghidraRun`, resolve the selected launcher through its+real path, and accept it only when that location belongs to a Ghidra tree with+the application metadata and headless launcher. An explicitly supplied+`GHIDRA_INSTALL_DIR` always takes precedence, including when it is invalid;+REA reports that error instead of silently selecting another installation.+This discovery is read-only and does not execute the Ghidra launcher.+Doctor validates the platform, architecture, Ghidra 12.1.x application version,`support/analyzeHeadless` or `support/analyzeHeadless.bat`, the installation'sJava major range, 64-bit JDK bitness, and the presence of `javac`/`javac.exe`.diff --git a/src/ghidra/GhidraInstallation.test.ts b/src/ghidra/GhidraInstallation.test.tsindex 626954c69..a60e7b4b1 100644--- a/src/ghidra/GhidraInstallation.test.ts+++ b/src/ghidra/GhidraInstallation.test.ts@@ -1,3 +1,5 @@+import { chmod, mkdir, symlink, writeFile } from "node:fs/promises";+import { join } from "node:path";import { afterEach, describe, expect, it, vi } from "vitest";import { spawnSync } from "node:child_process";@@ -6,6 +8,7 @@ import { projectGhidraDoctorInspection } from "./GhidraDoctor.js";import {ghidraInstallationDiagnostics,ghidraJavaEnvironment,+ discoverGhidraInstallationOnPath,inspectGhidraInstallation,type GhidraExecutableHeaderProbe,type GhidraInstallationHost,@@ -17,6 +20,7 @@ import {ghidraApplicationProperties,ghidraJavaRequirement,} from "./GhidraInstallationPolicy.js";+import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";// The real Java probe shells out via spawnSync; stub it so one test can run// the real probeJava against captured `-XshowSettings:properties` output.@@ -68,6 +72,100 @@ afterEach(() => {vi.unstubAllEnvs();});+it.skipIf(process.platform === "win32")(+ "resolves a PATH launcher only when its real target is a complete installation",+ async () => {+ const root = await createTestTempDirectory("rea-ghidra-path-");+ const installation = join(root, "installation");+ const pathDirectory = join(root, "bin");+ const launcher = join(installation, "ghidraRun");+ await mkdir(join(installation, "Ghidra"), { recursive: true });+ await mkdir(join(installation, "support"), { recursive: true });+ await mkdir(pathDirectory, { recursive: true });+ await writeFile(+ join(installation, "Ghidra", "application.properties"),+ "application.version=12.1.4\n",+ );+ await writeFile(launcher, "#!/bin/sh\nexit 0\n");+ await writeFile(+ join(installation, "support", "analyzeHeadless"),+ "#!/bin/sh\nexit 0\n",+ );+ await chmod(launcher, 0o700);+ await chmod(join(installation, "support", "analyzeHeadless"), 0o700);+ await symlink(launcher, join(pathDirectory, "ghidra"));++ expect(+ discoverGhidraInstallationOnPath(+ { PATH: pathDirectory },+ process.platform,+ ),+ ).toBe(installation);++ const incomplete = join(root, "incomplete");+ const incompletePath = join(root, "incomplete-bin");+ await mkdir(join(incomplete, "Ghidra"), { recursive: true });+ await mkdir(incompletePath, { recursive: true });+ await writeFile(+ join(incomplete, "Ghidra", "application.properties"),+ "application.version=12.1.4\n",+ );+ await writeFile(join(incomplete, "ghidraRun"), "launcher\n");+ await chmod(join(incomplete, "ghidraRun"), 0o700);+ await symlink(+ join(incomplete, "ghidraRun"),+ join(incompletePath, "ghidra"),+ );+ expect(+ discoverGhidraInstallationOnPath(+ { PATH: incompletePath },+ process.platform,+ ),+ ).toBeUndefined();++ const nonExecutable = join(root, "non-executable");+ const nonExecutablePath = join(root, "non-executable-bin");+ await mkdir(join(nonExecutable, "Ghidra"), { recursive: true });+ await mkdir(join(nonExecutable, "support"), { recursive: true });+ await mkdir(nonExecutablePath, { recursive: true });+ await writeFile(+ join(nonExecutable, "Ghidra", "application.properties"),+ "application.version=12.1.4\n",+ );+ await writeFile(+ join(nonExecutable, "support", "analyzeHeadless"),+ "headless\n",+ );+ await chmod(join(nonExecutable, "support", "analyzeHeadless"), 0o700);+ await writeFile(join(nonExecutablePath, "ghidra"), "not executable\n");+ expect(+ discoverGhidraInstallationOnPath(+ { PATH: nonExecutablePath },+ process.platform,+ ),+ ).toBeUndefined();+ },+);++it("does not fall back to PATH when an explicit Ghidra installation path is malformed", () => {+ const inspection = inspectGhidraInstallation(+ {+ environment: { PATH: "/valid-ghidra-bin" },+ installDir: "relative/ghidra",+ platform: "linux",+ architecture: "x64",+ },+ host({ discoverInstallDirOnPath: () => INSTALL }),+ );+ expect(inspection.status).toBe("unavailable");+ expect(inspection.installDir).toBe("relative/ghidra");+ expect(inspection.checks[0]).toMatchObject({+ name: "configuration",+ status: "failed",+ detail: "GHIDRA_INSTALL_DIR must be absolute",+ });+});+it("probes the selected Java environment without reading conflicting ambient settings", () => {vi.stubEnv("REA_GHIDRA_CONTEXT", "ambient");vi.stubEnv("REA_GHIDRA_AMBIENT", "ambient-only");diff --git a/src/ghidra/GhidraInstallation.ts b/src/ghidra/GhidraInstallation.tsindex f30f6ef7a..6a77ee1af 100644--- a/src/ghidra/GhidraInstallation.ts+++ b/src/ghidra/GhidraInstallation.ts@@ -8,9 +8,10 @@ import {openSync,readFileSync,readSync,+ realpathSync,statSync,} from "node:fs";-import { posix, win32 } from "node:path";+import { delimiter as pathDelimiter, dirname, posix, win32 } from "node:path";import type { ProviderRejectionCode } from "../contracts/providerSelection.js";import {@@ -295,6 +296,11 @@ export interface GhidraInstallationHost {command: string,environment: NodeJS.ProcessEnv,): GhidraJavaObservation | undefined;+ /** Resolve a PATH launcher to a validated installation without executing it. */+ discoverInstallDirOnPath?(+ environment: Readonly<NodeJS.ProcessEnv>,+ platform: NodeJS.Platform,+ ): string | undefined;}interface GhidraInstallationCoordinates {@@ -405,7 +411,12 @@ const installationCoordinates = (host: GhidraInstallationHost,): GhidraInstallationCoordinates => {const path = platform === "win32" ? win32 : posix;- const installDir = options.installDir ?? null;+ // An explicit setting remains authoritative even when malformed or stale;+ // automatic discovery is only a fallback when the caller supplied none.+ const installDir =+ options.installDir ??+ host.discoverInstallDirOnPath?.(options.environment, platform) ??+ null;const applicationPropertiesPath =installDir === null? null@@ -958,12 +969,56 @@ const systemGhidraInstallationHost = (): GhidraInstallationHost => ({: "jre",};},+ discoverInstallDirOnPath: discoverGhidraInstallationOnPath,});+/** Find a PATH launcher whose real target is inside a complete Ghidra tree. */+export const discoverGhidraInstallationOnPath = (+ environment: Readonly<NodeJS.ProcessEnv>,+ platform: NodeJS.Platform,+): string | undefined => {+ if (platform !== process.platform) return undefined;+ const path = platform === "win32" ? win32 : posix;+ const pathValue = environment.PATH;+ if (pathValue === undefined || pathValue.length === 0) return undefined;+ const launchers =+ platform === "win32"+ ? ["ghidra.bat", "ghidraRun.bat", "ghidra.exe", "ghidraRun.exe"]+ : ["ghidra", "ghidraRun"];+ for (const directory of pathValue.split(pathDelimiter)) {+ if (directory.length === 0) continue;+ for (const launcher of launchers) {+ let resolved: string;+ try {+ const candidate = path.resolve(directory, launcher);+ if (!executablePath(candidate)) continue;+ resolved = realpathSync(candidate);+ } catch (cause: unknown) {+ void cause;+ continue;+ }+ const root = dirname(resolved);+ const properties = path.join(root, "Ghidra", "application.properties");+ const headless = path.join(+ root,+ "support",+ platform === "win32" ? "analyzeHeadless.bat" : "analyzeHeadless",+ );+ try {+ if (statSync(properties).isFile() && executablePath(headless))+ return root;+ } catch (cause: unknown) {+ void cause;+ }+ }+ }+ return undefined;+};+const executablePath = (path: string): boolean => {try {accessSync(path, constants.X_OK);- return true;+ return statSync(path).isFile();} catch (cause: unknown) {// best-effort cleanup: optional executable probing; failure means missing.void cause;