From b1c07dd9c6fe8c4dd109fefe67f4b16fdd1115d1 Mon Sep 17 00:00:00 2001 From: N0zoM1z0 <1705004398@qq.com> Date: Thu, 16 Jul 2026 01:51:27 +0800 Subject: [PATCH] feat(ghidra): implement read-only inventory operations --- README.md | 25 +- bridge/ghidra/ReaGhidraBridge.java | 1074 ++++++++++++++++- ...rovider-selection-and-analysis-profiles.md | 22 +- docs/api/assets/hierarchy.js | 2 +- docs/api/assets/navigation.js | 2 +- docs/api/assets/search.js | 2 +- ...rmissionAuthority.PermissionPathError.html | 2 +- ...ocessCaptureError.ProcessCaptureError.html | 2 +- ...sionStore.ProjectPermissionStoreError.html | 2 +- .../ghidra_GhidraClient.GhidraClient.html | 40 +- ...idra_GhidraLauncher.GhidraLaunchError.html | 2 +- .../ghidra_GhidraProvider.GhidraProvider.html | 21 +- ...raResponseRouter.GhidraResponseRouter.html | 6 +- ...GhidraSessionError.GhidraSessionError.html | 20 +- .../ghidra_protocol.GhidraRemoteError.html | 87 ++ .../domain_hopperValues.addressDistance.html | 2 +- ...omain_hopperValues.parseAddressedPage.html | 2 +- .../domain_hopperValues.parseDocuments.html | 2 +- ...ain_hopperValues.parseFunctionDossier.html | 2 +- .../domain_hopperValues.parseListCount.html | 2 +- .../domain_hopperValues.parseNames.html | 2 +- .../domain_hopperValues.parseProcedures.html | 2 +- ...in_hopperValues.parseRelatedAddresses.html | 2 +- .../domain_hopperValues.parseSegments.html | 2 +- ...toryValues.isGhidraInventoryOperation.html | 44 + ...ntoryValues.parseGhidraInventoryInput.html | 45 + ...toryValues.parseGhidraInventoryResult.html | 45 + ...SessionError.bindGhidraSessionFailure.html | 44 + ...alues.isGhidraShutdownAcknowledgement.html | 2 +- ...aSessionValues.parseGhidraSessionInfo.html | 6 +- .../ghidra_protocol.ghidraResponseResult.html | 6 +- ...idra_protocol.parseGhidraResponseLine.html | 2 +- docs/api/hierarchy.html | 34 +- docs/api/index.html | 4 +- ...ation_AnalysisProvider.AnalysisClient.html | 2 +- ...nalysisProvider.AnalysisOperationPort.html | 2 +- ...ion_AnalysisProvider.AnalysisProvider.html | 2 +- ...sisProvider.AnalysisProviderCandidate.html | 2 +- ...n_BinarySessionPort.BinarySessionPort.html | 2 +- ...GhidraClientTypes.GhidraClientOptions.html | 18 +- ...hidraClientTypes.GhidraRequestOptions.html | 64 + .../ghidra_GhidraLauncher.GhidraLaunch.html | 2 +- ...nseRouter.GhidraResponseRouterOptions.html | 14 +- ...essionError.GhidraSessionErrorOptions.html | 14 +- ...ProviderProcess.ProviderProcessLaunch.html | 2 +- docs/api/modules/ghidra_GhidraClient.html | 4 +- .../api/modules/ghidra_GhidraClientTypes.html | 4 +- .../modules/ghidra_GhidraInventoryValues.html | 44 + docs/api/modules/ghidra_GhidraProvider.html | 4 + .../modules/ghidra_GhidraSessionError.html | 8 +- .../modules/ghidra_GhidraSessionValues.html | 4 + docs/api/modules/ghidra_protocol.html | 4 + ...tracts_toolContracts.OfficialToolName.html | 2 +- .../domain_hopperValues.FunctionDossier.html | 2 +- ...ra_GhidraClientTypes.GhidraDiagnostic.html | 2 +- ...entoryValues.GhidraInventoryOperation.html | 35 + ...aProvider.GhidraProviderClientFactory.html | 47 + ...GhidraSessionValues.GhidraSessionInfo.html | 2 +- ...toolContracts.ENHANCED_TOOL_CONTRACTS.html | 2 +- ...toolContracts.OFFICIAL_TOOL_CONTRACTS.html | 2 +- ..._toolContracts.SESSION_TOOL_CONTRACTS.html | 2 +- ...ontracts_toolContracts.TOOL_CONTRACTS.html | 2 +- ...oolContracts.binarySessionInputSchema.html | 2 +- ...olOutputSchemas.artifactOutputSchemas.html | 2 +- ...olOutputSchemas.enhancedOutputSchemas.html | 2 +- ...toolOutputSchemas.nativeOutputSchemas.html | 2 +- ...olOutputSchemas.officialOutputSchemas.html | 4 +- ...oolOutputSchemas.sessionOutputSchemas.html | 2 +- ...in_hopperValues.functionDossierSchema.html | 2 +- ..._GhidraDefaults.GHIDRA_BRIDGE_VERSION.html | 2 +- ...oryValues.GHIDRA_INVENTORY_OPERATIONS.html | 35 + ...idraProvider.GHIDRA_PROVIDER_IDENTITY.html | 2 +- ...ovider.GHIDRA_PROVIDER_TOOL_CONTRACTS.html | 6 +- ...ionValues.GHIDRA_SESSION_CAPABILITIES.html | 35 + docs/architecture.mermaid | 4 +- docs/installation.md | 16 +- docs/product-catalog.json | 17 +- docs/provider-evaluation.md | 69 +- docs/roadmap.md | 19 +- scripts/verify-real-ghidra.mjs | 492 ++++++-- src/contracts/toolContracts.ts | 26 +- src/contracts/toolOutputSchemas.ts | 44 +- src/domain/hopperValues.ts | 26 +- src/ghidra/GhidraClient.ts | 67 +- src/ghidra/GhidraClientTypes.ts | 6 + src/ghidra/GhidraDefaults.ts | 2 +- src/ghidra/GhidraInventoryValues.ts | 243 ++++ src/ghidra/GhidraProvider.ts | 185 ++- src/ghidra/GhidraResponseRouter.ts | 7 +- src/ghidra/GhidraSessionError.ts | 50 + src/ghidra/GhidraSessionValues.ts | 24 +- src/ghidra/protocol.ts | 18 +- tests/conformance/README.md | 5 + tests/conformance/ghidra/inventory.c | 15 + tests/fixtures/fakeGhidra.mjs | 137 ++- tests/ghidraClient.test.ts | 55 +- tests/ghidraInventoryValues.test.ts | 232 ++++ tests/ghidraMcp.test.ts | 293 +++++ tests/ghidraProvider.test.ts | 167 ++- tests/productCatalog.test.ts | 7 +- tests/providerArchitecture.test.ts | 27 +- 101 files changed, 3825 insertions(+), 377 deletions(-) create mode 100644 docs/api/classes/ghidra_protocol.GhidraRemoteError.html create mode 100644 docs/api/functions/ghidra_GhidraInventoryValues.isGhidraInventoryOperation.html create mode 100644 docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html create mode 100644 docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html create mode 100644 docs/api/functions/ghidra_GhidraSessionError.bindGhidraSessionFailure.html create mode 100644 docs/api/interfaces/ghidra_GhidraClientTypes.GhidraRequestOptions.html create mode 100644 docs/api/modules/ghidra_GhidraInventoryValues.html create mode 100644 docs/api/types/ghidra_GhidraInventoryValues.GhidraInventoryOperation.html create mode 100644 docs/api/types/ghidra_GhidraProvider.GhidraProviderClientFactory.html create mode 100644 docs/api/variables/ghidra_GhidraInventoryValues.GHIDRA_INVENTORY_OPERATIONS.html create mode 100644 docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html create mode 100644 src/ghidra/GhidraInventoryValues.ts create mode 100644 tests/conformance/ghidra/inventory.c create mode 100644 tests/ghidraInventoryValues.test.ts create mode 100644 tests/ghidraMcp.test.ts diff --git a/README.md b/README.md index 3f82d6071..ae5517765 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ See a feature in an app that you want in your own product? Give the app to your agent—even without its source code. With REA, the agent can investigate the feature, explain how it works, show its evidence, and build a version adapted to your stack and requirements. -REA gives agents one consistent way to investigate software. Today that includes deep native analysis through Hopper, a bring-your-own Ghidra headless-session foundation on Linux, complete function dossiers, reproducible Evidence v2 records, controlled process capture, passive website and Electron observation, and bounded JavaScript/source-map reconstruction. The Ghidra foundation deliberately exposes no binary operations yet; Hopper remains the operation-capable deep provider. The longer-term toolkit extends the same agent workflow to APIs, protocols, mobile artifacts, firmware, richer runtime behavior, and differences between versions. +REA gives agents one consistent way to investigate software. Today that includes deep native analysis through Hopper, bring-your-own Ghidra read-only inventory on Linux, complete Hopper function dossiers, reproducible Evidence v2 records, controlled process capture, passive website and Electron observation, and bounded JavaScript/source-map reconstruction. The longer-term toolkit extends the same agent workflow to APIs, protocols, mobile artifacts, firmware, richer runtime behavior, and differences between versions. Reverse engineering normally makes the operator choose a tool, learn its API, move evidence between programs, and decide what to inspect next. REA gives that work to the agent through commands, skills, structured results, and repeatable investigation workflows. @@ -153,7 +153,7 @@ Choose either the no-install commands or the global installation. You do not nee - Node.js 22.19+ or 24.11+ (including newer releases) - npm; REA does not require or install a particular npm version -Deep binary operations currently use [Hopper](https://www.hopperapp.com/), a separate desktop application with its own license. REA also ships the first Ghidra provider layer: Linux x64 discovery, exact Ghidra 12.1.2/JDK 21 validation, deterministic target/profile binding, and a private read-only `analyzeHeadless` session. That layer intentionally declares no binary operations until their semantic contracts and real-provider conformance land. Setup reuses an existing Hopper installation or an operator-supplied Ghidra installation. It never downloads Ghidra or installs Java. If neither provider is ready, interactive setup proposes Hopper; unattended Hopper installation requires `rea setup --yes --install-hopper`. +Deep binary operations use [Hopper](https://www.hopperapp.com/), a separate desktop application with its own license, or a caller-selected Ghidra provider. Ghidra currently supplies program identity, procedure/string/symbol inventories, memory blocks, address/name and containing-procedure resolution, and bounded search; decompilation, calls, xrefs, GUI state, and mutations remain unavailable through that provider. Setup reuses an existing Hopper installation or an operator-supplied Ghidra installation. It never downloads Ghidra or installs Java. If neither provider is ready, interactive setup proposes Hopper; unattended Hopper installation requires `rea setup --yes --install-hopper`. If something is not working, run: @@ -186,7 +186,7 @@ Install the missing distribution packages and rerun `rea setup`. Linux demo auto REA defaults `HOPPER_LAUNCHER_PATH` to `/Applications/Hopper Disassembler.app/Contents/MacOS/hopper` on macOS and `/opt/hopper/bin/Hopper` on Linux. Explicit configuration always takes precedence. -### Ghidra headless-session foundation +### Ghidra read-only inventory provider The current Ghidra adapter supports the exact official Ghidra 12.1.2 release on Linux x64 with a 64-bit full JDK 21. Download and extract those projects yourself, then configure absolute paths: @@ -200,7 +200,11 @@ rea providers --json Doctor distinguishes missing configuration, a bad installation root, the wrong Ghidra or Java version, a JRE without `javac`, a missing `support/analyzeHeadless`, and an unsupported platform or architecture. Approved setup only copies the verified non-secret paths into detected MCP registrations; it does not modify the Ghidra installation or install/download Ghidra or Java. -REA loads its packaged Java `HeadlessScript` with `-scriptPath`, imports the target into a mode-0700 temporary project, enables `-readOnly` and `-deleteProject`, caps auto-analysis at 300 seconds with two CPUs and a 2 GiB Java heap, and authenticates `ping`/`shutdown` over a mode-0600 Unix socket. It isolates Ghidra home/cache/config/temp paths and removes the owned project, socket, process group, and runtime root on close, cancellation, timeout, or process exit. This proves the provider lifecycle and analysis-profile commitment; it does **not** make `decompile`, inventory, xref, or function operations available through Ghidra in this release. +REA loads its packaged Java `HeadlessScript` with `-scriptPath`, imports the target into a mode-0700 temporary project, enables `-readOnly` and `-deleteProject`, caps auto-analysis at 300 seconds with two CPUs and a 2 GiB Java heap, and authenticates every request over a mode-0600 Unix socket. It isolates Ghidra home/cache/config/temp paths and removes the owned project, socket, process group, and runtime root on close, cancellation, timeout, or process exit. + +The Ghidra adapter declares exactly ten direct operations: `list_documents`, `list_procedures`, `list_strings`, `list_names`, `list_segments`, `address_name`, `procedure_address`, `resolve_containing_procedure`, `search_procedures`, and `search_strings`. These also enable the shared Swift/Objective-C inventory workflows and `binary_overview`; workflows that require decompilation, calls, or xrefs remain unavailable. Default-space addresses are lowercase `0x` hexadecimal. Other spaces, including `EXTERNAL`, use `:0x`. Symbol results identify primary, dynamic, external, type, and source facts; procedures distinguish external functions and thunks; strings identify charset, missing-terminator state, byte length, and value truncation; memory-block ends are exclusive and permissions come directly from Ghidra. + +The bridge serves operations only after auto-analysis completes. An analysis timeout, inventory safety limit, request timeout, or oversized response fails explicitly instead of returning a partial result labeled complete. `npm run verify:ghidra` compiles source-owned debug and stripped ELF fixtures, validates external symbols and every admitted operation against real Ghidra 12.1.2, and proves cleanup. To remove only REA-owned MCP registrations and the managed skill: @@ -378,7 +382,7 @@ REA is growing into a toolkit for understanding software across static artifacts ### Now 1. **Maintain truthful product metadata** — extend the shipped canonical catalog and drift checks whenever versions, tools, providers, schemas, setup clients, or CLI capabilities change. -2. **Ghidra read-only operations** — extend the shipped discovery/profile/headless-session foundation with individually admitted inventory, decompilation, call, and xref capabilities, verified on real source-owned binaries without pretending Hopper and Ghidra results are textually identical. +2. **Ghidra function analysis** — extend the shipped read-only inventory operations with individually admitted decompilation, assembly, call, xref, and CFG capabilities, verified on real source-owned binaries without pretending Hopper and Ghidra results are textually identical. 3. **JavaScript application reconstruction** — connect packages, ASAR entries, main/preload/renderer bundles, source maps, Electron IPC boundaries, service-worker assets, and native add-ons in one evidence-bearing application graph. ### Next @@ -395,7 +399,7 @@ REA is growing into a toolkit for understanding software across static artifacts New providers must produce the same evidence and safety metadata as existing capabilities before they become part of the public workflow. Once REA has multiple optional toolchains, setup can become capability-selective; the consent rules for that future work are recorded in the [installation roadmap](docs/roadmap.md). -See the [static-analysis provider evaluation](docs/provider-evaluation.md) for the shipped Ghidra foundation, remaining admission gates, and provider comparison matrix, and [ADR-0001](docs/adr/0001-provider-selection-and-analysis-profiles.md) for the binding, selection, profile, snapshot, and compatibility decisions. +See the [static-analysis provider evaluation](docs/provider-evaluation.md) for the shipped Ghidra inventory boundary, remaining admission gates, and provider comparison matrix, and [ADR-0001](docs/adr/0001-provider-selection-and-analysis-profiles.md) for the binding, selection, profile, snapshot, and compatibility decisions. ## Using REA with other agents @@ -429,7 +433,7 @@ flowchart LR REA --> Session["Target-bound session router"] Session --> Registry["Deep-provider registry
deterministic selection"] Registry --> Hopper["Hopper provider"] - Registry --> Ghidra["Ghidra provider
headless foundation; no binary ops"] + Registry --> Ghidra["Ghidra provider
read-only inventory operations"] Hopper --> Runtime["Owned provider runtime
deadline + bounded diagnostics + cleanup"] Ghidra --> Runtime Session --> Native["Native macOS provider"] @@ -508,9 +512,10 @@ the authoritative `analysis_provider_candidates` and `analysis_provider_binding` fields. Reopening the same target without a selector keeps its binding; runtime failure never selects another provider silently. Ghidra can appear as an available, target-compatible candidate after doctor -validates its exact installation, but its capability list is empty in this -foundation release. Selecting it does not make Hopper-backed operations -available and never triggers a silent fallback. +validates its exact installation. Its capability list contains only the ten +admitted read-only inventory operations; selecting it does not make +Hopper-only decompilation, call/xref, GUI, or mutation operations available and +never triggers a silent fallback. ### CLI exit status diff --git a/bridge/ghidra/ReaGhidraBridge.java b/bridge/ghidra/ReaGhidraBridge.java index 42abe3e39..f484d0bf1 100644 --- a/bridge/ghidra/ReaGhidraBridge.java +++ b/bridge/ghidra/ReaGhidraBridge.java @@ -3,8 +3,10 @@ import java.io.BufferedReader; import java.io.BufferedWriter; +import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.Reader; +import java.math.BigInteger; import java.net.StandardProtocolFamily; import java.net.UnixDomainSocketAddress; import java.nio.channels.Channels; @@ -16,23 +18,50 @@ import java.nio.file.LinkOption; import java.nio.file.Path; import java.nio.file.attribute.PosixFilePermissions; import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; import java.util.Set; +import java.util.regex.Pattern; +import java.util.regex.PatternSyntaxException; import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonArray; import com.google.gson.JsonElement; +import com.google.gson.JsonNull; import com.google.gson.JsonObject; import com.google.gson.JsonParser; import ghidra.app.util.headless.HeadlessScript; import ghidra.framework.Application; +import ghidra.program.model.address.Address; +import ghidra.program.model.address.AddressSpace; +import ghidra.program.model.data.StringDataInstance; +import ghidra.program.model.listing.Data; +import ghidra.program.model.listing.DataIterator; +import ghidra.program.model.listing.Function; +import ghidra.program.model.listing.FunctionIterator; +import ghidra.program.model.mem.MemoryBlock; +import ghidra.program.model.symbol.SourceType; +import ghidra.program.model.symbol.Symbol; +import ghidra.program.model.symbol.SymbolIterator; public final class ReaGhidraBridge extends HeadlessScript { - private static final int BRIDGE_VERSION = 1; + private static final int BRIDGE_VERSION = 2; private static final int MAX_DESCRIPTOR_BYTES = 16 * 1024; - // A Java character occupies at most three UTF-8 bytes in this Reader, so - // this also keeps the decoded request below the 1 MiB wire budget. private static final int MAX_REQUEST_CHARACTERS = 256 * 1024; - private static final Gson GSON = new Gson(); + private static final int MAX_RESPONSE_BYTES = 1024 * 1024; + private static final int MAX_INVENTORY_ITEMS = 1_000_000; + private static final int MAX_LIST_VALUE_CODE_POINTS = 1_024; + private static final int MAX_SEARCH_VALUE_CODE_POINTS = 4_096; + private static final int MAX_REGEX_CANDIDATE_CHARACTERS = 4_096; + private static final long MAX_REGEX_BACKTRACKING_PATHS = 10_000; + private static final long MAX_LITERAL_SEARCH_WORK_UNITS = 1_000_000; + private static final long MAX_REGEX_SEARCH_WORK_UNITS = 1_000_000; + private static final Gson GSON = new GsonBuilder().serializeNulls().create(); private static final Set DESCRIPTOR_KEYS = Set.of( "schema_version", "socket_path", @@ -47,6 +76,25 @@ public final class ReaGhidraBridge extends HeadlessScript { "method", "params" ); + private static final String[] CAPABILITIES = { + "ping", + "shutdown", + "address_name", + "list_documents", + "list_names", + "list_procedures", + "list_segments", + "list_strings", + "procedure_address", + "resolve_containing_procedure", + "search_procedures", + "search_strings" + }; + + private List nameInventory; + private List procedureInventory; + private List stringInventory; + private static AddressSpace sessionDefaultAddressSpace; @Override public void run() throws Exception { @@ -60,6 +108,8 @@ public final class ReaGhidraBridge extends HeadlessScript { if (currentProgram == null) { throw new IllegalStateException("REA bridge requires an imported program"); } + sessionDefaultAddressSpace = + currentProgram.getAddressFactory().getDefaultAddressSpace(); if (!Application.getApplicationVersion().equals(descriptor.providerVersion)) { throw new IllegalStateException("Ghidra provider version does not match the session"); } @@ -100,21 +150,61 @@ public final class ReaGhidraBridge extends HeadlessScript { writeFailure(writer, 1, "invalid_request", "Bridge request is invalid"); return; } - if (request.method.equals("ping")) { - writeSuccess(writer, request.id, sessionInfo(descriptor)); - continue; + try { + if (request.method.equals("shutdown")) { + requireKeys(request.params, Set.of()); + JsonObject result = new JsonObject(); + result.addProperty("shutdown", true); + result.addProperty("project_ephemeral", true); + writeSuccess(writer, request.id, result); + return; + } + writeSuccess(writer, request.id, handleRequest(request, descriptor)); } - if (request.method.equals("shutdown")) { - JsonObject result = new JsonObject(); - result.addProperty("shutdown", true); - result.addProperty("project_ephemeral", true); - writeSuccess(writer, request.id, result); - return; + catch (RequestFailure failure) { + writeFailure(writer, request.id, failure.code, failure.getMessage()); + } + catch (Exception exception) { + writeFailure( + writer, + request.id, + "bridge_exception", + exception.getClass().getSimpleName() + ": " + safeMessage(exception) + ); } - writeFailure(writer, request.id, "method_unavailable", "Bridge method is unavailable"); } } + private JsonElement handleRequest(Request request, SessionDescriptor descriptor) + throws Exception { + if (request.method.equals("ping")) { + requireKeys(request.params, Set.of()); + return sessionInfo(descriptor); + } + if (analysisTimeoutOccurred()) { + throw new RequestFailure( + "analysis_incomplete", + "Ghidra auto-analysis did not complete for this Program" + ); + } + return switch (request.method) { + case "address_name" -> addressName(request.params); + case "list_documents" -> listDocuments(request.params); + case "list_names" -> listNames(request.params); + case "list_procedures" -> listProcedures(request.params); + case "list_segments" -> listSegments(request.params); + case "list_strings" -> listStrings(request.params); + case "procedure_address" -> procedureAddress(request.params); + case "resolve_containing_procedure" -> containingProcedure(request.params); + case "search_procedures" -> search(request.params, true); + case "search_strings" -> search(request.params, false); + default -> throw new RequestFailure( + "method_unavailable", + "Bridge method is unavailable" + ); + }; + } + private JsonObject sessionInfo(SessionDescriptor descriptor) throws Exception { boolean timedOut = analysisTimeoutOccurred(); JsonObject provider = new JsonObject(); @@ -128,6 +218,11 @@ public final class ReaGhidraBridge extends HeadlessScript { "compiler_spec_id", currentProgram.getCompilerSpec().getCompilerSpecID().getIdAsString() ); + target.addProperty("image_base", canonicalAddress(currentProgram.getImageBase())); + target.addProperty( + "default_address_space", + currentProgram.getAddressFactory().getDefaultAddressSpace().getName() + ); JsonObject result = new JsonObject(); result.addProperty("name", "REA Ghidra bridge"); @@ -138,11 +233,588 @@ public final class ReaGhidraBridge extends HeadlessScript { result.addProperty("read_only", true); result.addProperty("analysis_complete", !timedOut); result.addProperty("analysis_timed_out", timedOut); - result.add("capabilities", GSON.toJsonTree(new String[] { "ping", "shutdown" })); + result.add("capabilities", GSON.toJsonTree(CAPABILITIES)); result.add("target", target); return result; } + private JsonElement addressName(JsonObject params) { + requireKeys(params, Set.of("document", "address")); + requireDocument(params); + Address address = requireAddress(params, "address"); + Symbol symbol = currentProgram.getSymbolTable().getPrimarySymbol(address); + return symbol == null ? JsonNull.INSTANCE : GSON.toJsonTree(symbol.getName(true)); + } + + private JsonArray listDocuments(JsonObject params) { + requireKeys(params, Set.of()); + JsonArray result = new JsonArray(); + result.add(currentProgram.getName()); + return result; + } + + private JsonObject listNames(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "address", "offset", "limit")); + requireDocument(params); + List inventory = names(); + String requested = optionalString(params, "address"); + if (requested != null) { + Address address = parseReaAddress(requested); + inventory = inventory.stream() + .filter(item -> item.address.equals(address)) + .toList(); + } + return page( + inventory, + requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE), + requireBoundedInteger(params, "limit", 1, 500), + "symbol" + ); + } + + private JsonObject listProcedures(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "offset", "limit")); + requireDocument(params); + List inventory = procedures().stream() + .map(FunctionEntry::item) + .toList(); + return page( + inventory, + requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE), + requireBoundedInteger(params, "limit", 1, 500), + "procedure" + ); + } + + private JsonArray listSegments(JsonObject params) { + requireKeys(params, Set.of("document")); + requireDocument(params); + JsonArray result = new JsonArray(); + String imageBase = canonicalAddress(currentProgram.getImageBase()); + MemoryBlock[] blocks = currentProgram.getMemory().getBlocks(); + if (blocks.length > MAX_INVENTORY_ITEMS) { + throw inventoryLimit(); + } + List ordered = new ArrayList<>(List.of(blocks)); + ordered.sort(Comparator.comparing(MemoryBlock::getStart)); + for (MemoryBlock block : ordered) { + JsonObject item = memoryRegion(block, imageBase); + item.add("sections", new JsonArray()); + result.add(item); + } + return result; + } + + private JsonObject listStrings(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "address", "offset", "limit")); + requireDocument(params); + List inventory = strings(); + String requested = optionalString(params, "address"); + if (requested != null) { + Address address = parseReaAddress(requested); + inventory = inventory.stream() + .filter(item -> item.address.equals(address)) + .toList(); + } + return page( + inventory, + requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE), + requireBoundedInteger(params, "limit", 1, 500), + "string" + ); + } + + private JsonElement procedureAddress(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "procedure")); + requireDocument(params); + return GSON.toJsonTree(canonicalAddress(resolveProcedure(requireString(params, "procedure")).getEntryPoint())); + } + + private JsonObject containingProcedure(JsonObject params) { + requireKeys(params, Set.of("document", "address")); + requireDocument(params); + Address query = requireAddress(params, "address"); + Function function = currentProgram.getFunctionManager().getFunctionAt(query); + if (function == null && query.isMemoryAddress()) { + function = currentProgram.getFunctionManager().getFunctionContaining(query); + } + JsonObject result = new JsonObject(); + result.addProperty("query_address", canonicalAddress(query)); + if (function != null) { + result.addProperty("found", true); + result.add("procedure", procedureIdentity(function)); + return result; + } + result.addProperty("found", false); + result.add("procedure", JsonNull.INSTANCE); + boolean inside = query.isMemoryAddress() && currentProgram.getMemory().contains(query); + result.addProperty("reason", inside ? "not_in_procedure" : "outside_segments"); + return result; + } + + private JsonObject search(JsonObject params, boolean procedureSearch) throws Exception { + requireKeys( + params, + Set.of("pattern", "mode", "case_sensitive", "offset", "limit", "document") + ); + requireDocument(params); + String expression = requireString(params, "pattern"); + if (expression.codePointCount(0, expression.length()) > 256) { + throw new RequestFailure( + "invalid_request", + "pattern must contain between 1 and 256 characters" + ); + } + String mode = requireString(params, "mode"); + if (!mode.equals("literal") && !mode.equals("regex")) { + throw new RequestFailure("invalid_request", "mode must be literal or regex"); + } + boolean caseSensitive = requireBoolean(params, "case_sensitive"); + int offset = requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE); + int limit = requireBoundedInteger(params, "limit", 1, 100); + List inventory = procedureSearch + ? procedures().stream().map(FunctionEntry::item).toList() + : strings(); + ValueMatcher matcher = mode.equals("literal") + ? literalMatcher(expression, caseSensitive) + : regexMatcher(expression, caseSensitive); + JsonArray items = new JsonArray(); + int total = 0; + long pageEnd = (long) offset + limit; + for (InventoryItem item : inventory) { + if (!matcher.matches(item.value)) { + continue; + } + if (total >= offset && total < pageEnd) { + items.add(resultItem(item, null, MAX_SEARCH_VALUE_CODE_POINTS)); + } + total += 1; + } + return pageResult(items, offset, limit, total); + } + + private List names() throws Exception { + if (nameInventory != null) { + return nameInventory; + } + List result = new ArrayList<>(); + SymbolIterator symbols = currentProgram.getSymbolTable().getAllSymbols(true); + while (symbols.hasNext()) { + monitor.checkCancelled(); + Symbol symbol = symbols.next(); + Address address = symbol.getAddress(); + if (!address.isMemoryAddress() && !address.isExternalAddress()) { + continue; + } + JsonObject facts = new JsonObject(); + facts.addProperty("primary", symbol.isPrimary()); + facts.addProperty("dynamic", symbol.isDynamic()); + facts.addProperty("external", symbol.isExternal()); + facts.addProperty("type", normalizedSymbolType(symbol)); + facts.addProperty("source", normalizedSource(symbol.getSource())); + addBounded( + result, + new InventoryItem(address, symbol.getName(true), facts) + ); + } + result.sort(INVENTORY_ORDER); + nameInventory = List.copyOf(result); + return nameInventory; + } + + private List procedures() throws Exception { + if (procedureInventory != null) { + return procedureInventory; + } + List result = new ArrayList<>(); + Set
seen = new HashSet<>(); + appendFunctions(result, seen, currentProgram.getFunctionManager().getFunctions(true)); + appendFunctions(result, seen, currentProgram.getFunctionManager().getExternalFunctions()); + result.sort((left, right) -> INVENTORY_ORDER.compare(left.item, right.item)); + procedureInventory = List.copyOf(result); + return procedureInventory; + } + + private void appendFunctions( + List destination, + Set
seen, + FunctionIterator functions) throws Exception { + while (functions.hasNext()) { + monitor.checkCancelled(); + Function function = functions.next(); + if (!seen.add(function.getEntryPoint())) { + continue; + } + JsonObject facts = new JsonObject(); + facts.addProperty("external", function.isExternal()); + facts.addProperty("thunk", function.isThunk()); + Function target = function.isThunk() ? function.getThunkedFunction(false) : null; + if (target == null) { + facts.add("thunk_target", JsonNull.INSTANCE); + } + else { + facts.addProperty("thunk_target", canonicalAddress(target.getEntryPoint())); + } + Symbol symbol = function.getSymbol(); + InventoryItem item = new InventoryItem( + function.getEntryPoint(), + symbol == null ? function.getName() : symbol.getName(true), + facts + ); + if (destination.size() >= MAX_INVENTORY_ITEMS) { + throw inventoryLimit(); + } + destination.add(new FunctionEntry(function, item)); + } + } + + private List strings() throws Exception { + if (stringInventory != null) { + return stringInventory; + } + List result = new ArrayList<>(); + DataIterator dataItems = currentProgram.getListing().getDefinedData(true); + while (dataItems.hasNext()) { + monitor.checkCancelled(); + Data data = dataItems.next(); + if (!data.hasStringValue()) { + continue; + } + StringDataInstance instance = StringDataInstance.getStringDataInstance(data); + String value = instance.getStringValue(); + if (value == null) { + continue; + } + JsonObject facts = new JsonObject(); + String charset = instance.getCharsetName(); + facts.addProperty("encoding", charset == null || charset.isEmpty() ? "unknown" : charset); + facts.addProperty( + "termination", + instance.isMissingNullTerminator() ? "missing" : "present_or_not_required" + ); + facts.addProperty("byte_length", Math.max(0, data.getLength())); + addBounded(result, new InventoryItem(data.getAddress(), value, facts)); + } + result.sort(INVENTORY_ORDER); + stringInventory = List.copyOf(result); + return stringInventory; + } + + private Function resolveProcedure(String value) throws Exception { + Address address = tryParseAddress(value); + if (address != null) { + Function function = currentProgram.getFunctionManager().getFunctionAt(address); + if (function == null && address.isMemoryAddress()) { + function = currentProgram.getFunctionManager().getFunctionContaining(address); + } + if (function == null) { + throw new RequestFailure("not_found", "No procedure exists at the requested address"); + } + return function; + } + List matches = new ArrayList<>(); + for (FunctionEntry entry : procedures()) { + Function function = entry.function; + Symbol symbol = function.getSymbol(); + String qualified = symbol == null ? function.getName() : symbol.getName(true); + if (function.getName().equals(value) || qualified.equals(value)) { + matches.add(function); + } + } + if (matches.isEmpty()) { + throw new RequestFailure("not_found", "Unknown Ghidra procedure name"); + } + if (matches.size() != 1) { + throw new RequestFailure("ambiguous", "Ghidra procedure name is ambiguous"); + } + return matches.get(0); + } + + private JsonObject page( + List inventory, + int offset, + int limit, + String factsName) { + int start = Math.min(offset, inventory.size()); + int end = Math.min(inventory.size(), start + limit); + JsonArray items = new JsonArray(); + for (int index = start; index < end; index += 1) { + items.add(resultItem(inventory.get(index), factsName, MAX_LIST_VALUE_CODE_POINTS)); + } + return pageResult(items, offset, limit, inventory.size()); + } + + private static JsonObject pageResult(JsonArray items, int offset, int limit, int total) { + int next = offset + items.size(); + boolean hasMore = next < total; + JsonObject result = new JsonObject(); + result.add("items", items); + result.addProperty("offset", offset); + result.addProperty("limit", limit); + result.addProperty("total", total); + if (hasMore) { + result.addProperty("next_offset", next); + } + else { + result.add("next_offset", JsonNull.INSTANCE); + } + result.addProperty("has_more", hasMore); + return result; + } + + private static JsonObject resultItem( + InventoryItem item, + String factsName, + int maximumCodePoints) { + TruncatedValue truncated = truncate(item.value, maximumCodePoints); + JsonObject result = new JsonObject(); + result.addProperty("address", canonicalAddress(item.address)); + result.addProperty("value", truncated.value); + result.addProperty("value_truncated", truncated.truncated); + if (factsName != null) { + result.add(factsName, item.facts.deepCopy()); + } + return result; + } + + private static JsonObject memoryRegion(MemoryBlock block, String imageBase) { + JsonObject permissions = new JsonObject(); + permissions.addProperty("available", true); + permissions.addProperty("source", "ghidra-memory-block"); + JsonObject result = new JsonObject(); + result.addProperty("name", block.getName()); + result.addProperty("start", canonicalAddress(block.getStart())); + result.addProperty("end", exclusiveEnd(block)); + result.addProperty("readable", block.isRead()); + result.addProperty("writable", block.isWrite()); + result.addProperty("executable", block.isExecute()); + result.add("permissions", permissions); + result.addProperty("provenance", "ghidra-memory-block"); + result.addProperty("address_space", block.getStart().getAddressSpace().getName()); + result.addProperty("image_base", imageBase); + result.addProperty("initialized", block.isInitialized()); + result.addProperty("overlay", block.isOverlay()); + return result; + } + + private static JsonObject procedureIdentity(Function function) { + JsonObject result = new JsonObject(); + result.addProperty("address", canonicalAddress(function.getEntryPoint())); + Symbol symbol = function.getSymbol(); + result.addProperty( + "name", + symbol == null ? function.getName() : symbol.getName(true) + ); + return result; + } + + private static String exclusiveEnd(MemoryBlock block) { + Address next = block.getEnd().next(); + if (next != null && next.getAddressSpace().equals(block.getStart().getAddressSpace())) { + return canonicalAddress(next); + } + BigInteger start = new BigInteger(Long.toUnsignedString(block.getStart().getOffset())); + return canonicalOffset( + block.getStart().getAddressSpace(), + start.add(BigInteger.valueOf(block.getSize())) + ); + } + + private static String canonicalAddress(Address address) { + return canonicalOffset( + address.getAddressSpace(), + new BigInteger(Long.toUnsignedString(address.getOffset())) + ); + } + + private static String canonicalOffset(AddressSpace space, BigInteger offset) { + String value = "0x" + offset.toString(16); + if (space.equals(sessionDefaultAddressSpace)) { + return value; + } + return encodeAddressSpace(space.getName()) + ":" + value; + } + + private Address requireAddress(JsonObject params, String name) { + return parseReaAddress(requireString(params, name)); + } + + private Address parseReaAddress(String value) { + Address address = tryParseAddress(value); + if (address == null) { + throw new RequestFailure("invalid_request", "Unknown or invalid Ghidra address"); + } + return address; + } + + private Address tryParseAddress(String value) { + try { + String spaceName = null; + String offset = value; + int separator = value.lastIndexOf(":0x"); + if (separator >= 0) { + spaceName = decodeAddressSpace(value.substring(0, separator)); + offset = value.substring(separator + 3); + } + else if (value.startsWith("0x")) { + offset = value.substring(2); + } + if (!offset.matches("[0-9A-Fa-f]+")) { + return null; + } + AddressSpace space = spaceName == null + ? currentProgram.getAddressFactory().getDefaultAddressSpace() + : currentProgram.getAddressFactory().getAddressSpace(spaceName); + return space == null ? null : space.getAddress(offset); + } + catch (Exception exception) { + return null; + } + } + + private static String encodeAddressSpace(String value) { + StringBuilder result = new StringBuilder(); + for (byte item : value.getBytes(StandardCharsets.UTF_8)) { + int unsigned = Byte.toUnsignedInt(item); + if ((unsigned >= 'A' && unsigned <= 'Z') || + (unsigned >= 'a' && unsigned <= 'z') || + (unsigned >= '0' && unsigned <= '9') || + unsigned == '.' || unsigned == '_' || unsigned == '~' || unsigned == '-') { + result.append((char) unsigned); + } + else { + result.append('%'); + result.append(Character.toUpperCase(Character.forDigit(unsigned >>> 4, 16))); + result.append(Character.toUpperCase(Character.forDigit(unsigned & 0xf, 16))); + } + } + return result.toString(); + } + + private static String decodeAddressSpace(String value) { + ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + for (int index = 0; index < value.length();) { + char item = value.charAt(index); + if (item == '%') { + if (index + 2 >= value.length()) { + throw new RequestFailure("invalid_request", "Address space encoding is invalid"); + } + int high = Character.digit(value.charAt(index + 1), 16); + int low = Character.digit(value.charAt(index + 2), 16); + if (high < 0 || low < 0) { + throw new RequestFailure("invalid_request", "Address space encoding is invalid"); + } + bytes.write((high << 4) | low); + index += 3; + } + else if ((item >= 'A' && item <= 'Z') || + (item >= 'a' && item <= 'z') || + (item >= '0' && item <= '9') || + item == '.' || item == '_' || item == '~' || item == '-') { + bytes.write((byte) item); + index += 1; + } + else { + throw new RequestFailure("invalid_request", "Address space encoding is invalid"); + } + } + return bytes.toString(StandardCharsets.UTF_8); + } + + private static String normalizedSymbolType(Symbol symbol) { + String value = symbol.getSymbolType().toString() + .toLowerCase(Locale.ROOT) + .replaceAll("[^a-z0-9]+", "_") + .replaceAll("^_+|_+$", ""); + return value.isEmpty() ? "unknown" : value; + } + + private static String normalizedSource(SourceType source) { + return source.name().toLowerCase(Locale.ROOT); + } + + private static void addBounded(List destination, InventoryItem item) { + if (destination.size() >= MAX_INVENTORY_ITEMS) { + throw inventoryLimit(); + } + destination.add(item); + } + + private static RequestFailure inventoryLimit() { + return new RequestFailure( + "limit_exceeded", + "Ghidra inventory exceeds the 1000000-item safety limit" + ); + } + + private static TruncatedValue truncate(String value, int maximumCodePoints) { + int codePoints = value.codePointCount(0, value.length()); + if (codePoints <= maximumCodePoints) { + return new TruncatedValue(value, false); + } + int end = value.offsetByCodePoints(0, maximumCodePoints); + return new TruncatedValue(value.substring(0, end), true); + } + + private static ValueMatcher literalMatcher(String pattern, boolean caseSensitive) { + String needle = caseSensitive ? pattern : pattern.toLowerCase(Locale.ROOT); + return new ValueMatcher() { + private long remaining = MAX_LITERAL_SEARCH_WORK_UNITS; + + @Override + public boolean matches(String value) { + long required = (long) Math.max(value.length(), 1) + needle.length(); + if (required > remaining) { + throw new RequestFailure( + "limit_exceeded", + "Literal search exceeds the 1000000-unit work budget" + ); + } + remaining -= required; + String candidate = caseSensitive ? value : value.toLowerCase(Locale.ROOT); + return candidate.contains(needle); + } + }; + } + + private static ValueMatcher regexMatcher(String expression, boolean caseSensitive) { + RegexMetrics metrics; + Pattern pattern; + try { + metrics = new BoundedRegexParser(expression).parse(); + pattern = Pattern.compile( + expression, + caseSensitive ? 0 : Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE + ); + } + catch (PatternSyntaxException exception) { + throw new RequestFailure("invalid_request", "Invalid regex pattern"); + } + long workPerCharacter = metrics.paths * Math.max(metrics.steps, 1); + return new ValueMatcher() { + private long remaining = MAX_REGEX_SEARCH_WORK_UNITS; + + @Override + public boolean matches(String value) { + if (value.length() > MAX_REGEX_CANDIDATE_CHARACTERS) { + throw new RequestFailure( + "limit_exceeded", + "Regex candidate exceeds the 4096-character safety limit" + ); + } + long required = workPerCharacter * Math.max(value.length(), 1); + if (required > remaining) { + throw new RequestFailure( + "limit_exceeded", + "Regex search exceeds the 1000000-unit work budget" + ); + } + remaining -= required; + return pattern.matcher(value).find(); + } + }; + } + private static SessionDescriptor readDescriptor(Path path) throws IOException { if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS) || Files.size(path) > MAX_DESCRIPTOR_BYTES) { @@ -171,12 +843,10 @@ public final class ReaGhidraBridge extends HeadlessScript { throw new IllegalArgumentException("Bridge request authentication failed"); } JsonElement params = object.get("params"); - if (params == null || - !params.isJsonObject() || - params.getAsJsonObject().size() != 0) { + if (params == null || !params.isJsonObject()) { throw new IllegalArgumentException("Bridge request parameters are invalid"); } - return new Request(id, requireString(object, "method")); + return new Request(id, requireString(object, "method"), params.getAsJsonObject()); } private static JsonObject requireObject(JsonElement element, Set keys) { @@ -190,14 +860,42 @@ public final class ReaGhidraBridge extends HeadlessScript { return object; } - private static String requireString(JsonObject object, String name) { + private static void requireKeys(JsonObject object, Set keys) { + if (!object.keySet().equals(keys)) { + throw new RequestFailure("invalid_request", "Bridge request fields are invalid"); + } + } + + private void requireDocument(JsonObject params) { + String document = optionalString(params, "document"); + if (document != null && !document.equals(currentProgram.getName())) { + throw new RequestFailure("not_found", "Unknown Ghidra Program identity"); + } + } + + private static String optionalString(JsonObject object, String name) { JsonElement value = object.get(name); - if (value == null || !value.isJsonPrimitive() || !value.getAsJsonPrimitive().isString()) { - throw new IllegalArgumentException("JSON string required"); + if (value == null || value.isJsonNull()) { + return null; + } + if (!value.isJsonPrimitive() || !value.getAsJsonPrimitive().isString()) { + throw new RequestFailure("invalid_request", name + " must be a string or null"); } String result = value.getAsString(); if (result.isEmpty()) { - throw new IllegalArgumentException("JSON string cannot be empty"); + throw new RequestFailure("invalid_request", name + " cannot be empty"); + } + return result; + } + + private static String requireString(JsonObject object, String name) { + JsonElement value = object.get(name); + if (value == null || !value.isJsonPrimitive() || !value.getAsJsonPrimitive().isString()) { + throw new RequestFailure("invalid_request", name + " must be a string"); + } + String result = value.getAsString(); + if (result.isEmpty()) { + throw new RequestFailure("invalid_request", name + " cannot be empty"); } return result; } @@ -214,6 +912,34 @@ public final class ReaGhidraBridge extends HeadlessScript { return result; } + private static int requireBoundedInteger( + JsonObject object, + String name, + int minimum, + int maximum) { + try { + int value = requireInteger(object, name); + if (value < minimum || value > maximum) { + throw new RequestFailure( + "invalid_request", + name + " is outside its supported range" + ); + } + return value; + } + catch (IllegalArgumentException exception) { + throw new RequestFailure("invalid_request", name + " must be an integer"); + } + } + + private static boolean requireBoolean(JsonObject object, String name) { + JsonElement value = object.get(name); + if (value == null || !value.isJsonPrimitive() || !value.getAsJsonPrimitive().isBoolean()) { + throw new RequestFailure("invalid_request", name + " must be a boolean"); + } + return value.getAsBoolean(); + } + private static boolean constantTimeEquals(String provided, String expected) { return MessageDigest.isEqual( provided.getBytes(StandardCharsets.UTF_8), @@ -265,11 +991,40 @@ public final class ReaGhidraBridge extends HeadlessScript { } private static void writeResponse(BufferedWriter writer, JsonObject response) throws IOException { - writer.write(GSON.toJson(response)); + String encoded = GSON.toJson(response); + if (encoded.getBytes(StandardCharsets.UTF_8).length > MAX_RESPONSE_BYTES) { + int id = response.get("id").getAsInt(); + JsonObject error = new JsonObject(); + error.addProperty("code", "output_limit"); + error.addProperty("message", "Ghidra response exceeds the 1 MiB wire limit"); + JsonObject bounded = new JsonObject(); + bounded.addProperty("id", id); + bounded.addProperty("ok", false); + bounded.add("error", error); + encoded = GSON.toJson(bounded); + } + writer.write(encoded); writer.newLine(); writer.flush(); } + private static String safeMessage(Exception exception) { + String message = exception.getMessage(); + return message == null || message.isBlank() ? "operation failed" : message; + } + + private interface ValueMatcher { + boolean matches(String value); + } + + private static final Comparator INVENTORY_ORDER = + Comparator.comparing(InventoryItem::address) + .thenComparing(InventoryItem::value) + .thenComparing(item -> GSON.toJson(item.facts)); + + private record InventoryItem(Address address, String value, JsonObject facts) {} + private record FunctionEntry(Function function, InventoryItem item) {} + private record TruncatedValue(String value, boolean truncated) {} private record SessionDescriptor( String socketPath, String token, @@ -277,6 +1032,275 @@ public final class ReaGhidraBridge extends HeadlessScript { String providerVersion, String profileDigest ) {} + private record Request(int id, String method, JsonObject params) {} + private record RegexMetrics(long paths, long steps, boolean containsRepeat) {} - private record Request(int id, String method) {} + private static final class RequestFailure extends RuntimeException { + private final String code; + + RequestFailure(String code, String message) { + super(message); + this.code = code; + } + } + + private static final class BoundedRegexParser { + private final String expression; + private int index; + + BoundedRegexParser(String expression) { + this.expression = expression; + } + + RegexMetrics parse() { + RegexMetrics result = parseExpression(false); + if (index != expression.length()) { + throw invalidRegex(); + } + return result; + } + + private RegexMetrics parseExpression(boolean grouped) { + RegexMetrics result = parseSequence(grouped); + while (peek('|')) { + index += 1; + RegexMetrics branch = parseSequence(grouped); + result = new RegexMetrics( + checkedPaths(result.paths, branch.paths, false), + Math.max(result.steps, branch.steps), + result.containsRepeat || branch.containsRepeat + ); + } + return result; + } + + private RegexMetrics parseSequence(boolean grouped) { + RegexMetrics result = new RegexMetrics(1, 0, false); + while (index < expression.length() && !peek('|') && !(grouped && peek(')'))) { + RegexMetrics item = parseAtom(); + result = new RegexMetrics( + checkedPaths(result.paths, item.paths, true), + result.steps + item.steps, + result.containsRepeat || item.containsRepeat + ); + } + return result; + } + + private RegexMetrics parseAtom() { + if (index >= expression.length()) { + throw invalidRegex(); + } + char item = expression.charAt(index++); + RegexMetrics atom; + if (item == '(') { + if (peek('?')) { + if (index + 1 >= expression.length() || expression.charAt(index + 1) != ':') { + throw new RequestFailure( + "invalid_request", + "Regex lookarounds and backreferences are not supported" + ); + } + index += 2; + } + atom = parseExpression(true); + if (!peek(')')) { + throw invalidRegex(); + } + index += 1; + } + else if (item == '[') { + consumeCharacterClass(); + atom = leaf(); + } + else if (item == '\\') { + consumeEscape(); + atom = leaf(); + } + else if (item == '*' || item == '+') { + throw unboundedRepeat(); + } + else if (item == '?' || item == '{' || item == '}' || item == ')') { + throw invalidRegex(); + } + else { + atom = leaf(); + } + if (index >= expression.length()) { + return atom; + } + if (peek('*') || peek('+')) { + throw unboundedRepeat(); + } + int minimum; + int maximum; + if (peek('?')) { + index += 1; + minimum = 0; + maximum = 1; + } + else if (peek('{')) { + int[] bounds = consumeBounds(); + minimum = bounds[0]; + maximum = bounds[1]; + } + else { + return atom; + } + if (atom.containsRepeat) { + throw new RequestFailure( + "invalid_request", + "Nested regex repetitions are not supported" + ); + } + if (maximum > 1_000) { + throw unboundedRepeat(); + } + return new RegexMetrics( + repeatPaths(atom.paths, minimum, maximum), + maximum * atom.steps, + true + ); + } + + private void consumeCharacterClass() { + boolean escaped = false; + boolean hasContent = false; + while (index < expression.length()) { + char item = expression.charAt(index++); + if (escaped) { + escaped = false; + hasContent = true; + } + else if (item == '\\') { + escaped = true; + } + else if (item == ']' && hasContent) { + return; + } + else { + hasContent = true; + } + } + throw invalidRegex(); + } + + private void consumeEscape() { + if (index >= expression.length()) { + throw invalidRegex(); + } + char escaped = expression.charAt(index++); + if (Character.isDigit(escaped) || escaped == 'k') { + throw new RequestFailure( + "invalid_request", + "Regex lookarounds and backreferences are not supported" + ); + } + if (escaped == 'Q' || escaped == 'E' || escaped == 'p' || escaped == 'P') { + throw new RequestFailure( + "invalid_request", + "Regex operation is not supported by the bounded matcher" + ); + } + if (escaped == 'x') { + consumeHexDigits(2); + } + else if (escaped == 'u') { + consumeHexDigits(4); + } + } + + private void consumeHexDigits(int count) { + if (index + count > expression.length()) { + throw invalidRegex(); + } + for (int current = 0; current < count; current += 1) { + if (Character.digit(expression.charAt(index + current), 16) < 0) { + throw invalidRegex(); + } + } + index += count; + } + + private int[] consumeBounds() { + index += 1; + int minimum = consumeDecimal(); + int maximum = minimum; + if (peek(',')) { + index += 1; + if (peek('}')) { + throw unboundedRepeat(); + } + maximum = consumeDecimal(); + } + if (!peek('}') || minimum > maximum) { + throw invalidRegex(); + } + index += 1; + return new int[] { minimum, maximum }; + } + + private int consumeDecimal() { + int start = index; + long value = 0; + while (index < expression.length() && Character.isDigit(expression.charAt(index))) { + value = value * 10 + Character.digit(expression.charAt(index), 10); + if (value > Integer.MAX_VALUE) { + throw unboundedRepeat(); + } + index += 1; + } + if (index == start) { + throw invalidRegex(); + } + return (int) value; + } + + private boolean peek(char expected) { + return index < expression.length() && expression.charAt(index) == expected; + } + + private static RegexMetrics leaf() { + return new RegexMetrics(1, 1, false); + } + + private static long repeatPaths(long childPaths, int minimum, int maximum) { + long result = 0; + long repeated = 1; + for (int count = 0; count <= maximum; count += 1) { + if (count >= minimum) { + result = checkedPaths(result, repeated, false); + } + if (count < maximum) { + repeated = checkedPaths(repeated, childPaths, true); + } + } + return result; + } + + private static long checkedPaths(long left, long right, boolean multiply) { + boolean exceeded = multiply + ? right != 0 && left > MAX_REGEX_BACKTRACKING_PATHS / right + : left > MAX_REGEX_BACKTRACKING_PATHS - right; + long result = multiply ? left * right : left + right; + if (exceeded || result > MAX_REGEX_BACKTRACKING_PATHS) { + throw new RequestFailure( + "invalid_request", + "Regex exceeds the 10000-path backtracking budget" + ); + } + return result; + } + + private static RequestFailure unboundedRepeat() { + return new RequestFailure( + "invalid_request", + "Unbounded or excessive regex repetitions are not supported" + ); + } + + private static RequestFailure invalidRegex() { + return new RequestFailure("invalid_request", "Invalid regex pattern"); + } + } } diff --git a/docs/adr/0001-provider-selection-and-analysis-profiles.md b/docs/adr/0001-provider-selection-and-analysis-profiles.md index 8ec99d073..37cba24cf 100644 --- a/docs/adr/0001-provider-selection-and-analysis-profiles.md +++ b/docs/adr/0001-provider-selection-and-analysis-profiles.md @@ -5,9 +5,9 @@ - Implementation status: The provider registry, deterministic selection, target binding, analysis-profile commitment, and snapshot/Evidence migration are implemented. Ghidra discovery, target/profile resolution, doctor checks, - and the private headless-session foundation are implemented; Ghidra analysis - capabilities remain intentionally undeclared pending operation-level - conformance work. + the private headless-session foundation, and ten read-only inventory + capabilities are implemented. Function-analysis capabilities remain gated on + operation-level conformance work. ## Context @@ -538,7 +538,7 @@ into false certainty. ## Implementation progress -The first four implementation stages are shipped: +The first five implementation stages are shipped: 1. Provider-specific target state was replaced by generic profile and snapshot v2 commitments while preserving Hopper execution behavior. @@ -547,9 +547,13 @@ The first four implementation stages are shipped: 3. Proven process-lifecycle primitives were extracted for shared use. 4. Ghidra availability, target/profile resolution, doctor checks, and a private read-only headless session were admitted without declaring operations. +5. Program identity, procedures, strings, symbols, memory blocks, + address/name resolution, containing-procedure resolution, and bounded search + were admitted with exact wire schemas and real debug/stripped ELF + conformance. -The remaining stage is to add Ghidra capabilities individually and verify each -real semantic claim across the shared source-owned conformance corpus. Until -that happens, Hopper remains the only deep provider with callable analysis -operations; Ghidra's empty capability set prevents accidental routing to an -unverified implementation. +The remaining stages add function details, decompilation, assembly, calls, +xrefs, and CFG individually and verify each real semantic claim across the +shared source-owned conformance corpus. Ghidra continues to omit GUI and +mutation operations, so unsupported requests cannot route to an unverified +implementation. diff --git a/docs/api/assets/hierarchy.js b/docs/api/assets/hierarchy.js index 1c209cdc8..adb732fe1 100644 --- a/docs/api/assets/hierarchy.js +++ b/docs/api/assets/hierarchy.js @@ -1 +1 @@ -window.hierarchyData = "eJylmd9vozgQx/8Xnr0cP2yD89aNeruVVteo3VUfTlHkgJtaJZgzpFW02v/9ZEhaE5ti6EtaEN+ZD+Px2B5+e1KIpvYW/0KIIhClJIzVL45ABGGcgBinKAUwDtV9SOIIhAGOEhChOApAiDAO1sCT7LFgWcNFWXuL356ypf6WdM+8hXdV0uJY8/paSiE94D3zMvcWYZQC7yALb+FlBa1rVv+Viz3l5Yap52q/J/Ofmn3hge5Rb+E1df5F2fnS3QBe9sSLXLKyfRUMAYQJBhCmKYCQEABRGAGIIgwgitUPDgBE6hFEQgBxAAHEUQoghgGAGEUAYowAxEkKYIIggAnGACaJ+k/ZSwIC13+Ap5xp7/pdVBWTE99UE016T5wSAHFHkwCYRAGASawIIerYEmwZh5UUjchEMXM8evIR3hYiTS0QN2V1aGYSvGtd3BNicX97aOb718QOACi0TYYlreiWF7w5/irpC+UF3RZsJs+wLRe8yJYjS1pmrChYPhtJ17tgxDaMn3zPxOxx0tUuCDjQEFZSvPCcyXt2Km0TIex6F4zepD2bucpp1UyuLDa1CwIJNYSvUrzWTN5uayZf6IxQDBhwAMGBXlyvZMMfadbcVkzO4bDrXTAivYRdq5CWGbspG7aTvDlOxLDrXTBgYMH4wfd86gwxtS7ue6v62cTffHLdMqQuzjHSnN+UL6xu+K4dxQchn+uKZlMxPjDiApToOfGrfC7Fa3nHdrxu5NSMsKldEFJibD3mVUxT6+KemO7nrhs2tQNCEiQGwsztjUXsAhAFBsAd24tmajIaUhfnsbn1XEmRsXrqXtvUuriHyHB/31A5L/nelS6ukf7mS1E+8t1h1ppgal3cY32J/kd85SWVx9uKTfVuSF2cJ/q7d/qfVO7Y1LgbUhfnvTm/YnLP65qL8o79d+By8rQfMDAO0p5CrST3majYG0GE8JmAlw2TjzR7h6jeRCtR8OzoX1gZxHgz1T+QhQGOkTogd8ev9nIwWqxuPk15suPA2eFAO843ScvPw7RWHFFU30BDeWBbtRiXjZDHO1aLg1S7o+rgCPWqyf1BW5NHE+EkXne0SazR3jfqfPXAtmfzMygNG26BU02ZoLc15/mO/aCHMnsaoXhqq+xGVzDp65fuCMkAApOfhmDDk39gnCIIUbjuyFBorEhXVVXwrC3vBqSlPtkJB02NV6oIotTcI5wPZg4ofYF/cengn0R69n574rmkTimzax/d6Aomff3SNWVIHA0gjKbMOMSclCEw7VKGwNQg+85oXrC6dsmXj/Au7TgNVmJGyiVZehxv2XFxOe5ftXUt3YfTztApa6ru2c2F1rfamjHZ4wC0Od2OH4K9NW2ZV6dmg0vMtt2jG1PlW26NBy8hIenDXKvejxTlRJpLmW+7N86juvm23ue5/bEScmyFpe8lb6M1gDsCq8HJI5qSkIAYxgFZn6BtDdtlwdnoJsWJtrPkWLnUpxB7C70/np/gGR3QgcDBICYxiEgQJG3g1D8foC5pmfOcNmO7lUnMb0ZnVOBEfWNCaaDg4xDFxDjV3LN2Y/nRpNFpeyK/fzU6WdoEHCKYOFEMrW/emRivNkBtpNQHuQ+bs1NhrQYsPdtZk1vV5/ZTlErW3pF9X4maN8ylMuq4htA374wfY9X3TL2Xeaqt86M4YMEfuj81jmppWXcdLwL7C7RaTJe0ag5yvOekI1ukvu3eSDT//Pkf4OlXYw==" \ No newline at end of file +window.hierarchyData = "eJylmdtupDgQht+Faw/LwQfIXaaVnYk02rSSGeViFbUccDpWaJs1dKJoNO++MqQ7pm2CITdJg/irPsrlsl38DpSUbROc/QshSkCS5RiBJI9iCBIIUwJSnMcRgGms78McERBHOCEgQSlJQIwwju5AoNhDxYqWS9EEZ78DbUv/F3THgrPgXNDqteHNhVJSBSB44qIMzuIkA8FeVcFZUFS0aVjzVyl3lIsN08814UAWPra7KgD9o8FZ0DblF23nS38DBMUjr0rFRPcqGAIICQYQZhmAMM8BRHECIEowgCjVf3AEINKPoDwGEEcQQJxkAGIYAYhRAiDGCEBMMgAJggASjAEkRP/S9kgM8d0fEGhnxrt+l3XN1Mw3NUSz3hNnOYC4o4kIgCSJACSpJoSoZyPYMQ5rJVtZyGrheAzkE7wdRJY5IC5FvW8XErxrfdznucP91b5d7t8QewCg2DUZVrSm97zi7esvQZ8pr+h9xRbyjNvywUtcObKiomBVxcrFSKbeByN1YfzkOyYXj5Op9kHAkYGwVvKZl0zdsLfSNhPCrffBGEzag5nzktbt7MriUvsg5LGB8FXJl4apq/uGqWe6IBQjBjxAcGQW13PV8gdatFc1U0s43HofjMQsYRc6pKJgl6JlW8Xb15kYbr0PBowcGD/4js+dIbbWx/1gVT+Y+JvPrluW1Mc5RobzS/HMmpZvu1G8leqpqWkxF+MDIz5AxMyJX+JJyBdxzba8adXcjHCpfRCy3Np6LKuYttbHfW67X7puuNQeCCQiFsLC7Y1D7AOQRBbANdvJdm4yWlIf56m99VwrWbBm7l7b1vq4h8hyf9NStSz53pU+rpH55ispHvh2v2hNsLU+7rG5RP8jv3JB1etVzeZ6t6Q+zon57r3+J1VbNjfultTH+WDOr5na8abhUlyz//ZczZ72IwamQbpTqJPkppA1OxIkCB8IuGiZeqDFO0R9FK1lxYvX8MTKKMbR1PBAFkc4RfqA3B+/usvRaLGm/TTlmx0Pzh4HunG+KSo+D9NZ8UTRfQMD5Zbd68VYtFK9XrNG7pXeHdV7T6gXQx6O2po9mgiT9K6nJalBe9Pq89Utuz+YX0Bp2fALnG7KRIOtOS+37Afdi+JxguKxq7IbU8FUaF76I5ARBKY+DcHGJ//IOCUQoviuJ0OxtSKd13XFi668W5CO+uQmHDU1XakSiDJ7j3A4mHmgDAXhyaWH/xyaO9Vvj7xU1Ctltt2jG1PBVGhe+qZMjsgIwmTKTEMsSZm8n9rdD4vsO6NlxZrGJ18+wju14zFYKIpii8cnWQYcx+w4ufTwn5LE0X142xl6ZU3dP7s50YZOWwsmexqBLqe78UMwNzNrVdZvzQafmN33j25sVei4NR08kpN4CHOhez9Kipk0p7LQdW+aR3fzXb3PQ/tjLdXUCkvfS97GaAD3BE6Ds0c0y0kMUpjivohnwyAeG4oVZ5ObFC/a3pJn5dKfQtwt9OF4foJnckBHAgcjCLuPNSi/61GRq9N9ML+iouQlbad2K7OYj0Znj7oudKBbGzV8Gp+0HLujyQ3rNpYfTRqTdiAKh1eTk6VLwDGCmRPF0ob2nZnx6gLURUp/kPuwOTsX1mnA0bNdNLl1fe4+RelkHRzZd7VseMt8KqOJawlD+870MVZ/zzR7mW+1dXkURyyEY/fnxlEvLV0c9XfH4QKtF9MVrdu9mu45mcgOaei6NxHNP3/+B3jTV10=" \ No newline at end of file diff --git a/docs/api/assets/navigation.js b/docs/api/assets/navigation.js index 78d5a7613..e2e251c55 100644 --- a/docs/api/assets/navigation.js +++ b/docs/api/assets/navigation.js @@ -1 +1 @@ -window.navigationData = "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" \ No newline at end of file +window.navigationData = "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" \ No newline at end of file diff --git a/docs/api/assets/search.js b/docs/api/assets/search.js index 9cadacb87..5714a118f 100644 --- a/docs/api/assets/search.js +++ b/docs/api/assets/search.js @@ -1 +1 @@ -window.searchData = "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"; \ No newline at end of file +window.searchData = "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"; \ No newline at end of file diff --git a/docs/api/classes/application_PermissionAuthority.PermissionPathError.html b/docs/api/classes/application_PermissionAuthority.PermissionPathError.html index 5db7b8951..31fb62945 100644 --- a/docs/api/classes/application_PermissionAuthority.PermissionPathError.html +++ b/docs/api/classes/application_PermissionAuthority.PermissionPathError.html @@ -14,7 +14,7 @@

Failure to establish a filesystem object's canonical authorization identity.

-
+

Hierarchy

  • Error diff --git a/docs/api/classes/application_ProcessCaptureError.ProcessCaptureError.html b/docs/api/classes/application_ProcessCaptureError.ProcessCaptureError.html index 3c7b3c476..9957091cb 100644 --- a/docs/api/classes/application_ProcessCaptureError.ProcessCaptureError.html +++ b/docs/api/classes/application_ProcessCaptureError.ProcessCaptureError.html @@ -14,7 +14,7 @@

    Typed application failure produced by controlled process capture.

    -
    +

    Hierarchy (View Summary)

    • AnalysisError diff --git a/docs/api/classes/application_ProjectPermissionStore.ProjectPermissionStoreError.html b/docs/api/classes/application_ProjectPermissionStore.ProjectPermissionStoreError.html index 487720ed4..070f5dc45 100644 --- a/docs/api/classes/application_ProjectPermissionStore.ProjectPermissionStoreError.html +++ b/docs/api/classes/application_ProjectPermissionStore.ProjectPermissionStoreError.html @@ -14,7 +14,7 @@

      Owner-only project policy persistence failure.

      -
      +

      Hierarchy

      • Error diff --git a/docs/api/classes/ghidra_GhidraClient.GhidraClient.html b/docs/api/classes/ghidra_GhidraClient.GhidraClient.html index 7addd17ab..bf3360730 100644 --- a/docs/api/classes/ghidra_GhidraClient.GhidraClient.html +++ b/docs/api/classes/ghidra_GhidraClient.GhidraClient.html @@ -15,7 +15,7 @@

        Owns one authenticated, private, read-only Ghidra headless session.

      +
    • Defined in src/ghidra/GhidraClient.ts:57
    @@ -27,7 +27,8 @@
    -
    close +
    callTool +close diagnostics ping start @@ -47,11 +48,28 @@
  • options: GhidraClientOptions

Returns GhidraClient

+
  • Defined in src/ghidra/GhidraClient.ts:106
    • + +
      +
    • + +
      +

      Execute one admitted inventory operation after the exact session handshake.

      +
      +
      +

      Parameters

      +
        +
      • operation:
            | "address_name"
            | "list_documents"
            | "list_names"
            | "list_procedures"
            | "list_segments"
            | "list_strings"
            | "procedure_address"
            | "resolve_containing_procedure"
            | "search_procedures"
            | "search_strings"
        • +
      • parameters: Readonly<Record<string, JsonValue>>
        • +
      • options: GhidraRequestOptions = {}
      +

      Returns Promise<Result<JSONType, GhidraSessionError>>

    +
    +
  • Defined in src/ghidra/GhidraClient.ts:165
    • +
  • Defined in src/ghidra/GhidraClient.ts:176
    • - +

      Revalidate live bridge, provider, run, and profile metadata.

      Parameters

        -
      • options: { signal?: AbortSignal; timeoutMs?: number } = {}
      -

      Returns Promise<
          Result<
              {
                  analysis_complete: boolean;
                  analysis_timed_out: boolean;
                  bridge_version: 1;
                  capabilities: ("shutdown" | "ping")[];
                  name: "REA Ghidra bridge";
                  profile_digest: string;
                  provider: { id: "ghidra"; version: string };
                  read_only: true;
                  run_id: string;
                  target: { compiler_spec_id: string; language_id: string; name: string };
              },
              GhidraSessionError,
          >,
      >

    +

    Returns Promise<
        Result<
            {
                analysis_complete: boolean;
                analysis_timed_out: boolean;
                bridge_version: 2;
                capabilities: (
                    | "address_name"
                    | "list_documents"
                    | "list_names"
                    | "list_procedures"
                    | "list_segments"
                    | "list_strings"
                    | "procedure_address"
                    | "resolve_containing_procedure"
                    | "search_procedures"
                    | "search_strings"
                    | "shutdown"
                    | "ping"
                )[];
                name: "REA Ghidra bridge";
                profile_digest: string;
                provider: { id: "ghidra"; version: string };
                read_only: true;
                run_id: string;
                target: {
                    compiler_spec_id: string;
                    default_address_space: string;
                    image_base: string;
                    language_id: string;
                    name: string;
                };
            },
            GhidraSessionError,
        >,
    >

    +
  • Defined in src/ghidra/GhidraClient.ts:143
      • @@ -102,7 +120,7 @@
    • Optionalsignal: AbortSignal

    Returns Promise<GhidraStartResult>

    +
  • Defined in src/ghidra/GhidraClient.ts:116
    • @@ -120,7 +138,7 @@
    Constructors
    Methods -
    +

    Returns GhidraProvider

    +
  • Defined in src/ghidra/GhidraProvider.ts:180
    • @@ -68,7 +69,7 @@

    Returns readonly CapabilityDescriptor[]

    +
  • Defined in src/ghidra/GhidraProvider.ts:192
    • +
  • Defined in src/ghidra/GhidraProvider.ts:266
    • +
  • Defined in src/ghidra/GhidraProvider.ts:188
    • +
  • Defined in src/ghidra/GhidraProvider.ts:196
    • +
  • Defined in src/ghidra/GhidraProvider.ts:215
    • +
  • Defined in src/ghidra/GhidraProvider.ts:254
    • diff --git a/docs/api/classes/ghidra_GhidraResponseRouter.GhidraResponseRouter.html b/docs/api/classes/ghidra_GhidraResponseRouter.GhidraResponseRouter.html index 4d9325c0c..b7e97c336 100644 --- a/docs/api/classes/ghidra_GhidraResponseRouter.GhidraResponseRouter.html +++ b/docs/api/classes/ghidra_GhidraResponseRouter.GhidraResponseRouter.html @@ -15,7 +15,7 @@

    Routes validated response IDs without giving the wire protocol client state.

    +
  • Defined in src/ghidra/GhidraResponseRouter.ts:20
    • @@ -44,7 +44,7 @@
  • options: GhidraResponseRouterOptions

    • Returns GhidraResponseRouter

    +
  • Defined in src/ghidra/GhidraResponseRouter.ts:23
    • @@ -62,7 +62,7 @@
  • line: string

    • Returns void

    +
  • Defined in src/ghidra/GhidraResponseRouter.ts:28
    • diff --git a/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html b/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html index cb62932bf..7c6f357be 100644 --- a/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html +++ b/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html @@ -14,14 +14,14 @@

    Provider-owned failure with bounded, token-redacted local diagnostics.

    -
    +

    Hierarchy

    • Error
      • GhidraSessionError
    +
  • Defined in src/ghidra/GhidraSessionError.ts:20
    • @@ -35,6 +35,7 @@
    diagnostics kind +remoteCode timeoutMs
    @@ -56,7 +57,7 @@

    Returns GhidraSessionError

    +
  • Defined in src/ghidra/GhidraSessionError.ts:25
    • @@ -64,17 +65,22 @@
    diagnostics: Readonly<Record<string, JsonValue>>
    +
  • Defined in src/ghidra/GhidraSessionError.ts:21
    • kind: GhidraSessionFailureKind
    +
  • Defined in src/ghidra/GhidraSessionError.ts:26
    • +
    + +
    remoteCode: string | undefined
    timeoutMs: number | undefined
    +
  • Defined in src/ghidra/GhidraSessionError.ts:22
    • @@ -92,7 +98,7 @@
    Constructors
    Properties -
    +

    Returns Result<AddressedPage, HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:252
    • diff --git a/docs/api/functions/domain_hopperValues.parseDocuments.html b/docs/api/functions/domain_hopperValues.parseDocuments.html index bd9de02ca..b2abe5180 100644 --- a/docs/api/functions/domain_hopperValues.parseDocuments.html +++ b/docs/api/functions/domain_hopperValues.parseDocuments.html @@ -24,7 +24,7 @@
  • value: JSONType

    • Returns Result<readonly string[], HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:333
    • diff --git a/docs/api/functions/domain_hopperValues.parseFunctionDossier.html b/docs/api/functions/domain_hopperValues.parseFunctionDossier.html index 4f6f49785..322c932e5 100644 --- a/docs/api/functions/domain_hopperValues.parseFunctionDossier.html +++ b/docs/api/functions/domain_hopperValues.parseFunctionDossier.html @@ -24,7 +24,7 @@
  • value: JSONType

    • Returns Result<JSONType, AnalysisOutputError>

    +
  • Defined in src/domain/hopperValues.ts:236
    • diff --git a/docs/api/functions/domain_hopperValues.parseListCount.html b/docs/api/functions/domain_hopperValues.parseListCount.html index 745ab4a91..9b7cf8fcd 100644 --- a/docs/api/functions/domain_hopperValues.parseListCount.html +++ b/docs/api/functions/domain_hopperValues.parseListCount.html @@ -25,7 +25,7 @@
  • property: string

    • Returns Result<number, HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:345
    • diff --git a/docs/api/functions/domain_hopperValues.parseNames.html b/docs/api/functions/domain_hopperValues.parseNames.html index dee266d57..ee856418b 100644 --- a/docs/api/functions/domain_hopperValues.parseNames.html +++ b/docs/api/functions/domain_hopperValues.parseNames.html @@ -24,7 +24,7 @@
  • value: JSONType

    • Returns Result<readonly AddressedName[], HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:288
    • diff --git a/docs/api/functions/domain_hopperValues.parseProcedures.html b/docs/api/functions/domain_hopperValues.parseProcedures.html index 277369368..a7553f7bb 100644 --- a/docs/api/functions/domain_hopperValues.parseProcedures.html +++ b/docs/api/functions/domain_hopperValues.parseProcedures.html @@ -24,7 +24,7 @@
  • value: JSONType

    • Returns Result<readonly AddressedName[], HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:269
    • diff --git a/docs/api/functions/domain_hopperValues.parseRelatedAddresses.html b/docs/api/functions/domain_hopperValues.parseRelatedAddresses.html index 8549fd908..b0c9d7eab 100644 --- a/docs/api/functions/domain_hopperValues.parseRelatedAddresses.html +++ b/docs/api/functions/domain_hopperValues.parseRelatedAddresses.html @@ -25,7 +25,7 @@
  • relation: "callers" | "callees"

    • Returns Result<readonly string[], HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:310
    • diff --git a/docs/api/functions/domain_hopperValues.parseSegments.html b/docs/api/functions/domain_hopperValues.parseSegments.html index 72e55ca5a..47ab7dacf 100644 --- a/docs/api/functions/domain_hopperValues.parseSegments.html +++ b/docs/api/functions/domain_hopperValues.parseSegments.html @@ -24,7 +24,7 @@
  • value: JSONType

    • Returns Result<readonly SegmentSummary[], HopperProtocolError>

    +
  • Defined in src/domain/hopperValues.ts:321
    • diff --git a/docs/api/functions/ghidra_GhidraInventoryValues.isGhidraInventoryOperation.html b/docs/api/functions/ghidra_GhidraInventoryValues.isGhidraInventoryOperation.html new file mode 100644 index 000000000..ca480bcbf --- /dev/null +++ b/docs/api/functions/ghidra_GhidraInventoryValues.isGhidraInventoryOperation.html @@ -0,0 +1,44 @@ +isGhidraInventoryOperation | rea-agents - v1.6.0
    +
    rea-agents - v1.6.0 + +
      +
      +
      Preparing search index...
      +
      +
      +
      + +

      Function isGhidraInventoryOperation

      +
      +
        +
      • + +
        +

        Narrow an application operation to the Ghidra inventory surface.

        +
        +
        +

        Parameters

        +
          +
        • operation: string
        +

        Returns operation is
            | "address_name"
            | "list_documents"
            | "list_names"
            | "list_procedures"
            | "list_segments"
            | "list_strings"
            | "procedure_address"
            | "resolve_containing_procedure"
            | "search_procedures"
            | "search_strings"

      +
      +
      +
      +
      +

      Settings

       +
      +
      Member Visibility +
        +
        • +
      +
      +
      +
      +
      diff --git a/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html new file mode 100644 index 000000000..aea7bd2d9 --- /dev/null +++ b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html @@ -0,0 +1,45 @@ +parseGhidraInventoryInput | rea-agents - v1.6.0
      +
      rea-agents - v1.6.0 + +
        +
        +
        Preparing search index...
        +
        +
        +
        + +

        Function parseGhidraInventoryInput

        +
        +
          +
        • + +
          +

          Validate and default one provider request before it crosses the socket.

          +
          +
          +

          Parameters

          +
            +
          • operation:
                | "address_name"
                | "list_documents"
                | "list_names"
                | "list_procedures"
                | "list_segments"
                | "list_strings"
                | "procedure_address"
                | "resolve_containing_procedure"
                | "search_procedures"
                | "search_strings"
            • +
          • value: Readonly<Record<string, JsonValue>>
          +

          Returns Result<Readonly<Record<string, JSONType>>, AnalysisInputError>

        +
        +
        +
        +
        +

        Settings

         +
        +
        Member Visibility +
          +
          • +
        +
        +
        +
        +
        diff --git a/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html new file mode 100644 index 000000000..f3edfc9f4 --- /dev/null +++ b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html @@ -0,0 +1,45 @@ +parseGhidraInventoryResult | rea-agents - v1.6.0
        +
        rea-agents - v1.6.0 + +
          +
          +
          Preparing search index...
          +
          +
          +
          + +

          Function parseGhidraInventoryResult

          +
          +
            +
          • + +
            +

            Require exact, bounded Java-bridge output before creating Evidence.

            +
            +
            +

            Parameters

            +
              +
            • operation:
                  | "address_name"
                  | "list_documents"
                  | "list_names"
                  | "list_procedures"
                  | "list_segments"
                  | "list_strings"
                  | "procedure_address"
                  | "resolve_containing_procedure"
                  | "search_procedures"
                  | "search_strings"
              • +
            • value: JSONType
            +

            Returns Result<JSONType, AnalysisOutputError>

          +
          +
          +
          +
          +

          Settings

           +
          +
          Member Visibility +
            +
            • +
          +
          +
          +
          +
          diff --git a/docs/api/functions/ghidra_GhidraSessionError.bindGhidraSessionFailure.html b/docs/api/functions/ghidra_GhidraSessionError.bindGhidraSessionFailure.html new file mode 100644 index 000000000..22c6c5cb8 --- /dev/null +++ b/docs/api/functions/ghidra_GhidraSessionError.bindGhidraSessionFailure.html @@ -0,0 +1,44 @@ +bindGhidraSessionFailure | rea-agents - v1.6.0
          +
          rea-agents - v1.6.0 + +
            +
            +
            Preparing search index...
            +
            +
            +
            + +

            Function bindGhidraSessionFailure

            +
            +
            +
            +
            +
            +
            +

            Settings

             +
            +
            Member Visibility +
              +
              • +
            +
            +
            +
            +
            diff --git a/docs/api/functions/ghidra_GhidraSessionValues.isGhidraShutdownAcknowledgement.html b/docs/api/functions/ghidra_GhidraSessionValues.isGhidraShutdownAcknowledgement.html index 44e3b5b21..e92ed95ef 100644 --- a/docs/api/functions/ghidra_GhidraSessionValues.isGhidraShutdownAcknowledgement.html +++ b/docs/api/functions/ghidra_GhidraSessionValues.isGhidraShutdownAcknowledgement.html @@ -24,7 +24,7 @@
          • value: JSONType

            • Returns boolean

            +
          • Defined in src/ghidra/GhidraSessionValues.ts:77
            • diff --git a/docs/api/functions/ghidra_GhidraSessionValues.parseGhidraSessionInfo.html b/docs/api/functions/ghidra_GhidraSessionValues.parseGhidraSessionInfo.html index fbd760434..6f3664d2e 100644 --- a/docs/api/functions/ghidra_GhidraSessionValues.parseGhidraSessionInfo.html +++ b/docs/api/functions/ghidra_GhidraSessionValues.parseGhidraSessionInfo.html @@ -14,7 +14,7 @@
            • - +

              Require exact run, provider, and profile identity from the Java bridge.

              @@ -23,9 +23,9 @@
              • value: JSONType
              • expected: { profileDigest: string; providerVersion: string; runId: string }
              -

              Returns Result<
                  {
                      analysis_complete: boolean;
                      analysis_timed_out: boolean;
                      bridge_version: 1;
                      capabilities: ("shutdown" | "ping")[];
                      name: "REA Ghidra bridge";
                      profile_digest: string;
                      provider: { id: "ghidra"; version: string };
                      read_only: true;
                      run_id: string;
                      target: { compiler_spec_id: string; language_id: string; name: string };
                  },
                  Error,
              >

            +
          • Defined in src/ghidra/GhidraSessionValues.ts:51
            • diff --git a/docs/api/functions/ghidra_protocol.ghidraResponseResult.html b/docs/api/functions/ghidra_protocol.ghidraResponseResult.html index 96c60aeea..9d805812f 100644 --- a/docs/api/functions/ghidra_protocol.ghidraResponseResult.html +++ b/docs/api/functions/ghidra_protocol.ghidraResponseResult.html @@ -14,7 +14,7 @@
            • - +

              Project one validated response into its result or remote failure.

              @@ -22,9 +22,9 @@

              Parameters

              • response: {
                    error?: { code: string; message: string };
                    id: number;
                    ok: boolean;
                    result?: JSONType;
                }
              -

              Returns Result<JSONType, Error>

            +
          • Defined in src/ghidra/protocol.ts:79
            • diff --git a/docs/api/functions/ghidra_protocol.parseGhidraResponseLine.html b/docs/api/functions/ghidra_protocol.parseGhidraResponseLine.html index a14010a09..c7162410c 100644 --- a/docs/api/functions/ghidra_protocol.parseGhidraResponseLine.html +++ b/docs/api/functions/ghidra_protocol.parseGhidraResponseLine.html @@ -24,7 +24,7 @@
          • line: string

            • Returns Result<
                {
                    error?: { code: string; message: string };
                    id: number;
                    ok: boolean;
                    result?: JSONType;
                },
                Error,
            >

            +
          • Defined in src/ghidra/protocol.ts:62
            • diff --git a/docs/api/hierarchy.html b/docs/api/hierarchy.html index 744a3e58a..fa77899ca 100644 --- a/docs/api/hierarchy.html +++ b/docs/api/hierarchy.html @@ -39,48 +39,48 @@
          • NoBinaryOpenError
          • BinaryTargetError
          • PermissionRequiredError
            • -
          • ProcessCaptureError
            • +
          • ProcessCaptureError
            • +
          • BinarySession
            • +
          • CdpBrowserProvider
            • +
          • CdpElectronProvider
            • +
          • GhidraHeadlessLauncher
            • +
          • GhidraLaunch
            • +
            application/AbortablePromise
            application/AnalysisProvider
            application/AnalysisProviderEvaluation
            application/AnalysisProviderRegistry
            application/AnalysisSnapshotCache
            application/AnalysisSnapshotFiles
            application/ArtifactExtraction
            application/ArtifactGraphConstruction
            application/ArtifactInventory
            application/AuthorizedArtifactInventory
            application/BinarySession
            application/BinarySessionPort
            application/BoundedJsonFiles
            application/BrowserEvidence
            application/BrowserObservationPort
            application/BrowserObservationService
            application/CapabilityInventory
            application/ClientConfigPath
            application/ClientRegistrationStatus
            application/CommandShimReplay
            application/CompositeProvider
            application/ConfiguredRoots
            application/CrossVersionInventory
            application/CrossVersionInvestigation
            application/CrossVersionInvestigationEvidence
            application/CrossVersionInvestigationReplay
            application/DeferredFileAuthorization
            application/DirectAnalysis
            application/Doctor
            application/ElectronEvidence
            application/ElectronObservationPort
            application/ElectronObservationService
            application/EnhancedTools
            application/EvidenceBundleCommands
            application/EvidenceBundleFiles
            application/EvidenceLedger
            application/FilesystemSnapshot
            application/homebrew
            application/InvestigationProviders
            application/InvestigationWorkspaceStore
            application/LinuxHopper
            application/LoopbackReplay
            application/MacHopper
            application/PermissionAuthority
            application/PermissionConfiguration
            application/ProcessCaptureAuthority
            application/ProcessCaptureCapability
            application/ProcessCaptureError
            application/ProcessCaptureLifecycle
            application/ProcessCheckpoints
            application/ProcessCli
            application/ProcessEvidence
            application/ProcessHarness
            application/ProcessNormalization
            application/ProcessSampling
            application/ProgressReporter
            application/ProjectPermissionStore
            application/RealHopperAssertions
            application/ReferenceSourceImport
            application/ReferenceSourceImportEntries
            application/ReferenceSourceImportPolicy
            application/ReferenceSourceImportTypes
            application/ReferenceSourceVcsAdapter
            application/runtime
            application/SessionProviderRouter
            application/Setup
            application/SetupClients
            application/SetupInstallFailure
            application/SetupPlan
            application/SetupSkill
            application/SupportedClients
            application/TerminalRenderer
            application/Uninstall
            application/UnknownEvidence
            application/Upgrade
            browser/CdpBrowserProvider
            browser/CdpCaptureCompleteness
            browser/CdpCaptureDocuments
            browser/CdpCaptureEvents
            browser/CdpCaptureStorage
            browser/CdpCaptureValues
            browser/CdpConnection
            browser/CdpElectronInspection
            browser/CdpElectronProvider
            browser/CdpEndpoint
            browser/CdpObservationSession
            browser/CdpOptionalCommand
            browser/CdpPageCapture
            browser/CdpSafeMetadata
            browser/CdpScreenshot
            browser/CdpTargetSession
            browser/CdpWebMcpDiscovery
            browser/ElectronFileScope
            browser/PngVisualDiff
            browser/SensitiveTextCapture
            browser/WebSourceMapFetcher
            cli
            config
            contracts/artifactComparisonExample
            contracts/artifactToolContracts
            contracts/browserToolContracts
            contracts/electronToolContracts
            contracts/enhancedInputs
            contracts/errorSchemas
            contracts/functionComparisonExample
            contracts/investigationExamples
            contracts/nativeToolContracts
            contracts/processCaptureExample
            contracts/promptContracts
            contracts/providerSelection
            contracts/sessionLifecycleInputs
            contracts/toolContractExamples
            contracts/toolContracts
            contracts/toolContractTypes
            contracts/toolOutputSchemas
            contracts/unknownContractExamples
            domain/analysisProfile
            domain/analysisSnapshot
            domain/artifactComparison
            domain/artifactGraph
            domain/artifactInventoryEvidence
            domain/binaryTarget
            domain/browserCompleteness
            domain/browserObservation
            domain/browserSession
            domain/bundleComparison
            domain/callPath
            domain/changedBehavior
            domain/electronObservation
            domain/errors
            domain/evidence
            domain/evidenceBundle
            domain/functionComparison
            domain/functionComparisonNormalization
            domain/functionComparisonResults
            domain/functionComparisonSchemas
            domain/functionDossierEvidence
            domain/hopperStartupFailure
            domain/hopperValues
            domain/investigationWorkspace
            domain/jsonLimits
            domain/jsonShape
            domain/jsonValue
            domain/nativeInspection
            domain/permissionPolicy
            domain/processCapture
            domain/processCaptureValidation
            domain/processComparison
            domain/processScenario
            domain/reconstructionUnknowns
            domain/reconstructionVerification
            domain/reconstructionVerificationSchemas
            domain/referenceSourceClassification
            domain/referenceSourceGraph
            domain/referenceSourceImportParsing
            domain/referenceSourcePolicy
            domain/residualUnknown
            domain/result
            domain/runtimeVersion
            domain/staticRuntimeCorrelation
            domain/symbolAnalysis
            domain/webBundleAnalysis
            domain/webBundleAnalyzer
            domain/webCaptureDiff
            domain/webContentArtifact
            domain/webInventory
            domain/webMcpDiscovery
            domain/webScreenshot
            ghidra/GhidraAnalysisProfile
            ghidra/GhidraClient
            ghidra/GhidraClientTypes
            ghidra/GhidraDefaults
            ghidra/GhidraDiagnostics
            ghidra/GhidraDoctor
            ghidra/GhidraInstallation
            ghidra/GhidraInventoryValues
            ghidra/GhidraLauncher
            ghidra/GhidraProvider
            ghidra/GhidraResponseBuffer
            ghidra/GhidraResponseRouter
            ghidra/GhidraSessionError
            ghidra/GhidraSessionValues
            ghidra/GhidraSocketConnection
            ghidra/protocol
            hopper/BridgeLauncher
            hopper/HopperAnalysisProfile
            hopper/HopperClient
            hopper/HopperProvider
            hopper/HopperSessionValues
            hopper/HopperSocketConnection
            hopper/protocol
            main
            process/PendingOperations
            process/PrivateRuntimeRoot
            process/ProcessOwnership
            process/ProviderDeadline
            process/ProviderProcess
            server/createServer
            server/mcpProgress
            server/promptCompletion
            server/recordDerivedEvidence
            server/registerArtifactComparisonTool
            server/registerArtifactTools
            server/registerBrowserTools
            server/registerBundleComparisonTool
            server/registerElectronTools
            server/registerEnhancedTools
            server/registerEvidenceResources
            server/registerEvidenceTools
            server/registerFunctionComparisonTool
            server/registerInvestigationTools
            server/registerNativeTools
            server/registerOfficialTools
            server/registerProcessComparisonTool
            server/registerPrompts
            server/registerSessionStatusTool
            server/registerSessionTools
            server/runDerivedOperation
            server/sessionEvidence
            server/sessionToolPolicies
            server/toolLogging
            server/toolRegistrationOptions
            server/toolResult
            @@ -25,7 +25,7 @@

            On This Page

            Modules -
            application/AbortablePromiseapplication/AnalysisProviderapplication/AnalysisProviderEvaluationapplication/AnalysisProviderRegistryapplication/AnalysisSnapshotCacheapplication/AnalysisSnapshotFilesapplication/ArtifactExtractionapplication/ArtifactGraphConstructionapplication/ArtifactInventoryapplication/AuthorizedArtifactInventoryapplication/BinarySessionapplication/BinarySessionPortapplication/BoundedJsonFilesapplication/BrowserEvidenceapplication/BrowserObservationPortapplication/BrowserObservationServiceapplication/CapabilityInventoryapplication/ClientConfigPathapplication/ClientRegistrationStatusapplication/CommandShimReplayapplication/CompositeProviderapplication/ConfiguredRootsapplication/CrossVersionInventoryapplication/CrossVersionInvestigationapplication/CrossVersionInvestigationEvidenceapplication/CrossVersionInvestigationReplayapplication/DeferredFileAuthorizationapplication/DirectAnalysisapplication/Doctorapplication/ElectronEvidenceapplication/ElectronObservationPortapplication/ElectronObservationServiceapplication/EnhancedToolsapplication/EvidenceBundleCommandsapplication/EvidenceBundleFilesapplication/EvidenceLedgerapplication/FilesystemSnapshotapplication/homebrewapplication/InvestigationProvidersapplication/InvestigationWorkspaceStoreapplication/LinuxHopperapplication/LoopbackReplayapplication/MacHopperapplication/PermissionAuthorityapplication/PermissionConfigurationapplication/ProcessCaptureAuthorityapplication/ProcessCaptureCapabilityapplication/ProcessCaptureErrorapplication/ProcessCaptureLifecycleapplication/ProcessCheckpointsapplication/ProcessCliapplication/ProcessEvidenceapplication/ProcessHarnessapplication/ProcessNormalizationapplication/ProcessSamplingapplication/ProgressReporterapplication/ProjectPermissionStoreapplication/RealHopperAssertionsapplication/ReferenceSourceImportapplication/ReferenceSourceImportEntriesapplication/ReferenceSourceImportPolicyapplication/ReferenceSourceImportTypesapplication/ReferenceSourceVcsAdapterapplication/runtimeapplication/SessionProviderRouterapplication/Setupapplication/SetupClientsapplication/SetupInstallFailureapplication/SetupPlanapplication/SetupSkillapplication/SupportedClientsapplication/TerminalRendererapplication/Uninstallapplication/UnknownEvidenceapplication/Upgradebrowser/CdpBrowserProviderbrowser/CdpCaptureCompletenessbrowser/CdpCaptureDocumentsbrowser/CdpCaptureEventsbrowser/CdpCaptureStoragebrowser/CdpCaptureValuesbrowser/CdpConnectionbrowser/CdpElectronInspectionbrowser/CdpElectronProviderbrowser/CdpEndpointbrowser/CdpObservationSessionbrowser/CdpOptionalCommandbrowser/CdpPageCapturebrowser/CdpSafeMetadatabrowser/CdpScreenshotbrowser/CdpTargetSessionbrowser/CdpWebMcpDiscoverybrowser/ElectronFileScopebrowser/PngVisualDiffbrowser/SensitiveTextCapturebrowser/WebSourceMapFetchercliconfigcontracts/artifactComparisonExamplecontracts/artifactToolContractscontracts/browserToolContractscontracts/electronToolContractscontracts/enhancedInputscontracts/errorSchemascontracts/functionComparisonExamplecontracts/investigationExamplescontracts/nativeToolContractscontracts/processCaptureExamplecontracts/promptContractscontracts/providerSelectioncontracts/sessionLifecycleInputscontracts/toolContractExamplescontracts/toolContractscontracts/toolContractTypescontracts/toolOutputSchemascontracts/unknownContractExamplesdomain/analysisProfiledomain/analysisSnapshotdomain/artifactComparisondomain/artifactGraphdomain/artifactInventoryEvidencedomain/binaryTargetdomain/browserCompletenessdomain/browserObservationdomain/browserSessiondomain/bundleComparisondomain/callPathdomain/changedBehaviordomain/electronObservationdomain/errorsdomain/evidencedomain/evidenceBundledomain/functionComparisondomain/functionComparisonNormalizationdomain/functionComparisonResultsdomain/functionComparisonSchemasdomain/functionDossierEvidencedomain/hopperStartupFailuredomain/hopperValuesdomain/investigationWorkspacedomain/jsonLimitsdomain/jsonShapedomain/jsonValuedomain/nativeInspectiondomain/permissionPolicydomain/processCapturedomain/processCaptureValidationdomain/processComparisondomain/processScenariodomain/reconstructionUnknownsdomain/reconstructionVerificationdomain/reconstructionVerificationSchemasdomain/referenceSourceClassificationdomain/referenceSourceGraphdomain/referenceSourceImportParsingdomain/referenceSourcePolicydomain/residualUnknowndomain/resultdomain/runtimeVersiondomain/staticRuntimeCorrelationdomain/symbolAnalysisdomain/webBundleAnalysisdomain/webBundleAnalyzerdomain/webCaptureDiffdomain/webContentArtifactdomain/webInventorydomain/webMcpDiscoverydomain/webScreenshotghidra/GhidraAnalysisProfileghidra/GhidraClientghidra/GhidraClientTypesghidra/GhidraDefaultsghidra/GhidraDiagnosticsghidra/GhidraDoctorghidra/GhidraInstallationghidra/GhidraLauncherghidra/GhidraProviderghidra/GhidraResponseBufferghidra/GhidraResponseRouterghidra/GhidraSessionErrorghidra/GhidraSessionValuesghidra/GhidraSocketConnectionghidra/protocolhopper/BridgeLauncherhopper/HopperAnalysisProfilehopper/HopperClienthopper/HopperProviderhopper/HopperSessionValueshopper/HopperSocketConnectionhopper/protocolmainprocess/PendingOperationsprocess/PrivateRuntimeRootprocess/ProcessOwnershipprocess/ProviderDeadlineprocess/ProviderProcessserver/createServerserver/mcpProgressserver/promptCompletionserver/recordDerivedEvidenceserver/registerArtifactComparisonToolserver/registerArtifactToolsserver/registerBrowserToolsserver/registerBundleComparisonToolserver/registerElectronToolsserver/registerEnhancedToolsserver/registerEvidenceResourcesserver/registerEvidenceToolsserver/registerFunctionComparisonToolserver/registerInvestigationToolsserver/registerNativeToolsserver/registerOfficialToolsserver/registerProcessComparisonToolserver/registerPromptsserver/registerSessionStatusToolserver/registerSessionToolsserver/runDerivedOperationserver/sessionEvidenceserver/sessionToolPoliciesserver/toolLoggingserver/toolRegistrationOptionsserver/toolResult
            +
            application/AbortablePromiseapplication/AnalysisProviderapplication/AnalysisProviderEvaluationapplication/AnalysisProviderRegistryapplication/AnalysisSnapshotCacheapplication/AnalysisSnapshotFilesapplication/ArtifactExtractionapplication/ArtifactGraphConstructionapplication/ArtifactInventoryapplication/AuthorizedArtifactInventoryapplication/BinarySessionapplication/BinarySessionPortapplication/BoundedJsonFilesapplication/BrowserEvidenceapplication/BrowserObservationPortapplication/BrowserObservationServiceapplication/CapabilityInventoryapplication/ClientConfigPathapplication/ClientRegistrationStatusapplication/CommandShimReplayapplication/CompositeProviderapplication/ConfiguredRootsapplication/CrossVersionInventoryapplication/CrossVersionInvestigationapplication/CrossVersionInvestigationEvidenceapplication/CrossVersionInvestigationReplayapplication/DeferredFileAuthorizationapplication/DirectAnalysisapplication/Doctorapplication/ElectronEvidenceapplication/ElectronObservationPortapplication/ElectronObservationServiceapplication/EnhancedToolsapplication/EvidenceBundleCommandsapplication/EvidenceBundleFilesapplication/EvidenceLedgerapplication/FilesystemSnapshotapplication/homebrewapplication/InvestigationProvidersapplication/InvestigationWorkspaceStoreapplication/LinuxHopperapplication/LoopbackReplayapplication/MacHopperapplication/PermissionAuthorityapplication/PermissionConfigurationapplication/ProcessCaptureAuthorityapplication/ProcessCaptureCapabilityapplication/ProcessCaptureErrorapplication/ProcessCaptureLifecycleapplication/ProcessCheckpointsapplication/ProcessCliapplication/ProcessEvidenceapplication/ProcessHarnessapplication/ProcessNormalizationapplication/ProcessSamplingapplication/ProgressReporterapplication/ProjectPermissionStoreapplication/RealHopperAssertionsapplication/ReferenceSourceImportapplication/ReferenceSourceImportEntriesapplication/ReferenceSourceImportPolicyapplication/ReferenceSourceImportTypesapplication/ReferenceSourceVcsAdapterapplication/runtimeapplication/SessionProviderRouterapplication/Setupapplication/SetupClientsapplication/SetupInstallFailureapplication/SetupPlanapplication/SetupSkillapplication/SupportedClientsapplication/TerminalRendererapplication/Uninstallapplication/UnknownEvidenceapplication/Upgradebrowser/CdpBrowserProviderbrowser/CdpCaptureCompletenessbrowser/CdpCaptureDocumentsbrowser/CdpCaptureEventsbrowser/CdpCaptureStoragebrowser/CdpCaptureValuesbrowser/CdpConnectionbrowser/CdpElectronInspectionbrowser/CdpElectronProviderbrowser/CdpEndpointbrowser/CdpObservationSessionbrowser/CdpOptionalCommandbrowser/CdpPageCapturebrowser/CdpSafeMetadatabrowser/CdpScreenshotbrowser/CdpTargetSessionbrowser/CdpWebMcpDiscoverybrowser/ElectronFileScopebrowser/PngVisualDiffbrowser/SensitiveTextCapturebrowser/WebSourceMapFetchercliconfigcontracts/artifactComparisonExamplecontracts/artifactToolContractscontracts/browserToolContractscontracts/electronToolContractscontracts/enhancedInputscontracts/errorSchemascontracts/functionComparisonExamplecontracts/investigationExamplescontracts/nativeToolContractscontracts/processCaptureExamplecontracts/promptContractscontracts/providerSelectioncontracts/sessionLifecycleInputscontracts/toolContractExamplescontracts/toolContractscontracts/toolContractTypescontracts/toolOutputSchemascontracts/unknownContractExamplesdomain/analysisProfiledomain/analysisSnapshotdomain/artifactComparisondomain/artifactGraphdomain/artifactInventoryEvidencedomain/binaryTargetdomain/browserCompletenessdomain/browserObservationdomain/browserSessiondomain/bundleComparisondomain/callPathdomain/changedBehaviordomain/electronObservationdomain/errorsdomain/evidencedomain/evidenceBundledomain/functionComparisondomain/functionComparisonNormalizationdomain/functionComparisonResultsdomain/functionComparisonSchemasdomain/functionDossierEvidencedomain/hopperStartupFailuredomain/hopperValuesdomain/investigationWorkspacedomain/jsonLimitsdomain/jsonShapedomain/jsonValuedomain/nativeInspectiondomain/permissionPolicydomain/processCapturedomain/processCaptureValidationdomain/processComparisondomain/processScenariodomain/reconstructionUnknownsdomain/reconstructionVerificationdomain/reconstructionVerificationSchemasdomain/referenceSourceClassificationdomain/referenceSourceGraphdomain/referenceSourceImportParsingdomain/referenceSourcePolicydomain/residualUnknowndomain/resultdomain/runtimeVersiondomain/staticRuntimeCorrelationdomain/symbolAnalysisdomain/webBundleAnalysisdomain/webBundleAnalyzerdomain/webCaptureDiffdomain/webContentArtifactdomain/webInventorydomain/webMcpDiscoverydomain/webScreenshotghidra/GhidraAnalysisProfileghidra/GhidraClientghidra/GhidraClientTypesghidra/GhidraDefaultsghidra/GhidraDiagnosticsghidra/GhidraDoctorghidra/GhidraInstallationghidra/GhidraInventoryValuesghidra/GhidraLauncherghidra/GhidraProviderghidra/GhidraResponseBufferghidra/GhidraResponseRouterghidra/GhidraSessionErrorghidra/GhidraSessionValuesghidra/GhidraSocketConnectionghidra/protocolhopper/BridgeLauncherhopper/HopperAnalysisProfilehopper/HopperClienthopper/HopperProviderhopper/HopperSessionValueshopper/HopperSocketConnectionhopper/protocolmainprocess/PendingOperationsprocess/PrivateRuntimeRootprocess/ProcessOwnershipprocess/ProviderDeadlineprocess/ProviderProcessserver/createServerserver/mcpProgressserver/promptCompletionserver/recordDerivedEvidenceserver/registerArtifactComparisonToolserver/registerArtifactToolsserver/registerBrowserToolsserver/registerBundleComparisonToolserver/registerElectronToolsserver/registerEnhancedToolsserver/registerEvidenceResourcesserver/registerEvidenceToolsserver/registerFunctionComparisonToolserver/registerInvestigationToolsserver/registerNativeToolsserver/registerOfficialToolsserver/registerProcessComparisonToolserver/registerPromptsserver/registerSessionStatusToolserver/registerSessionToolsserver/runDerivedOperationserver/sessionEvidenceserver/sessionToolPoliciesserver/toolLoggingserver/toolRegistrationOptionsserver/toolResult
            interface GhidraClientOptions {
                launcher: GhidraLauncher;
                logger?: Logger;
                onDiagnostic?: (event: GhidraDiagnostic) => void;
                profileDigest: string;
                providerVersion: string;
                requestTimeoutMs?: number;
                startupTimeoutMs?: number;
                targetPath: string;
            }
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:33
            • @@ -40,42 +40,42 @@
            launcher: GhidraLauncher
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:34
            • logger?: Logger
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:41
            • onDiagnostic?: (event: GhidraDiagnostic) => void
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:40
            • profileDigest: string
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:37
            • providerVersion: string
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:36
            • requestTimeoutMs?: number
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:38
            • startupTimeoutMs?: number
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:39
            • targetPath: string
            +
          • Defined in src/ghidra/GhidraClientTypes.ts:35
            • diff --git a/docs/api/interfaces/ghidra_GhidraClientTypes.GhidraRequestOptions.html b/docs/api/interfaces/ghidra_GhidraClientTypes.GhidraRequestOptions.html new file mode 100644 index 000000000..60c071da2 --- /dev/null +++ b/docs/api/interfaces/ghidra_GhidraClientTypes.GhidraRequestOptions.html @@ -0,0 +1,64 @@ +GhidraRequestOptions | rea-agents - v1.6.0
            +
            rea-agents - v1.6.0 + +
              +
              +
              Preparing search index...
              +
              +
              +
              + +

              Interface GhidraRequestOptions

              +
              +

              Cancellation and deadline controls shared by authenticated requests.

              +
              +
              interface GhidraRequestOptions {
                  signal?: AbortSignal;
                  timeoutMs?: number;
              }
              +
              +
              +
              +
              Index
               +
              +
              + +
              signal? +timeoutMs? +
              +
              + +
              +
              + +
              signal?: AbortSignal
              +
              + +
              timeoutMs?: number
              +
              +
              +
              +
              +

              Settings

               +
              +
              Member Visibility +
                +
                • +
              +
              +
              +

              On This Page

               +
              +
              Properties +
              +
              +
              +
              diff --git a/docs/api/interfaces/ghidra_GhidraLauncher.GhidraLaunch.html b/docs/api/interfaces/ghidra_GhidraLauncher.GhidraLaunch.html index c354ce858..b87590894 100644 --- a/docs/api/interfaces/ghidra_GhidraLauncher.GhidraLaunch.html +++ b/docs/api/interfaces/ghidra_GhidraLauncher.GhidraLaunch.html @@ -15,7 +15,7 @@

              Process plus private log coordinates returned by a Ghidra launcher.

              interface GhidraLaunch {
                  cleanup?: () => Promise<ProcessCleanupResult>;
                  ghidraLogPath: string;
                  ownsProcessLifetime: boolean;
                  process: ChildProcess;
                  projectRoot: string;
                  scriptLogPath: string;
              }
              -
              +

              Hierarchy (View Summary)

              @@ -36,22 +36,22 @@
              nextId: () => number
              +
            • Defined in src/ghidra/GhidraResponseRouter.ts:14
              • pending: PendingOperations<number, Result<JSONType, GhidraSessionError>>
              +
            • Defined in src/ghidra/GhidraResponseRouter.ts:10
              • protocolFailure: (message: string, cause?: Error) => void
              +
            • Defined in src/ghidra/GhidraResponseRouter.ts:16
              • -
              remoteFailure: (message: string, cause: Error) => GhidraSessionError
              +
            • Defined in src/ghidra/GhidraResponseRouter.ts:15
              • diff --git a/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html b/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html index 36fa333a8..5c799802d 100644 --- a/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html +++ b/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html @@ -14,8 +14,8 @@

              Additional structured context for a Ghidra session failure.

              -
              interface GhidraSessionErrorOptions {
                  timeoutMs?: number;
              }
              -
              +
              interface GhidraSessionErrorOptions {
                  remoteCode?: string;
                  timeoutMs?: number;
              }
              +

              Hierarchy

              + +
              remoteCode?: string
              +
              timeoutMs?: number
              +
              +
              GhidraClientOptions → GhidraClientOptions
              GhidraDiagnostic → GhidraDiagnostic
              GhidraRequestOptions → GhidraRequestOptions
              GhidraStartResult → GhidraStartResult
              @@ -31,7 +31,7 @@
              Classes
              References -
              +
              -
              GhidraClientOptions
              +
              GhidraClientOptions
              GhidraRequestOptions
              GhidraDiagnostic
              GhidraStartResult
              @@ -29,7 +29,7 @@

              On This Page

              Interfaces -
              +
              Type Aliases
              diff --git a/docs/api/modules/ghidra_GhidraInventoryValues.html b/docs/api/modules/ghidra_GhidraInventoryValues.html new file mode 100644 index 000000000..16dd57459 --- /dev/null +++ b/docs/api/modules/ghidra_GhidraInventoryValues.html @@ -0,0 +1,44 @@ +ghidra/GhidraInventoryValues | rea-agents - v1.6.0
              +
              rea-agents - v1.6.0 + +
                +
                +
                Preparing search index...
                +
                +
                +
                + +

                Module ghidra/GhidraInventoryValues

                +
                +
                GhidraInventoryOperation
                +
                +
                GHIDRA_INVENTORY_OPERATIONS
                +
                +
                isGhidraInventoryOperation
                parseGhidraInventoryInput
                parseGhidraInventoryResult
                +
                +
                +
                +
                +

                Settings

                 +
                +
                Member Visibility +
                  +
                  • +
                +
                +
                +

                On This Page

                 +
                +
                Type Aliases +
                +
                Variables +
                +
                Functions +
                +
                +
                +
                diff --git a/docs/api/modules/ghidra_GhidraProvider.html b/docs/api/modules/ghidra_GhidraProvider.html index 9f8b96e9c..a2ff89b34 100644 --- a/docs/api/modules/ghidra_GhidraProvider.html +++ b/docs/api/modules/ghidra_GhidraProvider.html @@ -12,6 +12,8 @@

                Module ghidra/GhidraProvider

                GhidraProvider
                +
                +
                GhidraProviderClientFactory
                GHIDRA_PROVIDER_IDENTITY
                GHIDRA_PROVIDER_TOOL_CONTRACTS
                @@ -30,6 +32,8 @@
                Classes
                +
                Type Aliases +
                Variables
                diff --git a/docs/api/modules/ghidra_GhidraSessionError.html b/docs/api/modules/ghidra_GhidraSessionError.html index af094ee95..0c5ec588d 100644 --- a/docs/api/modules/ghidra_GhidraSessionError.html +++ b/docs/api/modules/ghidra_GhidraSessionError.html @@ -15,7 +15,9 @@
                GhidraSessionErrorOptions
                -
                GhidraSessionFailureKind
                +
                GhidraSessionFailureKind
                +
                +
                bindGhidraSessionFailure
                @@ -35,7 +37,9 @@
                Interfaces
                Type Aliases -
                + +
                Functions +
                GhidraSessionInfo
                +
                +
                GHIDRA_SESSION_CAPABILITIES
                isGhidraShutdownAcknowledgement
                parseGhidraSessionInfo
                @@ -30,6 +32,8 @@
                Type Aliases
                +
                Variables +
                Functions
                diff --git a/docs/api/modules/ghidra_protocol.html b/docs/api/modules/ghidra_protocol.html index 26ec6a9ff..838fdc911 100644 --- a/docs/api/modules/ghidra_protocol.html +++ b/docs/api/modules/ghidra_protocol.html @@ -10,6 +10,8 @@

                Module ghidra/protocol

                +
                +
                GhidraRemoteError
                GhidraBridgeResponse
                @@ -28,6 +30,8 @@

                On This Page
                +
                Classes +
                Type Aliases
                Functions diff --git a/docs/api/types/contracts_toolContracts.OfficialToolName.html b/docs/api/types/contracts_toolContracts.OfficialToolName.html index 6ec3bc6dc..9685a883c 100644 --- a/docs/api/types/contracts_toolContracts.OfficialToolName.html +++ b/docs/api/types/contracts_toolContracts.OfficialToolName.html @@ -15,7 +15,7 @@

                Closed provider operation names exposed by direct analysis adapters.

                +
              • Defined in src/contracts/toolContracts.ts:342
                • diff --git a/docs/api/types/domain_hopperValues.FunctionDossier.html b/docs/api/types/domain_hopperValues.FunctionDossier.html index 531ab665e..e1052b343 100644 --- a/docs/api/types/domain_hopperValues.FunctionDossier.html +++ b/docs/api/types/domain_hopperValues.FunctionDossier.html @@ -15,7 +15,7 @@

                Strict analyzed-function dossier shared by provider and comparison boundaries.

                +
              • Defined in src/domain/hopperValues.ts:233
                • diff --git a/docs/api/types/ghidra_GhidraClientTypes.GhidraDiagnostic.html b/docs/api/types/ghidra_GhidraClientTypes.GhidraDiagnostic.html index 7fc13a9e7..69244c884 100644 --- a/docs/api/types/ghidra_GhidraClientTypes.GhidraDiagnostic.html +++ b/docs/api/types/ghidra_GhidraClientTypes.GhidraDiagnostic.html @@ -15,7 +15,7 @@

                Safe lifecycle telemetry for one isolated Ghidra headless process.

                +
              • Defined in src/ghidra/GhidraClientTypes.ts:17
                • diff --git a/docs/api/types/ghidra_GhidraInventoryValues.GhidraInventoryOperation.html b/docs/api/types/ghidra_GhidraInventoryValues.GhidraInventoryOperation.html new file mode 100644 index 000000000..bd5102d11 --- /dev/null +++ b/docs/api/types/ghidra_GhidraInventoryValues.GhidraInventoryOperation.html @@ -0,0 +1,35 @@ +GhidraInventoryOperation | rea-agents - v1.6.0
                +
                rea-agents - v1.6.0 + +
                  +
                  +
                  Preparing search index...
                  +
                  +
                  +
                  + +

                  Type Alias GhidraInventoryOperation

                  +
                  GhidraInventoryOperation: typeof GHIDRA_INVENTORY_OPERATIONS[number]
                  +

                  One direct inventory operation implemented by the packaged Java bridge.

                  +
                  +
                  +
                  +
                  +
                  +

                  Settings

                   +
                  +
                  Member Visibility +
                    +
                    • +
                  +
                  +
                  +
                  +
                  diff --git a/docs/api/types/ghidra_GhidraProvider.GhidraProviderClientFactory.html b/docs/api/types/ghidra_GhidraProvider.GhidraProviderClientFactory.html new file mode 100644 index 000000000..8cfe1b0f2 --- /dev/null +++ b/docs/api/types/ghidra_GhidraProvider.GhidraProviderClientFactory.html @@ -0,0 +1,47 @@ +GhidraProviderClientFactory | rea-agents - v1.6.0
                  +
                  rea-agents - v1.6.0 + +
                    +
                    +
                    Preparing search index...
                    +
                    +
                    +
                    + +

                    Type Alias GhidraProviderClientFactory

                    +
                    GhidraProviderClientFactory: (
                        options: GhidraClientOptions,
                    ) => Pick<GhidraClient, "start" | "callTool" | "close">
                    +

                    Production seam for exercising provider projection without a real process.

                    +
                    +
                    +

                    Type Declaration

                    +
                    +
                    +
                    +
                    +
                    +

                    Settings

                     +
                    +
                    Member Visibility +
                      +
                      • +
                    +
                    +
                    +
                    +
                    diff --git a/docs/api/types/ghidra_GhidraSessionValues.GhidraSessionInfo.html b/docs/api/types/ghidra_GhidraSessionValues.GhidraSessionInfo.html index 94a2c1d4f..84ecd55f8 100644 --- a/docs/api/types/ghidra_GhidraSessionValues.GhidraSessionInfo.html +++ b/docs/api/types/ghidra_GhidraSessionValues.GhidraSessionInfo.html @@ -15,7 +15,7 @@

                    Authenticated metadata produced after Ghidra finishes auto-analysis.

                    +
                  • Defined in src/ghidra/GhidraSessionValues.ts:48
                    • diff --git a/docs/api/variables/contracts_toolContracts.ENHANCED_TOOL_CONTRACTS.html b/docs/api/variables/contracts_toolContracts.ENHANCED_TOOL_CONTRACTS.html index 5036c7cb5..f5cfc4d99 100644 --- a/docs/api/variables/contracts_toolContracts.ENHANCED_TOOL_CONTRACTS.html +++ b/docs/api/variables/contracts_toolContracts.ENHANCED_TOOL_CONTRACTS.html @@ -15,7 +15,7 @@

                    Bounded workflows composed from one or more bridge operations.

                    +
                  • Defined in src/contracts/toolContracts.ts:345
                    • diff --git a/docs/api/variables/contracts_toolContracts.OFFICIAL_TOOL_CONTRACTS.html b/docs/api/variables/contracts_toolContracts.OFFICIAL_TOOL_CONTRACTS.html index ac6743e8a..6e64e98bf 100644 --- a/docs/api/variables/contracts_toolContracts.OFFICIAL_TOOL_CONTRACTS.html +++ b/docs/api/variables/contracts_toolContracts.OFFICIAL_TOOL_CONTRACTS.html @@ -15,7 +15,7 @@

                    Bridge operations exposed without additional application composition.

                    +
                  • Defined in src/contracts/toolContracts.ts:166
                    • diff --git a/docs/api/variables/contracts_toolContracts.SESSION_TOOL_CONTRACTS.html b/docs/api/variables/contracts_toolContracts.SESSION_TOOL_CONTRACTS.html index 5991fa40d..cb8eed2bd 100644 --- a/docs/api/variables/contracts_toolContracts.SESSION_TOOL_CONTRACTS.html +++ b/docs/api/variables/contracts_toolContracts.SESSION_TOOL_CONTRACTS.html @@ -15,7 +15,7 @@

                    Target lifecycle tools available only on the long-lived MCP adapter.

                    +
                  • Defined in src/contracts/toolContracts.ts:409
                    • diff --git a/docs/api/variables/contracts_toolContracts.TOOL_CONTRACTS.html b/docs/api/variables/contracts_toolContracts.TOOL_CONTRACTS.html index 34d2120d2..df08b885e 100644 --- a/docs/api/variables/contracts_toolContracts.TOOL_CONTRACTS.html +++ b/docs/api/variables/contracts_toolContracts.TOOL_CONTRACTS.html @@ -15,7 +15,7 @@

                    Complete ordered public inventory used by registration and verification.

                    +
                  • Defined in src/contracts/toolContracts.ts:522
                    • diff --git a/docs/api/variables/contracts_toolContracts.binarySessionInputSchema.html b/docs/api/variables/contracts_toolContracts.binarySessionInputSchema.html index 998b7b5d7..e1f6952b5 100644 --- a/docs/api/variables/contracts_toolContracts.binarySessionInputSchema.html +++ b/docs/api/variables/contracts_toolContracts.binarySessionInputSchema.html @@ -15,7 +15,7 @@

                    Caller observations used to compare a live server with expected identity.

                    +
                  • Defined in src/contracts/toolContracts.ts:399
                    • diff --git a/docs/api/variables/contracts_toolOutputSchemas.artifactOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.artifactOutputSchemas.html index fd96dae12..c00241dd5 100644 --- a/docs/api/variables/contracts_toolOutputSchemas.artifactOutputSchemas.html +++ b/docs/api/variables/contracts_toolOutputSchemas.artifactOutputSchemas.html @@ -15,7 +15,7 @@

                    Exact Evidence v2 schemas for provider-neutral artifact graph operations.

                    +
                  • Defined in src/contracts/toolOutputSchemas.ts:523
                    • diff --git a/docs/api/variables/contracts_toolOutputSchemas.enhancedOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.enhancedOutputSchemas.html index 41d7595d4..1c24842c3 100644 --- a/docs/api/variables/contracts_toolOutputSchemas.enhancedOutputSchemas.html +++ b/docs/api/variables/contracts_toolOutputSchemas.enhancedOutputSchemas.html @@ -15,7 +15,7 @@

                    Exact structured-content schemas for composed analysis workflows.

                    +
                  • Defined in src/contracts/toolOutputSchemas.ts:416
                    • diff --git a/docs/api/variables/contracts_toolOutputSchemas.nativeOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.nativeOutputSchemas.html index f3779c275..5b185aac5 100644 --- a/docs/api/variables/contracts_toolOutputSchemas.nativeOutputSchemas.html +++ b/docs/api/variables/contracts_toolOutputSchemas.nativeOutputSchemas.html @@ -15,7 +15,7 @@

                    Exact Evidence v2 schemas for provider-neutral native inspection.

                    +
                  • Defined in src/contracts/toolOutputSchemas.ts:514
                    • diff --git a/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html index 02e27d403..f73c71b8a 100644 --- a/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html +++ b/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html @@ -12,10 +12,10 @@
                  • officialOutputSchemas

                    • Variable officialOutputSchemasConst

                    officialOutputSchemas: Readonly<Record<string, z.ZodObject>> = ...
                    -

                    Exact structured-content schemas for the direct Hopper operations.

                    +

                    Exact structured-content schemas shared by direct analysis providers.

                    +
                  • Defined in src/contracts/toolOutputSchemas.ts:363
                    • diff --git a/docs/api/variables/contracts_toolOutputSchemas.sessionOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.sessionOutputSchemas.html index b89ea8223..570554cad 100644 --- a/docs/api/variables/contracts_toolOutputSchemas.sessionOutputSchemas.html +++ b/docs/api/variables/contracts_toolOutputSchemas.sessionOutputSchemas.html @@ -15,7 +15,7 @@

                    Exact structured-content schemas for target lifecycle operations.

                    +
                  • Defined in src/contracts/toolOutputSchemas.ts:529
                    • diff --git a/docs/api/variables/domain_hopperValues.functionDossierSchema.html b/docs/api/variables/domain_hopperValues.functionDossierSchema.html index 170f6a8d1..12cf3bc12 100644 --- a/docs/api/variables/domain_hopperValues.functionDossierSchema.html +++ b/docs/api/variables/domain_hopperValues.functionDossierSchema.html @@ -13,7 +13,7 @@

                    Variable functionDossierSchemaConst

                    functionDossierSchema: ZodObject<
                        {
                            assembly: ZodObject<
                                {
                                    items: ZodArray<ZodString>;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            basic_blocks: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<
                                            {
                                                end: ZodString;
                                                start: ZodString;
                                                successors: ZodArray<ZodString>;
                                            },
                                            $strict,
                                        >,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            callees: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<{ address: ZodString; name: ZodString }, $strict>,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            callers: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<{ address: ZodString; name: ZodString }, $strict>,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            comments: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<
                                            {
                                                address: ZodString;
                                                kind: ZodEnum<{ comment: "comment"; inline: "inline" }>;
                                                text: ZodString;
                                            },
                                            $strict,
                                        >,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            incoming_references: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<
                                            {
                                                kind: ZodObject<
                                                    { available: ZodLiteral<false>; reason: ZodString },
                                                    $strict,
                                                >;
                                                source_address: ZodString;
                                                source_procedure: ZodNullable<
                                                    ZodObject<{ address: ZodString; name: ZodString }, $strict>,
                                                >;
                                                target_address: ZodString;
                                                target_procedure: ZodNullable<
                                                    ZodObject<{ address: ZodString; name: ZodString }, $strict>,
                                                >;
                                            },
                                            $strict,
                                        >,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            instruction_scan: ZodObject<
                                { scanned: ZodNumber; truncated: ZodBoolean },
                                $strict,
                            >;
                            outgoing_references: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<
                                            {
                                                kind: ZodObject<
                                                    { available: ZodLiteral<false>; reason: ZodString },
                                                    $strict,
                                                >;
                                                source_address: ZodString;
                                                source_procedure: ZodNullable<
                                                    ZodObject<{ address: ZodString; name: ZodString }, $strict>,
                                                >;
                                                target_address: ZodString;
                                                target_procedure: ZodNullable<
                                                    ZodObject<{ address: ZodString; name: ZodString }, $strict>,
                                                >;
                                            },
                                            $strict,
                                        >,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            procedure: ZodObject<
                                {
                                    address: ZodString;
                                    locals: ZodArray<
                                        ZodObject<
                                            {
                                                description: ZodString;
                                                provenance: ZodLiteral<"hopper-public-python-api">;
                                            },
                                            $strict,
                                        >,
                                    >;
                                    name: ZodString;
                                    signature: ZodNullable<ZodString>;
                                },
                                $strict,
                            >;
                            pseudocode: ZodObject<
                                {
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned_chars: ZodNumber;
                                    text: ZodString;
                                    total_chars: ZodNumber;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            referenced_names: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<
                                            { address: ZodString; source_address: ZodString; value: ZodString },
                                            $strict,
                                        >,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                            referenced_strings: ZodObject<
                                {
                                    items: ZodArray<
                                        ZodObject<
                                            { address: ZodString; source_address: ZodString; value: ZodString },
                                            $strict,
                                        >,
                                    >;
                                    next_offset: ZodNullable<ZodNumber>;
                                    returned: ZodNumber;
                                    total: ZodNullable<ZodNumber>;
                                    truncated: ZodBoolean;
                                },
                                $strict,
                            >;
                        },
                        $strict,
                    > = ...
                    +
                  • Defined in src/domain/hopperValues.ts:143
                    • diff --git a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html index ea1213983..1ccd1f178 100644 --- a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html +++ b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html @@ -11,7 +11,7 @@
                  • ghidra/GhidraDefaults
                  • GHIDRA_BRIDGE_VERSION

                    • Variable GHIDRA_BRIDGE_VERSIONConst

                    -
                    GHIDRA_BRIDGE_VERSION: 1
                    +
                    GHIDRA_BRIDGE_VERSION: 2

                    Version of REA's Java bridge handshake and request protocol.

                    +
                  • Defined in src/ghidra/GhidraProvider.ts:53
                    • diff --git a/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_TOOL_CONTRACTS.html b/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_TOOL_CONTRACTS.html index ee1d17360..00bc97904 100644 --- a/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_TOOL_CONTRACTS.html +++ b/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_TOOL_CONTRACTS.html @@ -11,11 +11,11 @@
                  • ghidra/GhidraProvider
                  • GHIDRA_PROVIDER_TOOL_CONTRACTS

                    • Variable GHIDRA_PROVIDER_TOOL_CONTRACTSConst

                    -
                    GHIDRA_PROVIDER_TOOL_CONTRACTS: readonly CapabilityDescriptor[] = ...
                    -

                    PR07 intentionally exposes session health but no binary operation contract.

                    +
                    GHIDRA_PROVIDER_TOOL_CONTRACTS: readonly (
                        | ToolContract<"address_name">
                        | ToolContract<"comment">
                        | ToolContract<"current_address">
                        | ToolContract<"current_procedure">
                        | ToolContract<"current_document">
                        | ToolContract<"goto_address">
                        | ToolContract<"inline_comment">
                        | ToolContract<"list_bookmarks">
                        | ToolContract<"list_documents">
                        | ToolContract<"list_names">
                        | ToolContract<"list_procedures">
                        | ToolContract<"list_segments">
                        | ToolContract<"list_strings">
                        | ToolContract<"next_address">
                        | ToolContract<"prev_address">
                        | ToolContract<"procedure_address">
                        | ToolContract<"procedure_assembly">
                        | ToolContract<"procedure_callees">
                        | ToolContract<"procedure_callers">
                        | ToolContract<"procedure_info">
                        | ToolContract<"procedure_references">
                        | ToolContract<"procedure_pseudo_code">
                        | ToolContract<"resolve_containing_procedure">
                        | ToolContract<"search_procedures">
                        | ToolContract<"search_strings">
                        | ToolContract<"set_address_name">
                        | ToolContract<"set_addresses_names">
                        | ToolContract<"set_bookmark">
                        | ToolContract<"set_comment">
                        | ToolContract<"set_current_document">
                        | ToolContract<"set_inline_comment">
                        | ToolContract<"unset_bookmark">
                        | ToolContract<"xrefs">
                    )[] = ...
                    +

                    Direct read-only contracts implemented by the Ghidra adapter.

                    +
                  • Defined in src/ghidra/GhidraProvider.ts:64
                    • diff --git a/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html b/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html new file mode 100644 index 000000000..0d492347b --- /dev/null +++ b/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html @@ -0,0 +1,35 @@ +GHIDRA_SESSION_CAPABILITIES | rea-agents - v1.6.0
                    +
                    rea-agents - v1.6.0 + +
                      +
                      +
                      Preparing search index...
                      +
                      +
                      +
                      + +

                      Variable GHIDRA_SESSION_CAPABILITIESConst

                      +
                      GHIDRA_SESSION_CAPABILITIES: readonly [
                          "ping",
                          "shutdown",
                          "address_name",
                          "list_documents",
                          "list_names",
                          "list_procedures",
                          "list_segments",
                          "list_strings",
                          "procedure_address",
                          "resolve_containing_procedure",
                          "search_procedures",
                          "search_strings",
                      ] = ...
                      +

                      Exact methods proved by the bridge handshake after auto-analysis.

                      +
                      +
                      +
                      +
                      +
                      +

                      Settings

                       +
                      +
                      Member Visibility +
                        +
                        • +
                      +
                      +
                      +
                      +
                      diff --git a/docs/architecture.mermaid b/docs/architecture.mermaid index 935ead84e..f76866815 100644 --- a/docs/architecture.mermaid +++ b/docs/architecture.mermaid @@ -8,7 +8,7 @@ graph TD subgraph "Adapters" SERVER["src/server/
                      MCP request translation
                      createServer, tool registration, toolResult"] HOPPER_BRIDGE["bridge/hopper_bridge.py
                      Runs inside Hopper
                      adapts operations to Hopper Python API"] - GHIDRA_BRIDGE["bridge/ghidra/ReaGhidraBridge.java
                      Packaged HeadlessScript
                      private authenticated control channel"] + GHIDRA_BRIDGE["bridge/ghidra/ReaGhidraBridge.java
                      Packaged HeadlessScript
                      authenticated read-only inventory"] INSTALL["Host installation adapters
                      macOS: verified vendor DMG to ~/Applications
                      Linux: verified vendor package + apt/dnf/pacman"] end @@ -21,7 +21,7 @@ graph TD subgraph "Provider Layers" HOPPER["src/hopper/
                      Hopper launch & Unix-socket protocol
                      BridgeLauncher, HopperClient, protocol"] - GHIDRA["src/ghidra/
                      Ghidra discovery, profile & private headless session
                      launcher, client, doctor, protocol"] + GHIDRA["src/ghidra/
                      Ghidra discovery, profile & inventory operations
                      launcher, client, doctor, protocol"] AUX["src/artifacts/ + src/native/
                      disjoint artifact and native capabilities"] BROWSER["src/browser/
                      Loopback CDP transport
                      exact-origin passive observation"] end diff --git a/docs/installation.md b/docs/installation.md index 92209f9f5..da7ace9a4 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -68,10 +68,11 @@ desktop display. Unattended package-manager access requires ## Ghidra -REA's initial Ghidra provider layer is bring-your-own and currently supports -Linux x64 with the exact official Ghidra 12.1.2 release and a 64-bit full JDK 21. It supplies discovery, analysis-profile commitment, and an isolated -read-only headless session; it intentionally declares no binary-analysis -operations yet. +REA's Ghidra provider is bring-your-own and currently supports Linux x64 with +the exact official Ghidra 12.1.2 release and a 64-bit full JDK 21. It supplies +discovery, analysis-profile commitment, an isolated read-only headless session, +and ten bounded inventory/name/search operations. Decompilation, calls, xrefs, +GUI state, and analysis mutations remain unavailable through Ghidra. Extract Ghidra and install the JDK outside REA, then export absolute paths: @@ -96,6 +97,13 @@ per-file analysis timeout, CPU and heap bounds, and its packaged Java bridge via and descriptor are current-user-only, and all owned runtime paths and processes are removed on every terminal lifecycle path. +Operations begin only after default auto-analysis completes. A timeout fails +the open rather than exposing partial analysis. One session contains exactly +one imported Program; use `provider_id: "ghidra"`, `--provider ghidra`, or +`REA_ANALYSIS_PROVIDER=ghidra` when both Hopper and Ghidra support the target. +Run `GHIDRA_INSTALL_DIR=... npm run verify:ghidra` from a source checkout to +compile and analyze the source-owned debug and stripped conformance fixtures. + ## Diagnose, update, and remove `rea doctor --json` is strictly read-only. `rea upgrade` updates only the npm installation that owns the running CLI. `rea uninstall` removes only REA-owned agent registrations and skill files; `--purge-data` additionally removes REA cache and state paths. diff --git a/docs/product-catalog.json b/docs/product-catalog.json index 58a49385b..2dd5409fa 100644 --- a/docs/product-catalog.json +++ b/docs/product-catalog.json @@ -141,7 +141,18 @@ "id": "ghidra", "name": "Ghidra", "version": null, - "capabilities": [] + "capabilities": [ + "address_name", + "list_documents", + "list_names", + "list_procedures", + "list_segments", + "list_strings", + "procedure_address", + "resolve_containing_procedure", + "search_procedures", + "search_strings" + ] }, { "id": "hopper", @@ -412,10 +423,10 @@ "mcp_resource_templates": 7 }, "digests": { - "tools_sha256": "4babed9cb04300aa302d45de352c0401f7d9f5cb59e7bcb7e16c305172f4b7e7", + "tools_sha256": "8ca80bad31cd3f843b020fbef3c4b7da589e74345a2c7eec5edf18bd7f5f3bda", "prompts_sha256": "cb1a0316708d1bdb5f4325c2000e466211b16070af8c927bc201340301f194c4", "resources_sha256": "e603aad57a79479004fbdc267644092e8365dd64d94ad772b9da4425a49abd73", - "combined_sha256": "33c6be9777325d74209679f624e94a042092b275a10018d42c6d9a231ef8a473" + "combined_sha256": "8a3d3b22fdecc75a773dc2f6aba201ac9c61d4fdd69d341933a211410f72ccb3" } } } diff --git a/docs/provider-evaluation.md b/docs/provider-evaluation.md index 91a06fe66..d47715149 100644 --- a/docs/provider-evaluation.md +++ b/docs/provider-evaluation.md @@ -1,20 +1,22 @@ # Static-analysis provider evaluation -Status: the Ghidra provider foundation is shipped. It validates an exact -bring-your-own Ghidra 12.1.2/JDK 21 environment on Linux x64, resolves a -provider/version/profile commitment, and runs one isolated read-only headless -import with an authenticated post-analysis bridge. It intentionally publishes -no binary operation capabilities yet. +Status: the Ghidra read-only inventory provider is shipped. It validates an +exact bring-your-own Ghidra 12.1.2/JDK 21 environment on Linux x64, resolves a +provider/version/profile commitment, runs one isolated read-only headless +import, and publishes ten operation-level capabilities after the authenticated +post-analysis handshake. The provider-neutral target, provider registry, deterministic target binding, analysis-profile commitment, Evidence provenance, snapshot v2, and bounded provider-process lifecycle foundations are implemented. The Ghidra launcher, packaged Java bridge, doctor/setup projection, bounded client lifecycle, and -single-target real Linux verifier are also implemented. Binary inventory and -function semantics remain gated on operation adapters and a multi-fixture -conformance suite. A provider is not a drop-in replacement for Hopper: every -capability must be mapped explicitly, with truthful `unavailable` or degraded -results where the engine cannot provide equivalent semantics. +multi-target real Linux verifier are also implemented. Program identity, +procedure/string/symbol inventory, memory blocks, address/name and +containing-procedure resolution, and bounded search are admitted. Function +details, decompilation, calls, xrefs, and CFG remain gated on later operation +adapters. A provider is not a drop-in replacement for Hopper: every capability +is mapped explicitly, with truthful `unavailable` or degraded results where the +engine cannot provide equivalent semantics. [ADR-0001](adr/0001-provider-selection-and-analysis-profiles.md) fixes the provider registry, deterministic selection, target binding, analysis profile, @@ -32,9 +34,9 @@ follow. bounded startup/analysis/request deadlines, cancellation, and cleanup. - Prefer a packaged Java bridge loaded through Ghidra's script path. PyGhidra remains useful for prototypes but is not a mandatory production dependency. -- The foundation bridge exposes authenticated `ping` and `shutdown` only. - Successful auto-analysis is lifecycle proof, not an inventory, xref, CFG, or - decompilation claim. +- Treat authenticated `ping` and `shutdown` as lifecycle proof only. Inventory, + xref, CFG, and decompilation claims require separately admitted operation + contracts and real-provider conformance. - Implement read-only inventories, assembly, decompilation, function metadata, calls, references, containment, and bounded search first. - Report GUI cursor/navigation and persistent mutation operations as unavailable @@ -59,14 +61,35 @@ two CPUs, and a 2 GiB heap; inherited Java option injection variables are cleared. The mode-0600 descriptor carries the random token without exposing it in argv or environment. The Java bridge deletes the descriptor after parsing, binds a mode-0600 Unix socket, reports actual Ghidra/language/compiler/analysis -metadata, accepts only bounded authenticated `ping`/`shutdown`, and deletes the -socket. Close, cancellation, timeout, malformed protocol, or process exit stops -the token-verified owned process group and removes the entire runtime root. +metadata, accepts only the exact authenticated `ping`, `shutdown`, and ten +inventory methods, and deletes the socket. Close, cancellation, timeout, +malformed protocol, or process exit stops the token-verified owned process +group and removes the entire runtime root. -The provider catalog therefore lists `ghidra` with an empty capability array. -This is deliberate: provider discovery and a real headless lifecycle are -shipped, while binary operation semantics remain unavailable rather than being -borrowed from Hopper or inferred from a successful import. +The provider catalog lists only the ten proved Ghidra operations. GUI cursor, +mutation, decompilation, assembly, call, xref, and CFG operations are absent; +the router therefore reports them unavailable instead of borrowing Hopper +semantics or inferring capability from a successful import. + +## Admitted inventory semantics + +| Concern | Ghidra contract | +| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| Program identity | One `analyzeHeadless` import produces exactly one Program; `list_documents` therefore returns exactly one name. | +| Addresses | Default memory uses lowercase `0x` hexadecimal. Non-default and external spaces use `:0x` and remain round-trippable. The handshake commits image base and default address-space name. | +| Symbols | `list_names` includes address-bearing memory and external symbols, including dynamic symbols, while excluding variable and no-address namespace records. Each item reports primary, dynamic, external, symbol type, and source facts. | +| Procedures | Both non-external and external functions are listed. A local thunk remains distinct from its resolved target; exact and qualified name lookup fails on ambiguity rather than guessing. | +| Strings | Only Ghidra-defined string `Data` is observed. Items report charset, byte length, and whether a required null terminator is missing. The API cannot distinguish a present terminator from fixed/Pascal layouts when no terminator is missing, so that state is named `present_or_not_required`. | +| Memory | Memory-block end addresses are exclusive. Read/write/execute, initialization, overlay, address space, and image base are direct Ghidra observations. | +| Pagination | List limits are 500 and search limits are 100. Pages commit exact totals and advancing offsets; an inventory above one million items fails rather than returning a partial result labeled exhaustive. | +| Search | Literal search scans the immutable inventory with a 1,000,000-unit cumulative work budget. Regex uses a conservative finite Java-regex subset with 10,000 static paths, 4,096 UTF-16 code units per candidate, and the same cumulative budget. Exceeding a budget fails explicitly; returned values identify truncation. | +| Analysis state | The socket is exposed only after default auto-analysis. A 300-second analysis timeout fails target opening; established requests have a 10-second client deadline and a 1 MiB response ceiling. | + +`npm run verify:ghidra` compiles the versioned C oracle into separate debug and +stripped ELF binaries. It proves all ten operations, external functions, +resolved thunks, primary symbols, stripped-name behavior, strings, permissions, +bounded search, exact pagination, profile identity, and process/project cleanup +against real Ghidra 12.1.2. Unit fixtures separately reject malformed output. ## Shared provider-process foundation @@ -88,7 +111,7 @@ only the generic process mechanisms. | Provider | License / automation surface | What it brings | REA fit and blockers | | ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| [Ghidra](https://github.com/NationalSecurityAgency/ghidra) | Apache-2.0 source license; `analyzeHeadless`, Java APIs, and PyGhidra | Broad static analysis, many processors and formats, scripting, and project/database workflows | Foundation shipped: exact BYO installation checks, isolated project/state, bounded owned process, packaged Java bridge, and real lifecycle verifier. Operation schemas and semantic conformance remain before it is a full Hopper alternative. | +| [Ghidra](https://github.com/NationalSecurityAgency/ghidra) | Apache-2.0 source license; `analyzeHeadless`, Java APIs, and PyGhidra | Broad static analysis, many processors and formats, scripting, and project/database workflows | Read-only inventory shipped: exact BYO checks, isolated state, bounded process, packaged bridge, ten admitted operations, and real debug/stripped conformance. Function analysis remains before it is a broader Hopper alternative. | | [Rizin](https://github.com/rizinorg/rizin) / [rz-pipe](https://github.com/rizinorg/rz-pipe) | Rizin repository contains LGPL-3.0 and GPL-3.0 components; `rizin`, `rz-bin`, and language bridges through `rzpipe` | Portable CLI analysis, disassembly/debugging, many architectures and file formats, JSON command output | Good candidate for a process-backed Linux provider and fast metadata fallback. License/component inventory must be preserved; command output needs version-pinned parsers and semantic conformance before evidence is trusted. | | [LIEF](https://github.com/lief-project/LIEF) | Apache-2.0; C++, Python, and other bindings | Deterministic parsing and modification of ELF, PE, Mach-O, COFF, and related executable formats; headers, sections, symbols, relocations, and functions | Best near-term complement, not a decompiler replacement. It can cover format metadata and artifact evidence without a long-lived analysis process; function semantics, pseudocode, CFG, and cross-reference parity remain out of scope unless separately demonstrated. | | [Binary Ninja](https://docs.binary.ninja/dev/index.html) | API/documentation components are MIT, while the analysis product is licensed by edition; commercial, Ultimate, or Headless license is required for headless automation | Python/Core/C++/Rust APIs, headless loading, IL layers, function analysis, plugins, and configurable analysis | Strong technical fit for a native provider, especially function dossiers. Commercial licensing, license-secret handling, native runtime packaging, and multithreaded lifecycle rules are material deployment blockers. | @@ -97,8 +120,8 @@ only the generic process mechanisms. 1. Use the implemented explicit provider registry and target binding without changing Hopper behavior. -2. Extend the bounded read-only Ghidra foundation with capabilities admitted - individually through the shared conformance corpus. +2. Extend the admitted Ghidra inventory boundary with function capabilities + admitted individually through the shared conformance corpus. 3. Connect Electron/native-add-on application findings to the selected native analysis provider without introducing provider-prefixed tools. 4. Evaluate LIEF or Rizin later as complementary metadata/disassembly providers, diff --git a/docs/roadmap.md b/docs/roadmap.md index e28bcc43f..7bb80a7b6 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -13,18 +13,19 @@ The Ghidra foundation supports Linux x64 with exact Ghidra 12.1.2 and a 64-bit full JDK 21. Doctor validates those coordinates; approved setup propagates them to MCP registrations without installing or modifying either dependency. REA's packaged Java bridge then proves an isolated read-only headless import, -post-analysis handshake, and complete cleanup. The provider intentionally -declares no binary operation capabilities in this foundation release. +post-analysis handshake, complete cleanup, and ten admitted read-only inventory +operations. Real source-owned debug and stripped ELF fixtures cover program, +procedure, string, symbol, external/thunk, memory, resolution, and search +semantics. ## Next Ghidra milestone -Admit Ghidra read-only capabilities individually: start with program identity, -procedures, strings, symbols, memory blocks, address/name resolution, and -bounded search; then add function details, decompilation, assembly, calls, xrefs, -and CFG. Every claim requires normalized provider-neutral semantics and real -source-owned conformance. Hopper and Ghidra pseudocode text is not expected to -match. Automatic Ghidra acquisition, if ever added, remains a separately -planned and approved related-tool change; setup must never install Java. +Extend the admitted inventory boundary with function details, decompilation, +assembly, calls, xrefs, and CFG. Every claim requires normalized +provider-neutral semantics and real source-owned conformance. Hopper and Ghidra +pseudocode text is not expected to match. Automatic Ghidra acquisition, if ever +added, remains a separately planned and approved related-tool change; setup +must never install Java. ## Capability-selective setup diff --git a/scripts/verify-real-ghidra.mjs b/scripts/verify-real-ghidra.mjs index 21eefd8b4..525e82dfd 100644 --- a/scripts/verify-real-ghidra.mjs +++ b/scripts/verify-real-ghidra.mjs @@ -1,25 +1,30 @@ #!/usr/bin/env node -import { access } from "node:fs/promises"; -import { isAbsolute } from "node:path"; +import { execFile } from "node:child_process"; +import { access, mkdtemp, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { isAbsolute, join } from "node:path"; import { fileURLToPath } from "node:url"; +import { promisify } from "node:util"; import { resolveGhidraAnalysisProfile } from "../dist/ghidra/GhidraAnalysisProfile.js"; import { GhidraClient } from "../dist/ghidra/GhidraClient.js"; +import { parseGhidraInventoryResult } from "../dist/ghidra/GhidraInventoryValues.js"; import { inspectGhidraInstallation, SUPPORTED_GHIDRA_VERSION, } from "../dist/ghidra/GhidraInstallation.js"; import { GhidraHeadlessLauncher } from "../dist/ghidra/GhidraLauncher.js"; import { GHIDRA_PROVIDER_IDENTITY } from "../dist/ghidra/GhidraProvider.js"; +import { GHIDRA_SESSION_CAPABILITIES } from "../dist/ghidra/GhidraSessionValues.js"; import { parseBinaryTarget } from "../dist/domain/binaryTarget.js"; +const exec = promisify(execFile); const installDir = process.env.GHIDRA_INSTALL_DIR; if (installDir === undefined || !isAbsolute(installDir)) throw new Error( "Set GHIDRA_INSTALL_DIR to the absolute root of an extracted Ghidra 12.1.2 release.", ); -const targetPath = process.env.GHIDRA_TARGET_PATH ?? "/usr/bin/true"; const installation = inspectGhidraInstallation({ installDir, ...(process.env.JAVA_HOME === undefined @@ -32,76 +37,390 @@ if (!installation.available || installation.analyzeHeadlessPath === null) ); if (installation.providerVersion !== SUPPORTED_GHIDRA_VERSION) throw new Error("Ghidra provider version commitment drifted"); -const parsedTarget = await parseBinaryTarget(targetPath); -if (!parsedTarget.ok) throw parsedTarget.error; -const profile = await resolveGhidraAnalysisProfile( - parsedTarget.value, - GHIDRA_PROVIDER_IDENTITY, - installation, + +const fixtureRoot = await mkdtemp(join(tmpdir(), "rea-ghidra-fixtures-")); +const sourcePath = fileURLToPath( + new URL("../tests/conformance/ghidra/inventory.c", import.meta.url), ); -if (!profile.ok || profile.value.profile === null) - throw new Error("Ghidra analysis profile could not be committed"); - -const client = new GhidraClient({ - launcher: new GhidraHeadlessLauncher({ - analyzeHeadlessPath: installation.analyzeHeadlessPath, - ...(process.env.JAVA_HOME === undefined - ? {} - : { javaHome: process.env.JAVA_HOME }), - bridgeScriptPath: fileURLToPath( - new URL("../bridge/ghidra/ReaGhidraBridge.java", import.meta.url), - ), - }), - targetPath: parsedTarget.value.path, - providerVersion: SUPPORTED_GHIDRA_VERSION, - profileDigest: profile.value.profile.digest, -}); - -let runtimeCoordinates; -let observedSession; +const debugPath = join(fixtureRoot, "rea-ghidra-inventory-debug"); +const strippedPath = join(fixtureRoot, "rea-ghidra-inventory-stripped"); +const compiler = process.env.REA_CC ?? "cc"; try { - const started = await client.start(); - if (!started.ok) throw started.error; - assertSession(started.value, profile.value.profile.digest); - const pinged = await client.ping(); - if (!pinged.ok) throw pinged.error; - assertSession(pinged.value, profile.value.profile.digest); - observedSession = pinged.value; - runtimeCoordinates = client.diagnostics(); - for (const name of ["runtime_root", "socket_path", "project_root"]) - if (typeof runtimeCoordinates[name] !== "string") - throw new Error(`Ghidra verifier did not observe ${name}`); - if (typeof runtimeCoordinates.process_id !== "number") - throw new Error("Ghidra verifier did not observe its process ID"); + const common = ["-O0", "-g", "-fno-inline", "-fno-pie", "-no-pie"]; + await exec(compiler, [...common, sourcePath, "-o", debugPath]); + await exec(compiler, [...common, "-s", sourcePath, "-o", strippedPath]); + + const debug = await verifyTarget(debugPath, "debug"); + const stripped = await verifyTarget(strippedPath, "stripped"); + assertDebugFixture(debug); + assertStrippedFixture(stripped); + + const customPath = process.env.GHIDRA_TARGET_PATH; + const custom = + customPath === undefined ? null : await verifyTarget(customPath, "custom"); + process.stdout.write( + `${JSON.stringify({ + ok: true, + provider: { id: "ghidra", version: SUPPORTED_GHIDRA_VERSION }, + fixture_source: sourcePath, + fixtures: [summary(debug), summary(stripped)], + custom_target: custom === null ? null : summary(custom), + cleanup: "complete", + })}\n`, + ); } finally { - await client.close(); + await rm(fixtureRoot, { recursive: true, force: true }); } -if (runtimeCoordinates === undefined) - throw new Error("Ghidra runtime coordinates were not captured"); -if (observedSession === undefined) - throw new Error("Ghidra session metadata was not captured"); -for (const name of ["runtime_root", "socket_path", "project_root"]) { - const path = runtimeCoordinates[name]; - if (typeof path === "string" && (await exists(path))) - throw new Error(`Ghidra cleanup left ${name}: ${path}`); -} -const pid = runtimeCoordinates.process_id; -if (typeof pid === "number" && processExists(pid)) - throw new Error(`Ghidra cleanup left process ${String(pid)}`); +async function verifyTarget(targetPath, variant) { + const parsedTarget = await parseBinaryTarget(targetPath); + if (!parsedTarget.ok) throw parsedTarget.error; + const profile = await resolveGhidraAnalysisProfile( + parsedTarget.value, + GHIDRA_PROVIDER_IDENTITY, + installation, + ); + if (!profile.ok || profile.value.profile === null) + throw new Error("Ghidra analysis profile could not be committed"); -process.stdout.write( - `${JSON.stringify({ - ok: true, - provider: { id: "ghidra", version: SUPPORTED_GHIDRA_VERSION }, - target_path: parsedTarget.value.path, - target_sha256: parsedTarget.value.sha256, - analysis_profile_digest: profile.value.profile.digest, - language_id: observedSession.target.language_id, - compiler_spec_id: observedSession.target.compiler_spec_id, - cleanup: "complete", - })}\n`, -); + const client = new GhidraClient({ + launcher: new GhidraHeadlessLauncher({ + analyzeHeadlessPath: installation.analyzeHeadlessPath, + ...(process.env.JAVA_HOME === undefined + ? {} + : { javaHome: process.env.JAVA_HOME }), + bridgeScriptPath: fileURLToPath( + new URL("../bridge/ghidra/ReaGhidraBridge.java", import.meta.url), + ), + }), + targetPath: parsedTarget.value.path, + providerVersion: SUPPORTED_GHIDRA_VERSION, + profileDigest: profile.value.profile.digest, + }); + + let runtimeCoordinates; + try { + const started = await client.start(); + if (!started.ok) throw started.error; + assertSession(started.value, profile.value.profile.digest); + const pinged = await client.ping(); + if (!pinged.ok) throw pinged.error; + assertSession(pinged.value, profile.value.profile.digest); + runtimeCoordinates = client.diagnostics(); + assertRuntimeCoordinates(runtimeCoordinates); + + const documents = await call(client, "list_documents", {}); + const segments = await call(client, "list_segments", { document: null }); + const procedures = await allItems(client, "list_procedures", { + document: null, + }); + const names = await allItems(client, "list_names", { + document: null, + address: null, + }); + const strings = await allItems(client, "list_strings", { + document: null, + address: null, + }); + const probes = + variant === "custom" + ? null + : await verifyInventoryOperations({ + client, + variant, + procedures, + names, + strings, + }); + return { + variant, + target: parsedTarget.value, + profile: profile.value.profile, + session: pinged.value, + documents, + segments, + procedures, + names, + strings, + probes, + }; + } finally { + await client.close(); + if (runtimeCoordinates !== undefined) + await assertCleanup(runtimeCoordinates); + } +} + +async function verifyInventoryOperations({ + client, + variant, + procedures, + names, + strings, +}) { + const rejections = await verifyBridgeRejections(client); + const stringSearch = await call(client, "search_strings", { + pattern: String.raw`^REA_GHIDRA_(?:INVENTORY_ENTRY|LEAF_VALUE)$`, + mode: "regex", + case_sensitive: true, + offset: 0, + limit: 100, + document: null, + }); + if (stringSearch.total !== 2 || stringSearch.items.length !== 2) + throw new Error("Ghidra bounded regex string search drifted"); + const stringItem = strings.find( + (item) => item.value === "REA_GHIDRA_INVENTORY_ENTRY", + ); + if (stringItem === undefined) + throw new Error("Ghidra string probe address is unavailable"); + const filteredStrings = await call(client, "list_strings", { + document: null, + address: stringItem.address, + offset: 0, + limit: 500, + }); + if ( + filteredStrings.total !== 1 || + filteredStrings.items[0]?.address !== stringItem.address + ) + throw new Error("Ghidra exact-address string filter drifted"); + if (variant === "stripped") + return { rejections, stringSearch, filteredStrings }; + + const entry = findValue(procedures, "rea_ghidra_inventory_entry"); + if (entry === undefined) + throw new Error("Ghidra entry procedure probe is unavailable"); + const addressName = await call(client, "address_name", { + document: null, + address: entry.address, + }); + if (symbolTail(addressName) !== "rea_ghidra_inventory_entry") + throw new Error("Ghidra primary address-name resolution drifted"); + const resolvedAddress = await call(client, "procedure_address", { + document: null, + procedure: entry.value, + }); + if (resolvedAddress !== entry.address) + throw new Error("Ghidra procedure-name resolution drifted"); + const interior = `0x${(BigInt(entry.address) + 1n).toString(16)}`; + const containing = await call(client, "resolve_containing_procedure", { + document: null, + address: interior, + }); + if (!containing.found || containing.procedure.address !== entry.address) + throw new Error("Ghidra containing-procedure resolution drifted"); + const procedureSearch = await call(client, "search_procedures", { + pattern: "rea_ghidra_inventory_", + mode: "literal", + case_sensitive: true, + offset: 0, + limit: 1, + document: null, + }); + if ( + procedureSearch.total < 2 || + procedureSearch.items.length !== 1 || + !procedureSearch.has_more || + procedureSearch.next_offset !== 1 + ) + throw new Error("Ghidra literal procedure-search pagination drifted"); + const name = names.find((item) => item.address === entry.address); + if (name === undefined) + throw new Error("Ghidra entry name probe is unavailable"); + const filteredNames = await call(client, "list_names", { + document: null, + address: entry.address, + offset: 0, + limit: 500, + }); + if ( + filteredNames.total < 1 || + !filteredNames.items.some((item) => item.value === name.value) + ) + throw new Error("Ghidra exact-address name filter drifted"); + return { + rejections, + addressName, + resolvedAddress, + containing, + procedureSearch, + stringSearch, + filteredNames, + filteredStrings, + }; +} + +async function verifyBridgeRejections(client) { + return { + unknownDocument: await expectRemoteFailure( + client, + "list_segments", + { document: "not-the-imported-program" }, + "not_found", + ), + malformedParameter: await expectRemoteFailure( + client, + "procedure_address", + { document: null, procedure: 17 }, + "invalid_request", + ), + unboundedRegex: await expectRemoteFailure( + client, + "search_strings", + { + pattern: "a+", + mode: "regex", + case_sensitive: true, + offset: 0, + limit: 100, + document: null, + }, + "invalid_request", + ), + undeclaredMutation: await expectRemoteFailure( + client, + "set_comment", + {}, + "method_unavailable", + ), + }; +} + +async function expectRemoteFailure(client, operation, parameters, code) { + const result = await client.callTool(operation, parameters); + if ( + result.ok || + result.error.kind !== "remote" || + result.error.remoteCode !== code || + result.error.diagnostics.remote_code !== code + ) + throw new Error( + `Ghidra ${operation} rejection drifted: ${JSON.stringify(result)}`, + ); + return { operation, code }; +} + +async function call(client, operation, parameters) { + const called = await client.callTool(operation, parameters); + if (!called.ok) throw called.error; + const parsed = parseGhidraInventoryResult(operation, called.value); + if (!parsed.ok) throw parsed.error; + return parsed.value; +} + +async function allItems(client, operation, parameters) { + const items = []; + let offset = 0; + let total; + while (true) { + const page = await call(client, operation, { + ...parameters, + offset, + limit: 500, + }); + if (typeof page !== "object" || page === null || Array.isArray(page)) + throw new Error(`${operation} did not return a page`); + items.push(...page.items); + total ??= page.total; + if (page.total !== total) + throw new Error(`${operation} total changed during immutable paging`); + if (!page.has_more) break; + if (page.next_offset === null || page.next_offset <= offset) + throw new Error(`${operation} returned a non-advancing page`); + offset = page.next_offset; + } + if (items.length !== total) + throw new Error(`${operation} pagination was not exhaustive`); + return items; +} + +function assertDebugFixture(observed) { + if ( + !Array.isArray(observed.documents) || + observed.documents.length !== 1 || + !observed.documents[0].includes("debug") + ) + throw new Error("Ghidra did not expose exactly one debug Program identity"); + const entry = findValue(observed.procedures, "rea_ghidra_inventory_entry"); + const leaf = findValue(observed.procedures, "rea_ghidra_inventory_leaf"); + const external = observed.procedures.find( + (item) => item.procedure.external && symbolTail(item.value) === "puts", + ); + if (entry === undefined || leaf === undefined || external === undefined) + throw new Error( + "Ghidra procedure inventory missed local or external functions", + ); + if ( + !observed.procedures.some( + (item) => item.procedure.thunk && item.procedure.thunk_target !== null, + ) + ) + throw new Error( + "Ghidra procedure inventory did not distinguish a resolved thunk", + ); + const entryName = findValue(observed.names, "rea_ghidra_inventory_entry"); + if (entryName === undefined || !entryName.symbol.primary) + throw new Error("Ghidra symbol inventory missed the primary entry symbol"); + if (!observed.names.some((item) => item.symbol.external)) + throw new Error("Ghidra symbol inventory missed external symbols"); + assertStrings(observed.strings); + assertSegments(observed.segments, observed.session.target.image_base); +} + +function assertStrippedFixture(observed) { + if ( + observed.procedures.length === 0 || + observed.names.length === 0 || + findValue(observed.procedures, "rea_ghidra_inventory_entry") !== undefined + ) + throw new Error( + "Stripped Ghidra fixture did not preserve stripped semantics", + ); + assertStrings(observed.strings); + assertSegments(observed.segments, observed.session.target.image_base); +} + +function assertStrings(strings) { + for (const expected of [ + "REA_GHIDRA_INVENTORY_ENTRY", + "REA_GHIDRA_LEAF_VALUE", + ]) { + const item = strings.find((candidate) => candidate.value === expected); + if ( + item === undefined || + item.value_truncated || + typeof item.string.encoding !== "string" || + item.string.byte_length < expected.length + ) + throw new Error(`Ghidra string inventory missed ${expected}`); + } +} + +function assertSegments(segments, imageBase) { + if ( + !Array.isArray(segments) || + segments.length === 0 || + !segments.some((item) => item.executable) || + !segments.some((item) => item.writable) || + !segments.every( + (item) => + item.permissions.available === true && + item.permissions.source === "ghidra-memory-block" && + item.image_base === imageBase, + ) + ) + throw new Error("Ghidra memory-block permissions or image base drifted"); +} + +function findValue(items, expected) { + return items.find((item) => symbolTail(item.value) === expected); +} + +function symbolTail(value) { + if (typeof value !== "string") return undefined; + return value.split("::").at(-1); +} function assertSession(session, expectedDigest) { if ( @@ -111,13 +430,50 @@ function assertSession(session, expectedDigest) { session.read_only !== true || session.analysis_complete !== true || session.analysis_timed_out !== false || - session.capabilities.join(",") !== "ping,shutdown" + session.capabilities.join(",") !== GHIDRA_SESSION_CAPABILITIES.join(",") || + !/^0x[0-9a-f]+$/u.test(session.target.image_base) || + session.target.default_address_space.length === 0 ) throw new Error( `Ghidra session commitment drifted: ${JSON.stringify(session)}`, ); } +function assertRuntimeCoordinates(coordinates) { + for (const name of ["runtime_root", "socket_path", "project_root"]) + if (typeof coordinates[name] !== "string") + throw new Error(`Ghidra verifier did not observe ${name}`); + if (typeof coordinates.process_id !== "number") + throw new Error("Ghidra verifier did not observe its process ID"); +} + +async function assertCleanup(coordinates) { + for (const name of ["runtime_root", "socket_path", "project_root"]) { + const path = coordinates[name]; + if (typeof path === "string" && (await exists(path))) + throw new Error(`Ghidra cleanup left ${name}: ${path}`); + } + const pid = coordinates.process_id; + if (typeof pid === "number" && processExists(pid)) + throw new Error(`Ghidra cleanup left process ${String(pid)}`); +} + +function summary(observed) { + return { + variant: observed.variant, + target_path: observed.target.path, + target_sha256: observed.target.sha256, + analysis_profile_digest: observed.profile.digest, + language_id: observed.session.target.language_id, + compiler_spec_id: observed.session.target.compiler_spec_id, + image_base: observed.session.target.image_base, + procedures: observed.procedures.length, + names: observed.names.length, + strings: observed.strings.length, + memory_blocks: observed.segments.length, + }; +} + async function exists(path) { try { await access(path); diff --git a/src/contracts/toolContracts.ts b/src/contracts/toolContracts.ts index e3fe893ec..132ac1a16 100644 --- a/src/contracts/toolContracts.ts +++ b/src/contracts/toolContracts.ts @@ -46,7 +46,11 @@ export type { } from "./toolContractTypes.js"; const document = z.string().optional().describe("The document name"); -const address = z.string().describe("A Hopper address"); +const address = z + .string() + .describe( + "A provider-normalized address; default memory uses 0x-prefixed hexadecimal", + ); const optionalAddress = address.optional(); const procedure = z.string().describe("The procedure name or address"); const searchPattern = z @@ -162,7 +166,7 @@ const session = ( export const OFFICIAL_TOOL_CONTRACTS = [ official( "address_name", - "Resolve the analyzed name at a code or data address, defaulting to Hopper's current cursor. Use before following a symbol into xrefs; null means Hopper has no name at that address.", + "Resolve the primary analyzed name at a code or data address. Headless providers require an explicit address; GUI providers may default to their current cursor. Null means the provider has no primary name at that address.", z.object({ document, address: optionalAddress }), ), official( @@ -202,27 +206,27 @@ export const OFFICIAL_TOOL_CONTRACTS = [ ), official( "list_documents", - "List all Hopper documents visible to the bridge. Use before set_current_document when a provider session contains multiple documents.", + "List provider program or document identities. Hopper may expose several documents; a Ghidra headless session contains exactly its one imported Program.", z.object({}), ), official( "list_names", - "Page through analyzed names as address/value pairs. Results are bounded by offset and limit; follow next_offset until has_more is false before claiming exhaustive symbol coverage.", + "Page through analyzed memory and external symbols as address/value pairs. Provider metadata distinguishes Ghidra primary, dynamic, external, type, and source facts when available; follow next_offset before claiming exhaustive coverage.", z.object({ document, address: optionalAddress, ...pagination }), ), official( "list_procedures", - "Page through analyzed procedures as address/value pairs. Wait for Hopper analysis first, then follow next_offset for exhaustive coverage; use returned addresses with analyze_function or procedure_pseudo_code.", + "Page through analyzed procedures as address/value pairs after provider analysis. Ghidra metadata distinguishes thunks and external functions; follow next_offset for exhaustive coverage and use returned addresses in later function operations.", z.object({ document, ...pagination }), ), official( "list_segments", - "List all segments and sections in the selected document. Hopper's public API does not expose permissions, so writable and executable are null with explicit capability metadata.", + "List segments or memory blocks using exclusive end addresses. Ghidra reports block permissions, address space, image base, initialization, and overlay facts; Hopper marks unavailable permissions explicitly.", z.object({ document }), ), official( "list_strings", - "Page through analyzed strings, or filter to one address, as address/value pairs. Follow next_offset for exhaustive results and use xrefs on interesting string addresses.", + "Page through provider-defined strings, or filter to one address, as address/value pairs. Ghidra reports charset, missing-terminator status, byte length, and explicit value truncation; follow next_offset for exhaustive results.", z.object({ document, address: optionalAddress, ...pagination }), ), official( @@ -237,7 +241,7 @@ export const OFFICIAL_TOOL_CONTRACTS = [ ), official( "procedure_address", - "Resolve a procedure symbol name or hexadecimal address to its entry address. Use this to canonicalize user-supplied identifiers before xrefs, assembly, or decompilation.", + "Resolve an unambiguous procedure symbol name or provider-normalized address to its canonical entry address. External address spaces remain explicit; use the result before xrefs, assembly, or decompilation.", z.object({ procedure, document }), ), official( @@ -279,17 +283,17 @@ export const OFFICIAL_TOOL_CONTRACTS = [ ), official( "resolve_containing_procedure", - "Resolve an arbitrary address, including an xref source or interior instruction, to its Hopper-analyzed containing procedure. A negative result includes an explicit reason and is not guessed from nearby symbols.", + "Resolve an arbitrary address, including an interior instruction or exact external entry, to its provider-analyzed containing procedure. A negative result distinguishes outside segments from not in a procedure and is never guessed from nearby symbols.", z.object({ address, document }), ), official( "search_procedures", - "Search analyzed procedure names using literal matching by default or regex opt-in. Regex rejects unsupported constructs, more than 10,000 static backtracking paths, candidates over 4,096 characters, and searches over 1,000,000 work units. Results are deterministic and offset-paginated.", + "Search analyzed procedure names using literal matching by default or regex opt-in. Ghidra bounds literal work and rejects regex constructs, paths, candidates, or cumulative work outside its finite budgets. Results are deterministic and offset-paginated.", z.object(searchInput), ), official( "search_strings", - "Search analyzed strings using literal matching by default or regex opt-in. Regex rejects unsupported constructs, more than 10,000 static backtracking paths, candidates over 4,096 characters, and searches over 1,000,000 work units. Results are deterministic, offset-paginated, and explicitly truncated.", + "Search analyzed strings using literal matching by default or regex opt-in. Ghidra bounds literal work and rejects regex constructs, paths, candidates, or cumulative work outside its finite budgets. Results are deterministic, offset-paginated, and explicitly truncated.", z.object(searchInput), ), official( diff --git a/src/contracts/toolOutputSchemas.ts b/src/contracts/toolOutputSchemas.ts index 864721bf9..f2e7930a8 100644 --- a/src/contracts/toolOutputSchemas.ts +++ b/src/contracts/toolOutputSchemas.ts @@ -254,6 +254,10 @@ const unavailable = z.object({ available: z.literal(false), reason: z.string(), }); +const availableMemoryPermissions = z.object({ + available: z.literal(true), + source: z.literal("ghidra-memory-block"), +}); const bounded = (item: z.ZodType) => z.object({ items: z.array(item), @@ -262,8 +266,36 @@ const bounded = (item: z.ZodType) => truncated: z.boolean(), next_offset: z.number().int().min(0).nullable(), }); +const addressedValue = z.object({ + address: z.string(), + value: z.string(), + value_truncated: z.boolean().optional(), + symbol: z + .object({ + primary: z.boolean(), + dynamic: z.boolean(), + external: z.boolean(), + type: z.string(), + source: z.enum(["default", "analysis", "ai", "imported", "user_defined"]), + }) + .optional(), + procedure: z + .object({ + external: z.boolean(), + thunk: z.boolean(), + thunk_target: z.string().nullable(), + }) + .optional(), + string: z + .object({ + encoding: z.string(), + termination: z.enum(["missing", "present_or_not_required"]), + byte_length: z.number().int().min(0), + }) + .optional(), +}); const pageOutput = z.object({ - items: z.array(z.object({ address: z.string(), value: z.string() })), + items: z.array(addressedValue), offset: z.number().int().min(0), limit: z.number().int().min(1), total: z.number().int().min(0), @@ -286,8 +318,12 @@ const memoryRegionOutput = z.object({ readable: z.boolean().nullable(), writable: z.boolean().nullable(), executable: z.boolean().nullable(), - permissions: unavailable, - provenance: z.literal("hopper-public-python-api"), + permissions: z.union([unavailable, availableMemoryPermissions]), + provenance: z.enum(["hopper-public-python-api", "ghidra-memory-block"]), + address_space: z.string().optional(), + image_base: z.string().optional(), + initialized: z.boolean().optional(), + overlay: z.boolean().optional(), }); const segmentOutput = resultOf( z.array(memoryRegionOutput.extend({ sections: z.array(memoryRegionOutput) })), @@ -323,7 +359,7 @@ const graphNode = z.discriminatedUnion("status", [ ]); const functionDossierOutput = resultOf(functionDossierSchema); -/** Exact structured-content schemas for the direct Hopper operations. */ +/** Exact structured-content schemas shared by direct analysis providers. */ export const officialOutputSchemas: Readonly> = { address_name: resultOf(nullableText), comment: resultOf(nullableText), diff --git a/src/domain/hopperValues.ts b/src/domain/hopperValues.ts index 93771394d..a643282a6 100644 --- a/src/domain/hopperValues.ts +++ b/src/domain/hopperValues.ts @@ -24,9 +24,29 @@ export interface AddressedPage { readonly hasMore: boolean; } -/** Return the non-negative byte distance between hexadecimal addresses. */ -export const addressDistance = (start: string, end: string): number => - Math.max(0, Number.parseInt(end, 16) - Number.parseInt(start, 16)); +/** Return a bounded byte distance between canonical addresses in one space. */ +export const addressDistance = (start: string, end: string): number => { + const left = addressCoordinate(start); + const right = addressCoordinate(end); + if (left === null || right === null || left.space !== right.space) return 0; + const distance = right.offset - left.offset; + if (distance <= 0n) return 0; + return Number( + distance > BigInt(Number.MAX_SAFE_INTEGER) + ? BigInt(Number.MAX_SAFE_INTEGER) + : distance, + ); +}; + +const addressCoordinate = ( + value: string, +): { readonly space: string; readonly offset: bigint } | null => { + const separator = value.lastIndexOf(":0x"); + const space = separator < 0 ? "default" : value.slice(0, separator); + const offset = separator < 0 ? value : value.slice(separator + 1); + if (!/^0x[0-9a-f]+$/u.test(offset)) return null; + return { space, offset: BigInt(offset) }; +}; const procedureMapSchema = z.record(z.string(), z.string()); const addressedNamesSchema = z.array( diff --git a/src/ghidra/GhidraClient.ts b/src/ghidra/GhidraClient.ts index f3d6f39c1..51289c38f 100644 --- a/src/ghidra/GhidraClient.ts +++ b/src/ghidra/GhidraClient.ts @@ -21,13 +21,18 @@ import { } from "./GhidraDefaults.js"; import type { GhidraClientOptions, + GhidraRequestOptions, GhidraStartResult, } from "./GhidraClientTypes.js"; +import type { GhidraInventoryOperation } from "./GhidraInventoryValues.js"; import { createGhidraDiagnostics } from "./GhidraDiagnostics.js"; import type { GhidraLaunch } from "./GhidraLauncher.js"; import { GhidraResponseBuffer } from "./GhidraResponseBuffer.js"; import { GhidraResponseRouter } from "./GhidraResponseRouter.js"; -import { GhidraSessionError } from "./GhidraSessionError.js"; +import { + bindGhidraSessionFailure, + GhidraSessionError, +} from "./GhidraSessionError.js"; import { isGhidraShutdownAcknowledgement, parseGhidraSessionInfo, @@ -44,6 +49,7 @@ const SESSION_ROOT = "/tmp"; export type { GhidraClientOptions, GhidraDiagnostic, + GhidraRequestOptions, GhidraStartResult, } from "./GhidraClientTypes.js"; @@ -72,10 +78,14 @@ export class GhidraClient { #startupController: AbortController | undefined; #startPromise: Promise | undefined; #closePromise: Promise | undefined; + readonly #failure = bindGhidraSessionFailure(() => this.#diagnostics()); readonly #responseRouter = new GhidraResponseRouter({ pending: this.#pending, nextId: () => this.#nextId, - remoteFailure: (message, cause) => this.#failure("remote", message, cause), + remoteFailure: (failure) => + this.#failure("remote", failure.message, failure, { + remoteCode: failure.code, + }), protocolFailure: (message, cause) => this.#abortProtocol(message, cause), }); readonly #responseBuffer = new GhidraResponseBuffer({ @@ -131,10 +141,7 @@ export class GhidraClient { /** Revalidate live bridge, provider, run, and profile metadata. */ async ping( - options: { - readonly signal?: AbortSignal; - readonly timeoutMs?: number; - } = {}, + options: GhidraRequestOptions = {}, ): Promise> { const started = await this.start(options.signal); if (!started.ok) return started; @@ -143,6 +150,17 @@ export class GhidraClient { return this.#parseSessionInfo(result.value); } + /** Execute one admitted inventory operation after the exact session handshake. */ + async callTool( + operation: GhidraInventoryOperation, + parameters: Readonly>, + options: GhidraRequestOptions = {}, + ): Promise> { + const started = await this.start(options.signal); + if (!started.ok) return started; + return this.#request(operation, parameters, options); + } + /** Stop the owned process group and remove all project/runtime artifacts. */ close(): Promise { const starting = this.#startPromise; @@ -302,7 +320,7 @@ export class GhidraClient { async #request( method: string, params: JsonValue, - options: { readonly signal?: AbortSignal; readonly timeoutMs?: number }, + options: GhidraRequestOptions, ): Promise> { const socket = this.#socket; const token = this.#token; @@ -351,9 +369,7 @@ export class GhidraClient { return result; } - #parseSessionInfo( - value: JsonValue, - ): Result { + #parseSessionInfo(value: JsonValue) { const runId = this.#runId; if (runId === undefined) return err(this.#failure("protocol", "Ghidra run identity is missing")); @@ -362,15 +378,14 @@ export class GhidraClient { providerVersion: this.#options.providerVersion, profileDigest: this.#options.profileDigest, }); - return parsed.ok - ? parsed - : err( - this.#failure( - "protocol", - "Ghidra bridge handshake is invalid", - parsed.error, - ), - ); + if (parsed.ok) return parsed; + return err( + this.#failure( + "protocol", + "Ghidra bridge handshake is invalid", + parsed.error, + ), + ); } async #close( @@ -496,20 +511,6 @@ export class GhidraClient { }); } - #failure( - kind: GhidraSessionError["kind"], - message: string, - cause?: unknown, - options: { readonly timeoutMs?: number } = {}, - ): GhidraSessionError { - return new GhidraSessionError(kind, message, this.#diagnostics(), { - ...(cause === undefined ? {} : { cause }), - ...(options.timeoutMs === undefined - ? {} - : { timeoutMs: options.timeoutMs }), - }); - } - #diagnostics(): Readonly> { const snapshot = this.#process?.snapshot() ?? this.#processSnapshot; return createGhidraDiagnostics({ diff --git a/src/ghidra/GhidraClientTypes.ts b/src/ghidra/GhidraClientTypes.ts index 235a4ad1d..9f53e34b9 100644 --- a/src/ghidra/GhidraClientTypes.ts +++ b/src/ghidra/GhidraClientTypes.ts @@ -7,6 +7,12 @@ import type { GhidraSessionInfo } from "./GhidraSessionValues.js"; /** Result of opening and authenticating one headless Ghidra session. */ export type GhidraStartResult = Result; +/** Cancellation and deadline controls shared by authenticated requests. */ +export interface GhidraRequestOptions { + readonly signal?: AbortSignal; + readonly timeoutMs?: number; +} + /** Safe lifecycle telemetry for one isolated Ghidra headless process. */ export type GhidraDiagnostic = | { diff --git a/src/ghidra/GhidraDefaults.ts b/src/ghidra/GhidraDefaults.ts index 3b676516b..efcfd673b 100644 --- a/src/ghidra/GhidraDefaults.ts +++ b/src/ghidra/GhidraDefaults.ts @@ -11,4 +11,4 @@ export const GHIDRA_REQUEST_TIMEOUT_MS = 10_000; /** Maximum encoded response line accepted from the Java bridge. */ export const GHIDRA_MAX_LINE_BYTES = 1024 * 1024; /** Version of REA's Java bridge handshake and request protocol. */ -export const GHIDRA_BRIDGE_VERSION = 1; +export const GHIDRA_BRIDGE_VERSION = 2; diff --git a/src/ghidra/GhidraInventoryValues.ts b/src/ghidra/GhidraInventoryValues.ts new file mode 100644 index 000000000..004ee79e8 --- /dev/null +++ b/src/ghidra/GhidraInventoryValues.ts @@ -0,0 +1,243 @@ +import { z } from "zod"; + +import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js"; +import { + jsonObjectSchema, + jsonValueSchema, + type JsonValue, +} from "../domain/jsonValue.js"; +import { err, ok, type Result } from "../domain/result.js"; + +/** Read-only direct operations admitted by the Ghidra v1 adapter. */ +export const GHIDRA_INVENTORY_OPERATIONS = [ + "address_name", + "list_documents", + "list_names", + "list_procedures", + "list_segments", + "list_strings", + "procedure_address", + "resolve_containing_procedure", + "search_procedures", + "search_strings", +] as const; + +/** One direct inventory operation implemented by the packaged Java bridge. */ +export type GhidraInventoryOperation = + (typeof GHIDRA_INVENTORY_OPERATIONS)[number]; + +const operationSet: ReadonlySet = new Set(GHIDRA_INVENTORY_OPERATIONS); + +/** Narrow an application operation to the Ghidra inventory surface. */ +export const isGhidraInventoryOperation = ( + operation: string, +): operation is GhidraInventoryOperation => operationSet.has(operation); + +const boundedIdentifier = z.string().min(1).max(4096); +const document = boundedIdentifier.nullable().default(null); +const explicitAddress = boundedIdentifier; +const filteredAddress = explicitAddress.nullable().default(null); +const pagination = { + offset: z.number().int().min(0).default(0), + limit: z.number().int().min(1).max(500).default(100), +}; +const searchInput = { + pattern: z.string().min(1).max(256), + mode: z.enum(["literal", "regex"]).default("literal"), + case_sensitive: z.boolean().default(false), + offset: z.number().int().min(0).default(0), + limit: z.number().int().min(1).max(100).default(100), + document, +}; + +const inputSchemas = { + address_name: z.object({ document, address: explicitAddress }).strict(), + list_documents: z.object({}).strict(), + list_names: z + .object({ document, address: filteredAddress, ...pagination }) + .strict(), + list_procedures: z.object({ document, ...pagination }).strict(), + list_segments: z.object({ document }).strict(), + list_strings: z + .object({ document, address: filteredAddress, ...pagination }) + .strict(), + procedure_address: z + .object({ document, procedure: boundedIdentifier }) + .strict(), + resolve_containing_procedure: z + .object({ document, address: explicitAddress }) + .strict(), + search_procedures: z.object(searchInput).strict(), + search_strings: z.object(searchInput).strict(), +} satisfies Readonly>; + +/** Validate and default one provider request before it crosses the socket. */ +export const parseGhidraInventoryInput = ( + operation: GhidraInventoryOperation, + value: Readonly>, +): Result>, AnalysisInputError> => { + const parsed = inputSchemas[operation].safeParse(value); + if (!parsed.success) + return err(new AnalysisInputError(operation, { cause: parsed.error })); + return ok(jsonObjectSchema.parse(parsed.data)); +}; + +const canonicalAddress = z + .string() + .regex(/^(?:0x[0-9a-f]+|(?:[A-Za-z0-9._~-]|%[0-9A-F]{2})+:0x[0-9a-f]+)$/u); +const valueTruncation = { value_truncated: z.boolean() }; +const symbolFacts = z + .object({ + primary: z.boolean(), + dynamic: z.boolean(), + external: z.boolean(), + type: z.string().min(1), + source: z.enum(["default", "analysis", "ai", "imported", "user_defined"]), + }) + .strict(); +const procedureFacts = z + .object({ + external: z.boolean(), + thunk: z.boolean(), + thunk_target: canonicalAddress.nullable(), + }) + .strict(); +const stringFacts = z + .object({ + encoding: z.string().min(1), + termination: z.enum(["missing", "present_or_not_required"]), + byte_length: z.number().int().min(0), + }) + .strict(); +const baseItem = { + address: canonicalAddress, + value: z.string(), + ...valueTruncation, +}; +const symbolItem = z.object({ ...baseItem, symbol: symbolFacts }).strict(); +const procedureItem = z + .object({ ...baseItem, procedure: procedureFacts }) + .strict(); +const stringItem = z.object({ ...baseItem, string: stringFacts }).strict(); +const searchItem = z.object(baseItem).strict(); + +const pageSchema = (item: Item, maximumLimit: number) => + z + .object({ + items: z.array(item), + offset: z.number().int().min(0), + limit: z.number().int().min(1).max(maximumLimit), + total: z.number().int().min(0), + next_offset: z.number().int().min(0).nullable(), + has_more: z.boolean(), + }) + .strict() + .superRefine((page, context) => { + const next = page.offset + page.items.length; + const hasMore = next < page.total; + if (page.items.length > page.limit) + context.addIssue({ + code: "custom", + path: ["items"], + message: "page exceeds its declared limit", + }); + if (page.items.length > 0 && next > page.total) + context.addIssue({ + code: "custom", + path: ["total"], + message: "page items exceed its exact total", + }); + if (hasMore && page.items.length === 0) + context.addIssue({ + code: "custom", + path: ["items"], + message: "page continuation must advance its offset", + }); + if (page.has_more !== hasMore) + context.addIssue({ + code: "custom", + path: ["has_more"], + message: "page continuation does not match its exact total", + }); + if (page.next_offset !== (hasMore ? next : null)) + context.addIssue({ + code: "custom", + path: ["next_offset"], + message: "page continuation offset is inconsistent", + }); + }); + +const availablePermissions = z + .object({ + available: z.literal(true), + source: z.literal("ghidra-memory-block"), + }) + .strict(); +const memoryRegion = z + .object({ + name: z.string(), + start: canonicalAddress, + end: canonicalAddress, + readable: z.boolean(), + writable: z.boolean(), + executable: z.boolean(), + permissions: availablePermissions, + provenance: z.literal("ghidra-memory-block"), + address_space: z.string().min(1), + image_base: canonicalAddress, + initialized: z.boolean(), + overlay: z.boolean(), + }) + .strict(); +const segment = memoryRegion + .extend({ sections: z.array(memoryRegion) }) + .strict(); +const containingProcedure = z.discriminatedUnion("found", [ + z + .object({ + query_address: canonicalAddress, + found: z.literal(true), + procedure: z + .object({ address: canonicalAddress, name: z.string().min(1) }) + .strict(), + }) + .strict(), + z + .object({ + query_address: canonicalAddress, + found: z.literal(false), + procedure: z.null(), + reason: z.enum(["outside_segments", "not_in_procedure"]), + }) + .strict(), +]); + +const resultSchemas = { + address_name: z.string().nullable(), + list_documents: z.array(z.string().min(1)).length(1), + list_names: pageSchema(symbolItem, 500), + list_procedures: pageSchema(procedureItem, 500), + list_segments: z.array(segment), + list_strings: pageSchema(stringItem, 500), + procedure_address: canonicalAddress, + resolve_containing_procedure: containingProcedure, + search_procedures: pageSchema(searchItem, 100), + search_strings: pageSchema(searchItem, 100), +} satisfies Readonly>; + +/** Require exact, bounded Java-bridge output before creating Evidence. */ +export const parseGhidraInventoryResult = ( + operation: GhidraInventoryOperation, + value: JsonValue, +): Result => { + const parsed = resultSchemas[operation].safeParse(value); + return parsed.success + ? ok(jsonValueSchema.parse(parsed.data)) + : err( + new AnalysisOutputError( + operation, + "Ghidra bridge output did not match the inventory contract", + { cause: parsed.error }, + ), + ); +}; diff --git a/src/ghidra/GhidraProvider.ts b/src/ghidra/GhidraProvider.ts index af3ed5724..a28238069 100644 --- a/src/ghidra/GhidraProvider.ts +++ b/src/ghidra/GhidraProvider.ts @@ -17,17 +17,28 @@ import type { BinaryTarget } from "../domain/binaryTarget.js"; import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, + AnalysisInputError, type AnalysisError, AnalysisTimeoutError, ProviderAdapterError, } from "../domain/errors.js"; import { err, ok, type Result } from "../domain/result.js"; import type { Logger } from "../logger.js"; +import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js"; import { GhidraClient } from "./GhidraClient.js"; +import type { GhidraClientOptions } from "./GhidraClientTypes.js"; import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, + GHIDRA_MAX_LINE_BYTES, + GHIDRA_REQUEST_TIMEOUT_MS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js"; +import { + GHIDRA_INVENTORY_OPERATIONS, + isGhidraInventoryOperation, + parseGhidraInventoryInput, + parseGhidraInventoryResult, +} from "./GhidraInventoryValues.js"; import { ghidraInstallationDiagnostics, inspectGhidraInstallation, @@ -45,13 +56,123 @@ export const GHIDRA_PROVIDER_IDENTITY: ProviderIdentity = Object.freeze({ version: null, }); -/** PR07 intentionally exposes session health but no binary operation contract. */ -export const GHIDRA_PROVIDER_TOOL_CONTRACTS: readonly CapabilityDescriptor[] = - Object.freeze([]); +const officialContractByName = new Map( + OFFICIAL_TOOL_CONTRACTS.map((contract) => [contract.name, contract]), +); + +/** Direct read-only contracts implemented by the Ghidra adapter. */ +export const GHIDRA_PROVIDER_TOOL_CONTRACTS = Object.freeze( + GHIDRA_INVENTORY_OPERATIONS.map((operation) => { + const contract = officialContractByName.get(operation); + if (contract === undefined) + throw new TypeError(`Missing official contract for ${operation}`); + return contract; + }), +); + +const PAGINATED_OPERATIONS: ReadonlySet = new Set([ + "list_names", + "list_procedures", + "list_strings", + "search_procedures", + "search_strings", +]); +const SEARCH_OPERATIONS: ReadonlySet = new Set([ + "search_procedures", + "search_strings", +]); +const healthLimitations = Object.freeze([ + "The session serves operations only after default Ghidra auto-analysis completes; an analysis timeout fails the open instead of exposing partial results.", + "The imported Program and temporary project are ephemeral, read-only to REA, and deleted on close.", +]); + +const limitationsFor = (operation: string): readonly string[] => { + const common = [ + ...healthLimitations, + "Default-space addresses use lowercase 0x-prefixed hexadecimal; other address spaces use :0x.", + ]; + switch (operation) { + case "list_documents": + return [ + ...common, + "A headless Ghidra session contains exactly one imported Program, unlike Hopper's multi-document GUI session.", + ]; + case "list_names": + return [ + ...common, + "The symbol inventory includes memory and external symbols, including dynamic symbols, but excludes variable and no-address namespace records.", + ]; + case "list_procedures": + case "procedure_address": + return [ + ...common, + "External functions and local thunks are distinct; procedure metadata identifies both and preserves a thunk target when Ghidra resolves one.", + ]; + case "list_strings": + return [ + ...common, + "Only Ghidra-defined string Data is observed; charset is reported, while a non-missing terminator cannot distinguish a present terminator from a fixed or Pascal layout.", + "Returned values are bounded to 1,024 Unicode code points and mark value_truncated instead of silently crossing the wire budget.", + ]; + case "list_segments": + return [ + ...common, + "Memory-block end addresses are exclusive; permissions come from Ghidra MemoryBlock flags rather than inference from section names.", + ]; + case "search_procedures": + case "search_strings": + return [ + ...common, + "Literal search enforces 1,000,000 cumulative work units; regex mode also accepts only a conservative finite Java-regex subset with 10,000 static paths and 4,096 UTF-16 code units per candidate.", + ]; + default: + return common; + } +}; +const CAPABILITIES: readonly CapabilityDescriptor[] = Object.freeze( + GHIDRA_PROVIDER_TOOL_CONTRACTS.map((contract) => + Object.freeze({ + provider: GHIDRA_PROVIDER_IDENTITY, + operation: contract.name, + inputContractVersion: 1, + outputContractVersion: 1, + available: true, + reason: null, + pagination: PAGINATED_OPERATIONS.has(contract.name) + ? ("offset" as const) + : ("none" as const), + exhaustive: !PAGINATED_OPERATIONS.has(contract.name), + effects: Object.freeze({ + mutatesArtifact: false, + launchesProcess: true, + mayShowUi: false, + mayAccessNetwork: false, + mayWriteFilesystem: true, + changesPermissions: false, + requiresRoot: false, + }), + limits: Object.freeze({ + maxResults: PAGINATED_OPERATIONS.has(contract.name) + ? SEARCH_OPERATIONS.has(contract.name) + ? 100 + : 500 + : null, + maxPayloadBytes: GHIDRA_MAX_LINE_BYTES, + timeoutMs: GHIDRA_REQUEST_TIMEOUT_MS, + }), + limitations: Object.freeze(limitationsFor(contract.name)), + }), + ), +); const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]); const SUPPORTED_FORMATS = new Set(["elf", "pe", "mach-o"]); +/** Production seam for exercising provider projection without a real process. */ +export type GhidraProviderClientFactory = ( + options: GhidraClientOptions, +) => Pick; + /** Linux Ghidra candidate backed by an isolated read-only headless import. */ export class GhidraProvider implements AnalysisProviderCandidate { #installation: GhidraInstallationInspection | undefined; @@ -60,6 +181,8 @@ export class GhidraProvider implements AnalysisProviderCandidate { private readonly config: AppConfig, private readonly logger: Logger, private readonly installationHost?: GhidraInstallationHost, + private readonly clientFactory: GhidraProviderClientFactory = (options) => + new GhidraClient(options), ) {} identity(): ProviderIdentity { @@ -67,7 +190,7 @@ export class GhidraProvider implements AnalysisProviderCandidate { } capabilities(): readonly CapabilityDescriptor[] { - return GHIDRA_PROVIDER_TOOL_CONTRACTS; + return CAPABILITIES; } inspectAvailability(): ProviderAvailability { @@ -152,7 +275,7 @@ export class GhidraProvider implements AnalysisProviderCandidate { ); if (!prerequisites.ok) return unavailableClient(prerequisites.error); const committedProfile = prerequisites.value.profile; - const client = new GhidraClient({ + const client = this.clientFactory({ launcher: new GhidraHeadlessLauncher({ analyzeHeadlessPath: prerequisites.value.analyzeHeadlessPath, ...(this.config.ghidraJavaHome === undefined @@ -168,25 +291,42 @@ export class GhidraProvider implements AnalysisProviderCandidate { logger: this.logger.child({ layer: "ghidra-bridge" }), }); return { - execute: async (operation, _parameters, options) => { - if (operation !== "health") + execute: async (operation, parameters, options) => { + if (operation !== "health" && !isGhidraInventoryOperation(operation)) return err( new AnalysisCapabilityUnavailableError( GHIDRA_PROVIDER_IDENTITY.id, operation, - "Ghidra binary operations are not declared by this adapter release.", + "The Ghidra adapter does not declare this operation.", ), ); - const started = await client.start(options?.signal); - if (!started.ok) - return err(projectSessionError(operation, started.error)); + if (operation === "health") { + const started = await client.start(options?.signal); + if (!started.ok) + return err(projectSessionError(operation, started.error)); + return ok( + createAnalysisExecution(started.value, committedProfile.provider, { + analysisProfile: committedProfile, + limitations: healthLimitations, + }), + ); + } + const input = parseGhidraInventoryInput(operation, parameters); + if (!input.ok) return input; + const called = await client.callTool( + operation, + input.value, + options?.signal === undefined ? {} : { signal: options.signal }, + ); + if (!called.ok) + return err(projectSessionError(operation, called.error)); + const result = parseGhidraInventoryResult(operation, called.value); + if (!result.ok) return result; return ok( - createAnalysisExecution(started.value, committedProfile.provider, { + createAnalysisExecution(result.value, committedProfile.provider, { + rawResult: called.value, analysisProfile: committedProfile, - limitations: [ - "The session proves completed default Ghidra auto-analysis but exposes no binary operations in this release.", - "The imported program and project are ephemeral and externally read-only.", - ], + limitations: limitationsFor(operation), }), ); }, @@ -268,6 +408,19 @@ const projectSessionError = ( ? GHIDRA_ANALYSIS_TIMEOUT_SECONDS * 1_000 : GHIDRA_STARTUP_TIMEOUT_MS), ); + if ( + failure.kind === "remote" && + ["invalid_request", "not_found", "ambiguous"].includes( + failure.remoteCode ?? "", + ) + ) + return new AnalysisInputError(operation, { cause: failure }); + if (failure.kind === "remote" && failure.remoteCode === "method_unavailable") + return new AnalysisCapabilityUnavailableError( + "ghidra", + operation, + failure.message, + ); return new ProviderAdapterError("ghidra", operation, { cause: failure, diagnostics: failure.diagnostics, diff --git a/src/ghidra/GhidraResponseRouter.ts b/src/ghidra/GhidraResponseRouter.ts index e92794571..7058f01f9 100644 --- a/src/ghidra/GhidraResponseRouter.ts +++ b/src/ghidra/GhidraResponseRouter.ts @@ -3,6 +3,7 @@ import { err, type Result } from "../domain/result.js"; import type { PendingOperations } from "../process/PendingOperations.js"; import type { GhidraSessionError } from "./GhidraSessionError.js"; import { ghidraResponseResult, parseGhidraResponseLine } from "./protocol.js"; +import type { GhidraRemoteError } from "./protocol.js"; /** Dependencies for correlating validated bridge responses. */ export interface GhidraResponseRouterOptions { @@ -11,7 +12,7 @@ export interface GhidraResponseRouterOptions { Result >; readonly nextId: () => number; - readonly remoteFailure: (message: string, cause: Error) => GhidraSessionError; + readonly remoteFailure: (failure: GhidraRemoteError) => GhidraSessionError; readonly protocolFailure: (message: string, cause?: Error) => void; } @@ -38,9 +39,7 @@ export class GhidraResponseRouter { const result = ghidraResponseResult(parsed.value); this.#options.pending.settle( parsed.value.id, - result.ok - ? result - : err(this.#options.remoteFailure(result.error.message, result.error)), + result.ok ? result : err(this.#options.remoteFailure(result.error)), ); } } diff --git a/src/ghidra/GhidraSessionError.ts b/src/ghidra/GhidraSessionError.ts index f0a2a0a3e..c154f4e0f 100644 --- a/src/ghidra/GhidraSessionError.ts +++ b/src/ghidra/GhidraSessionError.ts @@ -13,12 +13,14 @@ export type GhidraSessionFailureKind = /** Additional structured context for a Ghidra session failure. */ export interface GhidraSessionErrorOptions extends ErrorOptions { readonly timeoutMs?: number; + readonly remoteCode?: string; } /** Provider-owned failure with bounded, token-redacted local diagnostics. */ export class GhidraSessionError extends Error { readonly diagnostics: Readonly>; readonly timeoutMs: number | undefined; + readonly remoteCode: string | undefined; constructor( readonly kind: GhidraSessionFailureKind, @@ -30,5 +32,53 @@ export class GhidraSessionError extends Error { this.name = "GhidraSessionError"; this.diagnostics = structuredClone(diagnostics); this.timeoutMs = options.timeoutMs; + this.remoteCode = options.remoteCode; } } + +/** Build a session failure while preserving bounded remote failure metadata. */ +const createGhidraSessionError = (failure: { + readonly kind: GhidraSessionFailureKind; + readonly message: string; + readonly diagnostics: Readonly>; + readonly cause?: unknown; + readonly timeoutMs?: number; + readonly remoteCode?: string; +}): GhidraSessionError => + new GhidraSessionError( + failure.kind, + failure.message, + failure.remoteCode === undefined + ? failure.diagnostics + : { + ...failure.diagnostics, + remote_code: failure.remoteCode, + remote_message: failure.message, + }, + { + ...(failure.cause === undefined ? {} : { cause: failure.cause }), + ...(failure.timeoutMs === undefined + ? {} + : { timeoutMs: failure.timeoutMs }), + ...(failure.remoteCode === undefined + ? {} + : { remoteCode: failure.remoteCode }), + }, + ); + +/** Bind session-failure construction to a live, token-redacted diagnostic view. */ +export const bindGhidraSessionFailure = + (diagnostics: () => Readonly>) => + ( + kind: GhidraSessionFailureKind, + message: string, + cause?: unknown, + options: Pick = {}, + ): GhidraSessionError => + createGhidraSessionError({ + kind, + message, + diagnostics: diagnostics(), + ...(cause === undefined ? {} : { cause }), + ...options, + }); diff --git a/src/ghidra/GhidraSessionValues.ts b/src/ghidra/GhidraSessionValues.ts index 81f9a98e8..df689d383 100644 --- a/src/ghidra/GhidraSessionValues.ts +++ b/src/ghidra/GhidraSessionValues.ts @@ -3,6 +3,16 @@ import { z } from "zod"; import type { JsonValue } from "../domain/jsonValue.js"; import { err, ok, type Result } from "../domain/result.js"; import { GHIDRA_BRIDGE_VERSION } from "./GhidraDefaults.js"; +import { GHIDRA_INVENTORY_OPERATIONS } from "./GhidraInventoryValues.js"; + +/** Exact methods proved by the bridge handshake after auto-analysis. */ +export const GHIDRA_SESSION_CAPABILITIES = [ + "ping", + "shutdown", + ...GHIDRA_INVENTORY_OPERATIONS, +] as const; + +const capabilitySchema = z.enum(GHIDRA_SESSION_CAPABILITIES); const sessionInfoSchema = z .object({ @@ -19,12 +29,16 @@ const sessionInfoSchema = z read_only: z.literal(true), analysis_complete: z.boolean(), analysis_timed_out: z.boolean(), - capabilities: z.array(z.enum(["ping", "shutdown"])).max(2), + capabilities: z + .array(capabilitySchema) + .length(GHIDRA_SESSION_CAPABILITIES.length), 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), }) .strict(), }) @@ -48,9 +62,11 @@ export const parseGhidraSessionInfo = ( parsed.data.run_id !== expected.runId || parsed.data.provider.version !== expected.providerVersion || parsed.data.profile_digest !== expected.profileDigest || - new Set(parsed.data.capabilities).size !== 2 || - !parsed.data.capabilities.includes("ping") || - !parsed.data.capabilities.includes("shutdown") || + new Set(parsed.data.capabilities).size !== + GHIDRA_SESSION_CAPABILITIES.length || + GHIDRA_SESSION_CAPABILITIES.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")); diff --git a/src/ghidra/protocol.ts b/src/ghidra/protocol.ts index 900283488..16e5dad13 100644 --- a/src/ghidra/protocol.ts +++ b/src/ghidra/protocol.ts @@ -47,6 +47,17 @@ const responseSchema = z /** Validated response emitted by REA's packaged Ghidra script. */ export type GhidraBridgeResponse = z.infer; +/** Expected operation failure returned by the authenticated Java bridge. */ +export class GhidraRemoteError extends Error { + constructor( + readonly code: string, + message: string, + ) { + super(message); + this.name = "GhidraRemoteError"; + } +} + /** Parse one complete Java-bridge response without accepting extra fields. */ export const parseGhidraResponseLine = ( line: string, @@ -67,11 +78,12 @@ export const parseGhidraResponseLine = ( /** Project one validated response into its result or remote failure. */ export const ghidraResponseResult = ( response: GhidraBridgeResponse, -): Result => +): Result => response.ok ? ok(response.result ?? null) : err( - new Error( - `${response.error?.code ?? "bridge_error"}: ${response.error?.message ?? "Ghidra bridge request failed"}`, + new GhidraRemoteError( + response.error?.code ?? "bridge_error", + response.error?.message ?? "Ghidra bridge request failed", ), ); diff --git a/tests/conformance/README.md b/tests/conformance/README.md index 88d64f28a..4bbf4337a 100644 --- a/tests/conformance/README.md +++ b/tests/conformance/README.md @@ -8,6 +8,11 @@ their Mach-O symbols and strings with native command-line tools. Only source files are versioned. Generated binaries, generated large-fixture source, debug information, and manifests must remain under `build/`. +`ghidra/inventory.c` is also compiled into temporary Linux ELF debug and +stripped variants by `npm run verify:ghidra`. It fixes local functions, external +`puts` linkage, defined strings, and writable/executable memory needed to prove +the read-only Ghidra inventory contracts without committing a binary. + The C fixture fixes a known call chain and strings. The version pair fixes an added symbol, changed string, and changed call relationship. The generated large fixture contains 1,205 uniquely named functions and strings so provider diff --git a/tests/conformance/ghidra/inventory.c b/tests/conformance/ghidra/inventory.c new file mode 100644 index 000000000..0ceaacd7a --- /dev/null +++ b/tests/conformance/ghidra/inventory.c @@ -0,0 +1,15 @@ +#include + +volatile int rea_ghidra_inventory_global = 7; + +__attribute__((noinline, used)) int rea_ghidra_inventory_leaf(int value) { + puts("REA_GHIDRA_LEAF_VALUE"); + return value + rea_ghidra_inventory_global; +} + +__attribute__((noinline, used)) int rea_ghidra_inventory_entry(void) { + puts("REA_GHIDRA_INVENTORY_ENTRY"); + return rea_ghidra_inventory_leaf(35); +} + +int main(void) { return rea_ghidra_inventory_entry() == 42 ? 0 : 1; } diff --git a/tests/fixtures/fakeGhidra.mjs b/tests/fixtures/fakeGhidra.mjs index 9c41fe871..03769c427 100644 --- a/tests/fixtures/fakeGhidra.mjs +++ b/tests/fixtures/fakeGhidra.mjs @@ -89,6 +89,26 @@ else { } else socket.write(response); continue; } + if (mode === "remote_error" && request.method === "list_procedures") { + socket.write( + `${JSON.stringify({ + id: request.id, + ok: false, + error: { + code: "not_found", + message: "Unknown Ghidra procedure name", + }, + })}\n`, + ); + continue; + } + const inventory = inventoryResult(request.method); + if (inventory !== undefined) { + socket.write( + `${JSON.stringify({ id: request.id, ok: true, result: inventory })}\n`, + ); + continue; + } if (request.method === "shutdown") { socket.end( `${JSON.stringify({ @@ -112,17 +132,130 @@ const sessionInfo = ({ timedOut, }) => ({ name: "REA Ghidra bridge", - bridge_version: 1, + bridge_version: 2, run_id: sessionRunId, profile_digest: digest, provider: { id: "ghidra", version }, read_only: true, analysis_complete: !timedOut, analysis_timed_out: timedOut, - capabilities: ["ping", "shutdown"], + capabilities: [ + "ping", + "shutdown", + "address_name", + "list_documents", + "list_names", + "list_procedures", + "list_segments", + "list_strings", + "procedure_address", + "resolve_containing_procedure", + "search_procedures", + "search_strings", + ], target: { name: "fixture", language_id: "x86:LE:64:default", compiler_spec_id: "gcc", + image_base: "0x1000", + default_address_space: "ram", }, }); + +const inventoryResult = (method) => { + const page = (items) => ({ + items, + offset: 0, + limit: method.startsWith("search_") ? 100 : 500, + total: items.length, + next_offset: null, + has_more: false, + }); + switch (method) { + case "address_name": + return "fixture_main"; + case "list_documents": + return ["fixture"]; + case "list_names": + return page([ + { + address: "0x1000", + value: "fixture_main", + value_truncated: false, + symbol: { + primary: true, + dynamic: false, + external: false, + type: "function", + source: "analysis", + }, + }, + ]); + case "list_procedures": + return page([ + { + address: "0x1000", + value: "fixture_main", + value_truncated: false, + procedure: { external: false, thunk: false, thunk_target: null }, + }, + ]); + case "list_segments": + return [ + { + name: ".text", + start: "0x1000", + end: "0x1100", + readable: true, + writable: false, + executable: true, + permissions: { available: true, source: "ghidra-memory-block" }, + provenance: "ghidra-memory-block", + address_space: "ram", + image_base: "0x1000", + initialized: true, + overlay: false, + sections: [], + }, + ]; + case "list_strings": + return page([ + { + address: "0x2000", + value: "fixture value", + value_truncated: false, + string: { + encoding: "UTF-8", + termination: "present_or_not_required", + byte_length: 14, + }, + }, + ]); + case "procedure_address": + return "0x1000"; + case "resolve_containing_procedure": + return { + query_address: "0x1001", + found: true, + procedure: { address: "0x1000", name: "fixture_main" }, + }; + case "search_procedures": + return page([ + { + address: "0x1000", + value: "fixture_main", + value_truncated: false, + }, + ]); + case "search_strings": + return page([ + { + address: "0x2000", + value: "fixture value", + value_truncated: false, + }, + ]); + default: + return undefined; + } +}; diff --git a/tests/ghidraClient.test.ts b/tests/ghidraClient.test.ts index 596a2b78f..36d3075b7 100644 --- a/tests/ghidraClient.test.ts +++ b/tests/ghidraClient.test.ts @@ -15,6 +15,7 @@ import type { GhidraLaunchSession, GhidraLauncher, } from "../src/ghidra/GhidraLauncher.js"; +import { GHIDRA_SESSION_CAPABILITIES } from "../src/ghidra/GhidraSessionValues.js"; const fixturePath = fileURLToPath( new URL("./fixtures/fakeGhidra.mjs", import.meta.url), @@ -31,6 +32,7 @@ type FixtureMode = | "oversized_whitespace" | "future_id" | "analysis_timeout" + | "remote_error" | "hang_after_start" | "silent" | "exit"; @@ -114,12 +116,63 @@ describe("GhidraClient", () => { read_only: true, analysis_complete: true, analysis_timed_out: false, - capabilities: ["ping", "shutdown"], + capabilities: GHIDRA_SESSION_CAPABILITIES, + target: { + image_base: "0x1000", + default_address_space: "ram", + }, }, }); expect(Buffer.byteLength(launcher.socketPaths[0] ?? "")).toBeLessThan(108); }); + it("correlates an admitted inventory request after startup", async () => { + const client = clientFor(new FixtureLauncher()); + + await expect( + client.callTool("list_procedures", { + document: null, + offset: 0, + limit: 500, + }), + ).resolves.toMatchObject({ + ok: true, + value: { + items: [ + { + address: "0x1000", + value: "fixture_main", + procedure: { external: false, thunk: false }, + }, + ], + total: 1, + has_more: false, + }, + }); + }); + + it("preserves an authenticated operation failure code and diagnostics", async () => { + const client = clientFor(new FixtureLauncher("remote_error")); + + const result = await client.callTool("list_procedures", { + document: null, + offset: 0, + limit: 500, + }); + + expect(result).toMatchObject({ + ok: false, + error: { + kind: "remote", + remoteCode: "not_found", + diagnostics: { + remote_code: "not_found", + remote_message: "Unknown Ghidra procedure name", + }, + }, + }); + }); + it.each([ ["wrong_identity", "protocol"], ["malformed", "protocol"], diff --git a/tests/ghidraInventoryValues.test.ts b/tests/ghidraInventoryValues.test.ts new file mode 100644 index 000000000..771d9efb6 --- /dev/null +++ b/tests/ghidraInventoryValues.test.ts @@ -0,0 +1,232 @@ +import { describe, expect, it } from "vitest"; + +import { + GHIDRA_INVENTORY_OPERATIONS, + isGhidraInventoryOperation, + parseGhidraInventoryInput, + parseGhidraInventoryResult, + type GhidraInventoryOperation, +} from "../src/ghidra/GhidraInventoryValues.js"; +import type { JsonValue } from "../src/domain/jsonValue.js"; + +describe("Ghidra inventory boundary values", () => { + it("defaults bounded provider inputs without accepting undeclared fields", () => { + expect(parseGhidraInventoryInput("list_procedures", {})).toEqual({ + ok: true, + value: { document: null, offset: 0, limit: 100 }, + }); + expect( + parseGhidraInventoryInput("search_strings", { pattern: "needle" }), + ).toEqual({ + ok: true, + value: { + pattern: "needle", + mode: "literal", + case_sensitive: false, + offset: 0, + limit: 100, + document: null, + }, + }); + expect( + parseGhidraInventoryInput("list_documents", { extra: true }), + ).toMatchObject({ ok: false, error: { _tag: "AnalysisInputError" } }); + expect(parseGhidraInventoryInput("address_name", {})).toMatchObject({ + ok: false, + error: { _tag: "AnalysisInputError" }, + }); + expect( + parseGhidraInventoryInput("procedure_address", { + procedure: "x".repeat(4097), + }), + ).toMatchObject({ + ok: false, + error: { _tag: "AnalysisInputError" }, + }); + }); + + it("keeps the admitted operation set closed", () => { + expect(GHIDRA_INVENTORY_OPERATIONS).toHaveLength(10); + expect(isGhidraInventoryOperation("list_names")).toBe(true); + expect(isGhidraInventoryOperation("goto_address")).toBe(false); + expect(isGhidraInventoryOperation("set_comment")).toBe(false); + }); + + it("parses primary, dynamic, and external symbol facts", () => { + const items = [ + { + address: "EXTERNAL:0x1", + value: "libc::puts", + value_truncated: false, + symbol: { + primary: true, + dynamic: false, + external: true, + type: "function", + source: "imported", + }, + }, + { + address: "0x401000", + value: "LAB_00401000", + value_truncated: false, + symbol: { + primary: true, + dynamic: true, + external: false, + type: "label", + source: "default", + }, + }, + ] satisfies readonly JsonValue[]; + expect(parseGhidraInventoryResult("list_names", page(items))).toEqual({ + ok: true, + value: page(items), + }); + }); + + it("parses thunk, string-layout, and memory-permission observations", () => { + expect( + parseGhidraInventoryResult( + "list_procedures", + page([ + { + address: "0x401020", + value: "puts", + value_truncated: false, + procedure: { + external: false, + thunk: true, + thunk_target: "EXTERNAL:0x1", + }, + }, + ]), + ), + ).toMatchObject({ ok: true }); + expect( + parseGhidraInventoryResult( + "list_strings", + page([ + { + address: "0x402000", + value: "fixture", + value_truncated: false, + string: { + encoding: "UTF-8", + termination: "missing", + byte_length: 7, + }, + }, + ]), + ), + ).toMatchObject({ ok: true }); + expect( + parseGhidraInventoryResult("list_segments", [ + { + name: ".text", + start: "0x401000", + end: "0x402000", + readable: true, + writable: false, + executable: true, + permissions: { available: true, source: "ghidra-memory-block" }, + provenance: "ghidra-memory-block", + address_space: "ram", + image_base: "0x400000", + initialized: true, + overlay: false, + sections: [], + }, + ]), + ).toMatchObject({ ok: true }); + }); + + it.each(malformedOutputs())( + "rejects malformed %s output", + (_name, operation, value) => { + expect(parseGhidraInventoryResult(operation, value)).toMatchObject({ + ok: false, + error: { _tag: "AnalysisOutputError" }, + }); + }, + ); +}); + +function malformedOutputs(): Array< + [string, GhidraInventoryOperation, JsonValue] +> { + return [ + [ + "non-canonical address", + "list_procedures", + page([ + { + address: "00401000", + value: "main", + value_truncated: false, + procedure: { + external: false, + thunk: false, + thunk_target: null, + }, + }, + ]), + ], + [ + "missing external metadata", + "list_names", + page([{ address: "0x401000", value: "main", value_truncated: false }]), + ], + [ + "contradictory continuation", + "search_strings", + { + ...page([]), + total: 1, + has_more: false, + next_offset: null, + }, + ], + [ + "non-advancing continuation", + "list_procedures", + { + ...page([]), + total: 1, + has_more: true, + next_offset: 0, + }, + ], + [ + "items beyond exact total", + "list_procedures", + { ...page([procedureItem()]), total: 0 }, + ], + ["provider limit", "search_procedures", { ...page([]), limit: 101 }], + ["multiple programs", "list_documents", ["first", "second"]], + ]; +} + +function procedureItem(): JsonValue { + return { + address: "0x401000", + value: "main", + value_truncated: false, + procedure: { + external: false, + thunk: false, + thunk_target: null, + }, + }; +} + +function page(items: readonly JsonValue[]) { + return { + items: [...items], + offset: 0, + limit: 500, + total: items.length, + next_offset: null, + has_more: false, + }; +} diff --git a/tests/ghidraMcp.test.ts b/tests/ghidraMcp.test.ts new file mode 100644 index 000000000..12437fdfd --- /dev/null +++ b/tests/ghidraMcp.test.ts @@ -0,0 +1,293 @@ +import { Client, InMemoryTransport } from "@modelcontextprotocol/client"; +import { describe, expect, it } from "vitest"; + +import { BinarySession } from "../src/application/BinarySession.js"; +import { EnhancedTools } from "../src/application/EnhancedTools.js"; +import { AnalysisProviderRegistry } from "../src/application/AnalysisProviderRegistry.js"; +import { SessionProviderRouter } from "../src/application/SessionProviderRouter.js"; +import { parseConfig } from "../src/config.js"; +import { parseEvidence } from "../src/domain/evidence.js"; +import type { JsonValue } from "../src/domain/jsonValue.js"; +import { ok } from "../src/domain/result.js"; +import type { GhidraInstallationHost } from "../src/ghidra/GhidraInstallation.js"; +import type { GhidraInventoryOperation } from "../src/ghidra/GhidraInventoryValues.js"; +import { + GhidraProvider, + type GhidraProviderClientFactory, +} from "../src/ghidra/GhidraProvider.js"; +import { GHIDRA_SESSION_CAPABILITIES } from "../src/ghidra/GhidraSessionValues.js"; +import { silentLogger } from "../src/logger.js"; +import { createServer } from "../src/server/createServer.js"; + +const INSTALL = "/opt/ghidra_12.1.2_PUBLIC"; + +describe("Ghidra MCP and shared CLI composition", () => { + it("preserves provider evidence, composed parity, and capability routing", async () => { + const calls: GhidraInventoryOperation[] = []; + const factory: GhidraProviderClientFactory = (options) => ({ + start: () => Promise.resolve(ok(sessionInfo(options.profileDigest))), + callTool: (operation, input) => { + calls.push(operation); + return Promise.resolve(ok(resultFor(operation, input))); + }, + close: () => Promise.resolve(), + }); + const config = parseConfig({ GHIDRA_INSTALL_DIR: INSTALL }); + if (!config.ok) throw config.error; + const provider = new GhidraProvider( + config.value, + silentLogger, + installationHost(), + factory, + ); + const session = new BinarySession( + SessionProviderRouter.selectable( + new AnalysisProviderRegistry([provider]), + [], + ), + ); + const server = createServer(session, session, { logger: silentLogger }); + const mcp = new Client({ name: "ghidra-parity", version: "1.0.0" }); + const [clientTransport, serverTransport] = + InMemoryTransport.createLinkedPair(); + + try { + await server.connect(serverTransport); + await mcp.connect(clientTransport); + const opened = await mcp.callTool({ + name: "open_binary", + arguments: { path: process.execPath }, + }); + expect(opened.isError).not.toBe(true); + + const listed = parseEvidence( + ( + await mcp.callTool({ + name: "list_procedures", + arguments: {}, + }) + ).structuredContent, + ); + expect(listed).toMatchObject({ + operation: "list_procedures", + provider: { id: "ghidra", name: "Ghidra", version: "12.1.2" }, + analysis_profile: { + provider: { id: "ghidra", version: "12.1.2" }, + parameters: { + import_mode: "ephemeral-read-only", + analyzer_preset: "ghidra-default", + }, + }, + normalized_result: { + items: [ + { + address: "0x401000", + value: "fixture_main", + procedure: { + external: false, + thunk: false, + thunk_target: null, + }, + }, + ], + total: 1, + }, + raw_result: { + items: [{ value_truncated: false }], + }, + }); + + const mcpOverview = parseEvidence( + ( + await mcp.callTool({ + name: "binary_overview", + arguments: { detail: "detailed", limit: 5 }, + }) + ).structuredContent, + ); + const directOverview = await new EnhancedTools(session).execute( + "binary_overview", + { detail: "detailed", limit: 5 }, + ); + expect(directOverview.ok).toBe(true); + if (!directOverview.ok) return; + expect(mcpOverview.normalized_result).toEqual(directOverview.value); + expect(mcpOverview).toMatchObject({ + provider: { id: "rea-workflow" }, + confidence: "derived", + normalized_result: { + document: "fixture", + segment_count: 1, + procedure_count: 1, + string_count: 2, + segments: [{ name: ".text", length: 256 }], + }, + }); + + const unsupported = await mcp.callTool({ + name: "set_comment", + arguments: { address: "0x401000", comment: "not allowed" }, + }); + expect(unsupported.isError).toBe(true); + expect(unsupported.structuredContent).toMatchObject({ + error: { code: "capability_unavailable" }, + }); + expect(calls).not.toContain("set_comment"); + + const status = await mcp.callTool({ + name: "binary_session", + arguments: {}, + }); + expect(status.structuredContent).toMatchObject({ + result: { + open: true, + analysis_provider_binding: { + provider: { id: "ghidra", version: "12.1.2" }, + }, + tool_availability: expect.arrayContaining([ + expect.objectContaining({ + name: "binary_overview", + available: true, + }), + expect.objectContaining({ name: "swift_classes", available: true }), + expect.objectContaining({ + name: "get_objc_classes", + available: true, + }), + expect.objectContaining({ + name: "batch_decompile", + available: false, + reason: "provider_missing", + }), + expect.objectContaining({ + name: "trace_feature", + available: false, + reason: "provider_missing", + }), + ]), + }, + }); + } finally { + await Promise.allSettled([mcp.close(), server.close()]); + await session.close(); + } + }); +}); + +const installationHost = (): GhidraInstallationHost => ({ + readText: () => "application.version=12.1.2\n", + executable: () => true, + probeJava: () => ({ + version: "21.0.11", + major: 21, + home: "/usr/lib/jvm/jdk-21", + bits: 64, + jdk: true, + }), +}); + +const sessionInfo = (profileDigest: string) => ({ + name: "REA Ghidra bridge" as const, + bridge_version: 2 as const, + run_id: "11111111-1111-4111-8111-111111111111", + profile_digest: profileDigest, + provider: { id: "ghidra" as const, version: "12.1.2" }, + read_only: true as const, + analysis_complete: true, + analysis_timed_out: false, + capabilities: [...GHIDRA_SESSION_CAPABILITIES], + target: { + name: "fixture", + language_id: "x86:LE:64:default", + compiler_spec_id: "gcc", + image_base: "0x400000", + default_address_space: "ram", + }, +}); + +const resultFor = ( + operation: GhidraInventoryOperation, + input: Readonly>, +): JsonValue => { + const limit = typeof input.limit === "number" ? input.limit : 100; + switch (operation) { + case "list_documents": + return ["fixture"]; + case "list_procedures": + return page( + [ + { + address: "0x401000", + value: "fixture_main", + value_truncated: false, + procedure: { + external: false, + thunk: false, + thunk_target: null, + }, + }, + ], + limit, + ); + case "list_strings": + return page( + [ + stringItem("0x402000", "inventory fixture"), + stringItem("0x402020", "external fixture"), + ], + limit, + ); + case "list_segments": + return [ + { + name: ".text", + start: "0x401000", + end: "0x401100", + readable: true, + writable: false, + executable: true, + permissions: { available: true, source: "ghidra-memory-block" }, + provenance: "ghidra-memory-block", + address_space: "ram", + image_base: "0x400000", + initialized: true, + overlay: false, + sections: [], + }, + ]; + case "list_names": + case "search_procedures": + case "search_strings": + return page([], limit); + case "address_name": + return "fixture_main"; + case "procedure_address": + return "0x401000"; + case "resolve_containing_procedure": + return { + query_address: "0x401001", + found: true, + procedure: { address: "0x401000", name: "fixture_main" }, + }; + } +}; + +const page = (items: readonly JsonValue[], limit: number): JsonValue => ({ + items: [...items], + offset: 0, + limit, + total: items.length, + next_offset: null, + has_more: false, +}); + +const stringItem = (address: string, value: string): JsonValue => ({ + address, + value, + value_truncated: false, + string: { + encoding: "UTF-8", + termination: "present_or_not_required", + byte_length: value.length + 1, + }, +}); diff --git a/tests/ghidraProvider.test.ts b/tests/ghidraProvider.test.ts index bc1527cea..2e0bf9795 100644 --- a/tests/ghidraProvider.test.ts +++ b/tests/ghidraProvider.test.ts @@ -6,8 +6,12 @@ import { GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS, GhidraProvider, + type GhidraProviderClientFactory, } from "../src/ghidra/GhidraProvider.js"; import type { GhidraInstallationHost } from "../src/ghidra/GhidraInstallation.js"; +import { GHIDRA_SESSION_CAPABILITIES } from "../src/ghidra/GhidraSessionValues.js"; +import { err, ok } from "../src/domain/result.js"; +import { GhidraSessionError } from "../src/ghidra/GhidraSessionError.js"; import { silentLogger } from "../src/logger.js"; const INSTALL = "/opt/ghidra_12.1.2_PUBLIC"; @@ -23,10 +27,13 @@ const installationHost = (): GhidraInstallationHost => ({ }), }); -const provider = (host = installationHost()): GhidraProvider => { +const provider = ( + host = installationHost(), + clientFactory?: GhidraProviderClientFactory, +): GhidraProvider => { const config = parseConfig({ GHIDRA_INSTALL_DIR: INSTALL }); if (!config.ok) throw config.error; - return new GhidraProvider(config.value, silentLogger, host); + return new GhidraProvider(config.value, silentLogger, host, clientFactory); }; describe("Ghidra provider", () => { @@ -36,9 +43,29 @@ describe("Ghidra provider", () => { const ghidra = provider(host); expect(ghidra.identity()).toEqual(GHIDRA_PROVIDER_IDENTITY); - expect(ghidra.capabilities()).toBe(GHIDRA_PROVIDER_TOOL_CONTRACTS); - expect(GHIDRA_PROVIDER_TOOL_CONTRACTS).toEqual([]); + expect(ghidra.capabilities().map(({ operation }) => operation)).toEqual( + GHIDRA_PROVIDER_TOOL_CONTRACTS.map(({ name }) => name), + ); + expect(GHIDRA_PROVIDER_TOOL_CONTRACTS).toHaveLength(10); expect(Object.isFrozen(ghidra.capabilities())).toBe(true); + expect(ghidra.capabilities()).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + operation: "list_procedures", + pagination: "offset", + effects: expect.objectContaining({ + mutatesArtifact: false, + mayShowUi: false, + mayWriteFilesystem: true, + }), + limits: { + maxResults: 500, + maxPayloadBytes: 1024 * 1024, + timeoutMs: 10_000, + }, + }), + ]), + ); expect(ghidra.inspectAvailability()).toMatchObject({ status: "available", diagnostics: { @@ -86,7 +113,33 @@ describe("Ghidra provider", () => { }); it("commits exact provider, isolation, and resource semantics", async () => { - const ghidra = provider(); + const callTool = vi.fn().mockResolvedValue( + ok({ + items: [ + { + address: "0x1000", + value: "fixture_main", + value_truncated: false, + procedure: { + external: false, + thunk: false, + thunk_target: null, + }, + }, + ], + offset: 0, + limit: 100, + total: 1, + next_offset: null, + has_more: false, + }), + ); + const start = vi.fn().mockResolvedValue(ok(sessionInfo())); + const ghidra = provider(installationHost(), () => ({ + start, + callTool, + close: () => Promise.resolve(), + })); const resolved = await ghidra.resolveAnalysisProfile( executableTarget("elf", "x86_64"), ); @@ -112,15 +165,92 @@ describe("Ghidra provider", () => { const result = await ghidra .createClient(executableTarget("elf", "x86_64"), resolved.value.profile) .execute("list_procedures", {}); + expect(callTool).toHaveBeenCalledWith( + "list_procedures", + { document: null, offset: 0, limit: 100 }, + {}, + ); expect(result).toMatchObject({ - ok: false, - error: { - _tag: "AnalysisCapabilityUnavailableError", - providerId: "ghidra", + ok: true, + value: { + provider: { + id: "ghidra", + name: "Ghidra", + version: "12.1.2", + }, + analysisProfile: resolved.value.profile, + result: { + items: [{ address: "0x1000", value: "fixture_main" }], + total: 1, + }, + rawResult: { + items: [{ procedure: { external: false, thunk: false } }], + }, }, }); + expect(start).not.toHaveBeenCalled(); }); + it("rejects malformed inventory output before Evidence creation", async () => { + const ghidra = provider(installationHost(), () => ({ + start: () => Promise.resolve(ok(sessionInfo())), + callTool: () => Promise.resolve(ok({ items: "not-a-page" })), + close: () => Promise.resolve(), + })); + const resolved = await ghidra.resolveAnalysisProfile( + executableTarget("elf", "x86_64"), + ); + if (!resolved.ok || resolved.value.profile === null) return; + + await expect( + ghidra + .createClient(executableTarget("elf", "x86_64"), resolved.value.profile) + .execute("list_procedures", {}), + ).resolves.toMatchObject({ + ok: false, + error: { _tag: "AnalysisOutputError" }, + }); + }); + + it.each([ + ["invalid_request", "AnalysisInputError"], + ["not_found", "AnalysisInputError"], + ["ambiguous", "AnalysisInputError"], + ["method_unavailable", "AnalysisCapabilityUnavailableError"], + ] as const)( + "projects remote %s without losing its typed meaning", + async (code, tag) => { + const ghidra = provider(installationHost(), () => ({ + start: () => Promise.resolve(ok(sessionInfo())), + callTool: () => + Promise.resolve( + err( + new GhidraSessionError( + "remote", + "Fixture remote failure", + { remote_code: code }, + { remoteCode: code }, + ), + ), + ), + close: () => Promise.resolve(), + })); + const resolved = await ghidra.resolveAnalysisProfile( + executableTarget("elf", "x86_64"), + ); + if (!resolved.ok || resolved.value.profile === null) return; + + await expect( + ghidra + .createClient( + executableTarget("elf", "x86_64"), + resolved.value.profile, + ) + .execute("list_procedures", {}), + ).resolves.toMatchObject({ ok: false, error: { _tag: tag } }); + }, + ); + it("returns cancellation before profile work", async () => { const controller = new AbortController(); controller.abort(); @@ -135,6 +265,25 @@ describe("Ghidra provider", () => { }); }); +const sessionInfo = () => ({ + name: "REA Ghidra bridge" as const, + bridge_version: 2 as const, + run_id: "11111111-1111-4111-8111-111111111111", + profile_digest: "a".repeat(64), + provider: { id: "ghidra" as const, version: "12.1.2" }, + read_only: true as const, + analysis_complete: true, + analysis_timed_out: false, + capabilities: [...GHIDRA_SESSION_CAPABILITIES], + target: { + name: "fixture", + language_id: "x86:LE:64:default", + compiler_spec_id: "gcc", + image_base: "0x1000", + default_address_space: "ram", + }, +}); + const executableTarget = ( format: BinaryTarget["format"], architecture?: NonNullable, diff --git a/tests/productCatalog.test.ts b/tests/productCatalog.test.ts index c74fdc001..3caa18367 100644 --- a/tests/productCatalog.test.ts +++ b/tests/productCatalog.test.ts @@ -19,7 +19,10 @@ import { HOPPER_PROVIDER_IDENTITY, HOPPER_PROVIDER_TOOL_CONTRACTS, } from "../src/hopper/HopperProvider.js"; -import { GHIDRA_PROVIDER_IDENTITY } from "../src/ghidra/GhidraProvider.js"; +import { + GHIDRA_PROVIDER_IDENTITY, + GHIDRA_PROVIDER_TOOL_CONTRACTS, +} from "../src/ghidra/GhidraProvider.js"; import { NATIVE_MACOS_PROVIDER_IDENTITY } from "../src/native/NativeMacOSProvider.js"; import { assertDocumentationFacts, @@ -74,7 +77,7 @@ describe("canonical product catalog", () => { expect( catalog.providers.find(({ id }) => id === GHIDRA_PROVIDER_IDENTITY.id) ?.capabilities, - ).toEqual([]); + ).toEqual(GHIDRA_PROVIDER_TOOL_CONTRACTS.map(({ name }) => name).sort()); expect( z.toJSONSchema(analysisSnapshotSchema).properties?.snapshot_version, ).toMatchObject({ diff --git a/tests/providerArchitecture.test.ts b/tests/providerArchitecture.test.ts index ec7773642..df6cddb3d 100644 --- a/tests/providerArchitecture.test.ts +++ b/tests/providerArchitecture.test.ts @@ -7,6 +7,7 @@ import { describe, expect, it } from "vitest"; import { parseConfig } from "../src/config.js"; import { HopperProvider } from "../src/hopper/HopperProvider.js"; import { GhidraProvider } from "../src/ghidra/GhidraProvider.js"; +import { GHIDRA_INVENTORY_OPERATIONS } from "../src/ghidra/GhidraInventoryValues.js"; import { silentLogger } from "../src/logger.js"; const sourceRoot = new URL("../src/", import.meta.url); @@ -37,7 +38,7 @@ describe("provider-neutral architecture", () => { expect(violations).toEqual([]); }); - it("publishes no speculative Ghidra binary capabilities", () => { + it("publishes only admitted immutable Ghidra inventory capabilities", () => { const config = parseConfig({}); expect(config.ok).toBe(true); if (!config.ok) return; @@ -46,8 +47,28 @@ describe("provider-neutral architecture", () => { executable: () => false, probeJava: () => undefined, }); - expect(provider.capabilities()).toEqual([]); - expect(Object.isFrozen(provider.capabilities())).toBe(true); + const capabilities = provider.capabilities(); + expect(capabilities.map(({ operation }) => operation).sort()).toEqual( + [...GHIDRA_INVENTORY_OPERATIONS].sort(), + ); + expect(Object.isFrozen(capabilities)).toBe(true); + for (const descriptor of capabilities) { + expect(descriptor).toMatchObject({ + available: true, + reason: null, + effects: { + mutatesArtifact: false, + mayShowUi: false, + mayAccessNetwork: false, + changesPermissions: false, + requiresRoot: false, + }, + }); + expect(Object.isFrozen(descriptor)).toBe(true); + expect(Object.isFrozen(descriptor.effects)).toBe(true); + expect(Object.isFrozen(descriptor.limits)).toBe(true); + expect(Object.isFrozen(descriptor.limitations)).toBe(true); + } }); it("publishes deterministic immutable Hopper capability descriptors", () => {