diff --git a/AGENTS.md b/AGENTS.md index 92fee9485..ebd60703f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -2,7 +2,7 @@ ## Product Direction -REA exposes reverse-engineering tools through a CLI and MCP server. Hopper is the current operation-capable deep binary-analysis provider. The Linux x64 Ghidra provider currently supplies discovery, exact profile commitment, and a private read-only headless session but intentionally declares no binary operations. Keep provider-specific code out of the domain and application layers. +REA exposes reverse-engineering tools through a CLI and MCP server. Hopper and the Linux x64 bring-your-own Ghidra adapter are operation-capable deep binary-analysis providers. Ghidra supplies admitted read-only inventory and function-analysis operations but no GUI or mutation authority. Keep provider-specific code out of the domain and application layers. Prioritize: @@ -25,20 +25,20 @@ See [docs/architecture.mermaid](docs/architecture.mermaid) for a visual architec - `src/main.ts`: MCP adapter. Parses config, wires the shared session runtime, starts stdio transport, and owns process-lifetime shutdown. - `src/cli.ts`: one-shot CLI adapter for setup, diagnostics, analysis, and decompilation. - `src/config.ts`: Zod-validated parsing of environment configuration into `AppConfig`. -- `src/domain/`: pure, side-effect-free modules. `errors.ts` (tagged error algebra), `result.ts` (`Result`/`ok`/`err`), `hopperValues.ts` (boundary parsers for Hopper JSON), `symbolAnalysis.ts` (Swift/ObjC name parsing). +- `src/domain/`: pure, side-effect-free modules. `errors.ts` (tagged error algebra), `result.ts` (`Result`/`ok`/`err`), `hopperValues.ts` (shared function-dossier values plus Hopper boundary parsers), `symbolAnalysis.ts` (Swift/ObjC name parsing). - `src/contracts/`: caller-visible schemas for 33 direct, 10 enhanced, 5 native, 2 artifact, 8 browser, 2 Electron, and 18 session tools; `enhancedInputs.ts` owns enhanced input parsing. - `src/process/`: provider-neutral process ownership and lifecycle primitives. It owns private runtime roots, absolute startup deadlines, correlated request waits, bounded output capture, and TERM-to-KILL cleanup without defining any provider wire protocol. - `src/browser/`: loopback CDP discovery, bounded WebSocket transport, exact-origin target authorization, and passive browser observation normalization. - `src/hopper/`: Hopper launch and Unix-socket protocol mechanics. `BridgeLauncher.ts` spawns the Hopper app with the in-process bridge, `HopperClient.ts` correlates request/response over the socket with timeouts and cancellation, `protocol.ts` frames bridge messages. - `bridge/hopper_bridge.py`: runs inside Hopper and adapts declared operations to Hopper's public Python API. Hopper's bundled MCP server is not used. -- `src/ghidra/`: exact Ghidra 12.1.2/JDK 21 installation inspection, analysis-profile commitment, isolated `analyzeHeadless` launch, authenticated Unix-socket client, and the intentionally capability-empty provider foundation. -- `bridge/ghidra/ReaGhidraBridge.java`: packaged `HeadlessScript` loaded through Ghidra's `scriptPath`; it reports post-analysis identity and supports only authenticated `ping`/`shutdown` in the foundation release. +- `src/ghidra/`: exact Ghidra 12.1.2/JDK 21 inspection, analysis-profile commitment, isolated `analyzeHeadless` launch, authenticated Unix-socket client, bounded serial request queue, and strict inventory/function boundaries. +- `bridge/ghidra/ReaGhidraBridge.java`: packaged read-only `HeadlessScript` loaded through Ghidra's `scriptPath`; it owns the persistent decompiler and adapts admitted inventory, function, reference, and CFG operations to public Ghidra APIs. - `src/application/`: shared CLI/MCP session composition, setup and diagnostics, and enhanced workflows. `AnalysisProviderRegistry` discovers overlapping deep candidates without starting them; `SessionProviderRouter` binds one candidate per target and composes it with disjoint auxiliary providers. - `src/server/`: MCP request translation. `createServer.ts` assembles the MCP server, `registerOfficialTools.ts`/`registerEnhancedTools.ts` register each tool set, `toolResult.ts` maps `Result` values to MCP content. - `docs/product-catalog.json`: generated package, tool-family, provider, setup-client, schema-version, and CLI facts. Regenerate it from source; do not edit it by hand. - `tests/`: Vitest suite. `tests/fixtures/` holds reusable provider-process fixtures plus the fake launcher, Hopper bridge, and CDP seams. - `scripts/verify-real-hopper.mjs`: real-Hopper end-to-end verifier. -- `scripts/verify-real-ghidra.mjs`: real Linux Ghidra verifier for one isolated read-only import, handshake, and complete cleanup. +- `scripts/verify-real-ghidra.mjs`: real Linux Ghidra verifier for x86-64 debug/stripped ELF, AArch64 ELF, PE, and Mach-O function semantics plus complete cleanup. - `scripts/verify-real-browser.mjs`: real Chrome end-to-end verifier for the passive CDP provider. - `scripts/print-mcp-config.mjs`: prints an MCP server config with absolute paths filled in (`npm run config:print -- /path/to/binary`). diff --git a/README.md b/README.md index ae5517765..336e38672 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, 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. +REA gives agents one consistent way to investigate software. Today that includes deep native analysis and function dossiers through Hopper or bring-your-own Ghidra on Linux, 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 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`. +Deep binary operations use [Hopper](https://www.hopperapp.com/), a separate desktop application with its own license, or a caller-selected Ghidra provider. Ghidra supplies read-only inventory, function metadata, decompilation, assembly, resolved calls, typed references, xrefs, CFG, and function dossiers; 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 read-only inventory provider +### Ghidra read-only analysis 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: @@ -202,9 +202,11 @@ Doctor distinguishes missing configuration, a bad installation root, the wrong G 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 Ghidra adapter declares 18 direct and enhanced operations. Its ten inventory operations are `list_documents`, `list_procedures`, `list_strings`, `list_names`, `list_segments`, `address_name`, `procedure_address`, `resolve_containing_procedure`, `search_procedures`, and `search_strings`. It also admits `procedure_info`, `procedure_pseudo_code`, `procedure_assembly`, `procedure_callers`, `procedure_callees`, `procedure_references`, `xrefs`, and `analyze_function`. These capabilities enable the shared Swift/Objective-C inventory workflows, `binary_overview`, `batch_decompile`, `get_call_graph`, `find_xrefs_to_name`, `trace_feature`, and complete function dossiers. 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. +The bridge serves operations only after auto-analysis completes. Each Program owns one persistent `DecompInterface`; a bounded 32-request FIFO serializes Ghidra API access, and every decompile has a 30-second native deadline. Reference results preserve Ghidra's call/jump/data/read/write/indirect/computed/external facts, while unresolved targetless flows remain explicitly unknown. Synthetic entry-point references without actionable memory sources are omitted. Pseudocode and assembly are provider-specific observations, not original source or Hopper-equivalent text. An analysis timeout, scan or 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 x86-64 debug and stripped ELF, AArch64 ELF, x86-64 PE, and x86-64 Mach-O fixtures. Against real Ghidra 12.1.2 it validates every admitted operation, direct and indirect calls, imports/exports/thunks, typed references, strings/xrefs, multi-block CFG, cancellation, deadlines, concurrency, malformed inputs, and complete process/project cleanup. Set `REA_CC`, `REA_CLANG`, or `REA_LLD_LINK` only when the corresponding compiler command is not on `PATH`. To remove only REA-owned MCP registrations and the managed skill: @@ -382,8 +384,8 @@ 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 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. +2. **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. +3. **Cross-provider conformance growth** — add source-owned architectures and difficult indirect/thunk cases while preserving semantic comparison and provider-specific text boundaries. ### Next @@ -399,7 +401,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 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. +See the [static-analysis provider evaluation](docs/provider-evaluation.md) for the shipped Ghidra function-analysis 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 @@ -433,7 +435,7 @@ flowchart LR REA --> Session["Target-bound session router"] Session --> Registry["Deep-provider registry
deterministic selection"] Registry --> Hopper["Hopper provider"] - Registry --> Ghidra["Ghidra provider
read-only inventory operations"] + Registry --> Ghidra["Ghidra provider
read-only inventory + function analysis"] Hopper --> Runtime["Owned provider runtime
deadline + bounded diagnostics + cleanup"] Ghidra --> Runtime Session --> Native["Native macOS provider"] @@ -512,10 +514,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. 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. +validates its exact installation. Its capability list contains the 18 admitted +read-only inventory and function-analysis operations; selecting it still does +not make Hopper-only GUI or mutation operations available and never triggers a +silent fallback. ### CLI exit status diff --git a/README_ar.md b/README_ar.md index c0d4b70c8..0355aba06 100644 --- a/README_ar.md +++ b/README_ar.md @@ -78,7 +78,7 @@ npx skills add morluto/rea يعرض `rea setup` خطة التغييرات كاملة ويطلب التأكيد قبل تطبيقها. لا يثبت أو يحدّث Homebrew أو Node.js أو npm. إذا كان [Hopper](https://www.hopperapp.com/) مفقودًا، يقترح Setup الحزمة الرسمية. Hopper برنامج منفصل يحتاج إلى ترخيص خاص به. -إذا كان Ghidra 12.1.2 PUBLIC وJDK 21 الكامل بنواة 64 بت مثبتين مسبقًا على Linux ‏64 بت، فيمكن لـ Setup أيضًا تسجيل `GHIDRA_INSTALL_DIR` و`JAVA_HOME` الاختياري بعد الموافقة. لا ينزّل REA أو يثبت أو يعدّل Ghidra أو Java. يقدّم هذا الإصدار أساس جلسة headless خاصة ومعزولة فقط، ولا يعرض بعد عمليات تحليل الملفات الثنائية عبر Ghidra؛ لذلك تستمر مسارات التحليل العميق الحالية باستخدام Hopper. +إذا كان Ghidra 12.1.2 PUBLIC وJDK 21 الكامل بنواة 64 بت مثبتين مسبقًا على Linux ‏64 بت، فيمكن لـ Setup أيضًا تسجيل `GHIDRA_INSTALL_DIR` و`JAVA_HOME` الاختياري بعد الموافقة. لا ينزّل REA أو يثبت أو يعدّل Ghidra أو Java. يوفّر مزوّد Ghidra ضمن جلسة headless معزولة وللقراءة فقط الجرد، وفك الترجمة، والتجميع، وعلاقات الاستدعاء، والمراجع ذات الأنواع، وxref، وCFG، وملفات تحليل الدوال؛ وتبقى حالة الواجهة الرسومية وعمليات التعديل غير متاحة. #### التثبيت على Linux واستكشاف الأخطاء @@ -193,8 +193,8 @@ flowchart LR Human -->|CLI| REA REA --> Hopper[عمليات تحليل Hopper] Hopper --> App[تطبيقك] - REA -.-> Ghidra[أساس Ghidra headless
دون عمليات ثنائية] - Ghidra -.-> App + REA --> Ghidra[تحليل Ghidra للقراءة فقط
جرد + تحليل الدوال] + Ghidra --> App ``` يستخدم CLI وخادم MCP محرك التحليل نفسه. تغلق أوامر الطرفية التطبيق عند انتهائها، بينما تبقيه جلسة الوكيل مفتوحًا أثناء الاستقصاء. @@ -251,7 +251,7 @@ export HOPPER_LOADER_ARGS_JSON='["-l", "Mach-O", "--aarch64"]'
هل يعمل REA على Linux أو Windows؟ -نعم، يعمل REA على macOS 12+ وUbuntu 24.04+ وFedora 41+ وArch Linux ‏64 بت؛ Windows غير مدعوم حاليًا. تعتمد عمليات التحليل العميق الحالية على تطبيق Hopper وواجهة Python الخاصة به، بينما لا يقدّم أساس Ghidra الجديد عمليات تحليل ثنائية بعد. +نعم، يعمل REA على macOS 12+ وUbuntu 24.04+ وFedora 41+ وArch Linux ‏64 بت؛ Windows غير مدعوم حاليًا. يستخدم التحليل العميق Hopper أو مزوّد Ghidra للقراءة فقط الذي يختاره المستدعي؛ ويتطلب Ghidra على Linux الإصدار 12.1.2 وJDK 21 الكامل.
diff --git a/README_ja.md b/README_ja.md index c5b516329..a2852a56a 100644 --- a/README_ja.md +++ b/README_ja.md @@ -80,7 +80,7 @@ npx skills add morluto/rea `rea setup` は変更計画を表示し、確認後に適用します。Homebrew、Node.js、npm をインストールまたは更新しません。[Hopper](https://www.hopperapp.com/) がない場合は公式パッケージを提案します。Hopper は別製品で、ライセンスは別途必要です。 -64 ビット Linux に Ghidra 12.1.2 PUBLIC と完全な 64 ビット JDK 21 がすでにある場合、Setup は承認後に `GHIDRA_INSTALL_DIR` と任意の `JAVA_HOME` も登録できます。REA は Ghidra や Java をダウンロード、インストール、変更しません。このリリースが提供するのは隔離されたプライベート headless セッションの基盤であり、Ghidra のバイナリ解析操作はまだ公開されていないため、既存の深い解析ワークフローは引き続き Hopper を使用します。 +64 ビット Linux に Ghidra 12.1.2 PUBLIC と完全な 64 ビット JDK 21 がすでにある場合、Setup は承認後に `GHIDRA_INSTALL_DIR` と任意の `JAVA_HOME` も登録できます。REA は Ghidra や Java をダウンロード、インストール、変更しません。Ghidra プロバイダーは隔離された読み取り専用 headless セッションで、インベントリ、逆コンパイル、アセンブリ、呼び出し関係、型付き参照、xref、CFG、関数 dossier を提供します。GUI 状態と変更操作は引き続き利用できません。 #### Linux のインストールとトラブルシューティング @@ -182,8 +182,8 @@ flowchart LR Terminal["ターミナル"] --> REA REA --> Hopper["Hopper 解析操作"] Hopper --> App["あなたのアプリ"] - REA -.-> Ghidra["Ghidra headless 基盤
バイナリ操作は未提供"] - Ghidra -.-> App + REA --> Ghidra["Ghidra 読み取り専用解析
インベントリ + 関数解析"] + Ghidra --> App ``` CLI と MCP サーバーは同じ解析エンジンを使います。ターミナルのコマンドは終了時にアプリを閉じ、エージェントのセッションは調査中アプリを開いたままにします。 diff --git a/README_ko.md b/README_ko.md index f2ef6ba18..e7480ad55 100644 --- a/README_ko.md +++ b/README_ko.md @@ -80,7 +80,7 @@ npx skills add morluto/rea `rea setup`은 전체 변경 계획을 표시하고 확인 후 적용합니다. Homebrew, Node.js 또는 npm을 설치하거나 업데이트하지 않습니다. [Hopper](https://www.hopperapp.com/)가 없으면 공식 패키지 설치를 제안합니다. Hopper는 별도 라이선스가 필요한 독립 소프트웨어입니다. -64비트 Linux에 Ghidra 12.1.2 PUBLIC과 완전한 64비트 JDK 21이 이미 설치되어 있다면 Setup은 승인 후 `GHIDRA_INSTALL_DIR`과 선택 사항인 `JAVA_HOME`도 등록할 수 있습니다. REA는 Ghidra나 Java를 다운로드, 설치 또는 수정하지 않습니다. 이 릴리스는 격리된 비공개 headless 세션 기반만 제공하며 Ghidra 바이너리 분석 작업은 아직 노출하지 않으므로, 기존 심층 분석 워크플로는 계속 Hopper를 사용합니다. +64비트 Linux에 Ghidra 12.1.2 PUBLIC과 완전한 64비트 JDK 21이 이미 설치되어 있다면 Setup은 승인 후 `GHIDRA_INSTALL_DIR`과 선택 사항인 `JAVA_HOME`도 등록할 수 있습니다. REA는 Ghidra나 Java를 다운로드, 설치 또는 수정하지 않습니다. Ghidra 공급자는 격리된 읽기 전용 headless 세션에서 인벤토리, 디컴파일, 어셈블리, 호출 관계, 형식이 지정된 참조, xref, CFG 및 함수 dossier를 제공합니다. GUI 상태와 변경 작업은 계속 사용할 수 없습니다. #### Linux 설치 및 문제 해결 @@ -182,8 +182,8 @@ flowchart LR Terminal["터미널"] --> REA REA --> Hopper["Hopper 분석 작업"] Hopper --> App["사용자의 앱"] - REA -.-> Ghidra["Ghidra headless 기반
바이너리 작업 미제공"] - Ghidra -.-> App + REA --> Ghidra["Ghidra 읽기 전용 분석
인벤토리 + 함수 분석"] + Ghidra --> App ``` CLI와 MCP 서버는 같은 분석 엔진을 사용합니다. 터미널 명령은 끝날 때 앱을 닫고, 에이전트 세션은 조사하는 동안 앱을 열어 둡니다. diff --git a/README_zh.md b/README_zh.md index b90746402..935e6b3ea 100644 --- a/README_zh.md +++ b/README_zh.md @@ -80,7 +80,7 @@ npx skills add morluto/rea `rea setup` 会先显示完整变更计划并请求确认。它不会安装或更新 Homebrew、Node.js 或 npm。缺少 [Hopper](https://www.hopperapp.com/) 时，Setup 会提议安装官方软件包；Hopper 是需要单独许可证的独立软件。 -如果你已在 64 位 Linux 上安装 Ghidra 12.1.2 PUBLIC 和完整的 64 位 JDK 21，Setup 也可以在批准后登记 `GHIDRA_INSTALL_DIR` 和可选的 `JAVA_HOME`。REA 不会下载、安装或修改 Ghidra 或 Java。本版本交付的是隔离的私有 headless 会话基础，尚未开放 Ghidra 二进制分析操作，因此现有的深度分析工作流仍使用 Hopper。 +如果你已在 64 位 Linux 上安装 Ghidra 12.1.2 PUBLIC 和完整的 64 位 JDK 21，Setup 也可以在批准后登记 `GHIDRA_INSTALL_DIR` 和可选的 `JAVA_HOME`。REA 不会下载、安装或修改 Ghidra 或 Java。Ghidra provider 在隔离的只读 headless 会话中提供清单、反编译、汇编、调用关系、带类型的引用、xref、CFG 与函数 dossier；GUI 状态和修改操作仍不可用。 #### Linux 安装与故障排除 @@ -182,8 +182,8 @@ flowchart LR Terminal["终端"] --> REA REA --> Hopper["Hopper 分析操作"] Hopper --> App["你的应用"] - REA -.-> Ghidra["Ghidra headless 基础
暂无二进制操作"] - Ghidra -.-> App + REA --> Ghidra["Ghidra 只读分析
清单 + 函数分析"] + Ghidra --> App ``` CLI 与 MCP 服务器使用相同的分析引擎。终端命令完成后会关闭应用；智能体会话则会在调查期间保持应用打开。 diff --git a/bridge/ghidra/ReaGhidraBridge.java b/bridge/ghidra/ReaGhidraBridge.java index f484d0bf1..0931834de 100644 --- a/bridge/ghidra/ReaGhidraBridge.java +++ b/bridge/ghidra/ReaGhidraBridge.java @@ -24,6 +24,7 @@ import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Set; +import java.util.TreeMap; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; @@ -36,25 +37,45 @@ import com.google.gson.JsonObject; import com.google.gson.JsonParser; import ghidra.app.util.headless.HeadlessScript; +import ghidra.app.decompiler.DecompInterface; +import ghidra.app.decompiler.DecompileOptions; +import ghidra.app.decompiler.DecompileResults; +import ghidra.app.decompiler.DecompiledFunction; import ghidra.framework.Application; import ghidra.program.model.address.Address; import ghidra.program.model.address.AddressSpace; +import ghidra.program.model.block.BasicBlockModel; +import ghidra.program.model.block.CodeBlock; +import ghidra.program.model.block.CodeBlockIterator; +import ghidra.program.model.block.CodeBlockReference; +import ghidra.program.model.block.CodeBlockReferenceIterator; import ghidra.program.model.data.StringDataInstance; +import ghidra.program.model.listing.CommentType; 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.listing.Instruction; +import ghidra.program.model.listing.InstructionIterator; +import ghidra.program.model.listing.Variable; import ghidra.program.model.mem.MemoryBlock; +import ghidra.program.model.symbol.RefType; +import ghidra.program.model.symbol.Reference; +import ghidra.program.model.symbol.ReferenceIterator; 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 = 2; + private static final int BRIDGE_VERSION = 3; private static final int MAX_DESCRIPTOR_BYTES = 16 * 1024; private static final int MAX_REQUEST_CHARACTERS = 256 * 1024; private static final int MAX_RESPONSE_BYTES = 1024 * 1024; private static final int MAX_INVENTORY_ITEMS = 1_000_000; + private static final int MAX_FUNCTION_ITEMS = 100_000; + private static final int MAX_FUNCTION_INSTRUCTIONS = 100_000; + private static final int DECOMPILE_TIMEOUT_SECONDS = 30; + private static final int DECOMPILE_PAYLOAD_MBYTES = 8; 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; @@ -88,12 +109,21 @@ public final class ReaGhidraBridge extends HeadlessScript { "procedure_address", "resolve_containing_procedure", "search_procedures", - "search_strings" + "search_strings", + "analyze_function", + "procedure_assembly", + "procedure_callees", + "procedure_callers", + "procedure_info", + "procedure_pseudo_code", + "procedure_references", + "xrefs" }; private List nameInventory; private List procedureInventory; private List stringInventory; + private DecompInterface decompiler; private static AddressSpace sessionDefaultAddressSpace; @Override @@ -113,7 +143,16 @@ public final class ReaGhidraBridge extends HeadlessScript { if (!Application.getApplicationVersion().equals(descriptor.providerVersion)) { throw new IllegalStateException("Ghidra provider version does not match the session"); } - serve(descriptor); + try { + initializeDecompiler(); + serve(descriptor); + } + finally { + if (decompiler != null) { + decompiler.dispose(); + decompiler = null; + } + } } private void serve(SessionDescriptor descriptor) throws Exception { @@ -195,9 +234,17 @@ public final class ReaGhidraBridge extends HeadlessScript { case "list_segments" -> listSegments(request.params); case "list_strings" -> listStrings(request.params); case "procedure_address" -> procedureAddress(request.params); + case "procedure_assembly" -> procedureAssembly(request.params); + case "procedure_callees" -> procedureCalls(request.params, false); + case "procedure_callers" -> procedureCalls(request.params, true); + case "procedure_info" -> procedureInfo(request.params); + case "procedure_pseudo_code" -> procedurePseudocode(request.params); + case "procedure_references" -> procedureReferences(request.params); case "resolve_containing_procedure" -> containingProcedure(request.params); case "search_procedures" -> search(request.params, true); case "search_strings" -> search(request.params, false); + case "xrefs" -> xrefs(request.params); + case "analyze_function" -> analyzeFunction(request.params); default -> throw new RequestFailure( "method_unavailable", "Bridge method is unavailable" @@ -238,6 +285,280 @@ public final class ReaGhidraBridge extends HeadlessScript { return result; } + private void initializeDecompiler() { + DecompileOptions options = new DecompileOptions(); + options.setDefaultTimeout(DECOMPILE_TIMEOUT_SECONDS); + options.setMaxPayloadMBytes(DECOMPILE_PAYLOAD_MBYTES); + options.setMaxInstructions(MAX_FUNCTION_INSTRUCTIONS); + decompiler = new DecompInterface(); + decompiler.setOptions(options); + decompiler.toggleCCode(true); + decompiler.toggleSyntaxTree(true); + if (!decompiler.openProgram(currentProgram)) { + throw new IllegalStateException("Ghidra decompiler could not open the imported Program"); + } + } + + private JsonElement procedurePseudocode(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "procedure")); + requireDocument(params); + String value = decompile(resolveProcedure(requireString(params, "procedure"))); + return value == null ? JsonNull.INSTANCE : GSON.toJsonTree(value); + } + + private JsonElement procedureAssembly(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "procedure")); + requireDocument(params); + Function function = resolveProcedure(requireString(params, "procedure")); + InstructionScan scan = scanInstructions(function, MAX_FUNCTION_INSTRUCTIONS); + if (scan.truncated) { + throw functionLimit("Procedure assembly exceeds the 100000-instruction limit"); + } + return GSON.toJsonTree(renderAssembly(scan.instructions)); + } + + private JsonArray procedureCalls(JsonObject params, boolean callers) throws Exception { + requireKeys(params, Set.of("document", "procedure")); + requireDocument(params); + Function function = resolveProcedure(requireString(params, "procedure")); + Set observed = callers + ? function.getCallingFunctions(monitor) + : function.getCalledFunctions(monitor); + if (observed.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Resolved call set exceeds the 100000-item limit"); + } + List ordered = new ArrayList<>(observed); + ordered.sort(Comparator.comparing(Function::getEntryPoint)); + JsonArray result = new JsonArray(); + for (Function item : ordered) { + result.add(canonicalAddress(item.getEntryPoint())); + } + return result; + } + + private JsonObject procedureInfo(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "procedure")); + requireDocument(params); + Function function = resolveProcedure(requireString(params, "procedure")); + JsonObject result = new JsonObject(); + result.addProperty("name", procedureName(function)); + result.addProperty("entrypoint", canonicalAddress(function.getEntryPoint())); + result.addProperty("basicblock_count", basicBlocks(function).size()); + result.addProperty("length", function.getBody().getNumAddresses()); + result.addProperty("signature", function.getPrototypeString(false, true)); + result.add("locals", functionLocals(function)); + result.add("classification", functionClassification(function)); + return result; + } + + private JsonObject procedureReferences(JsonObject params) throws Exception { + requireKeys( + params, + Set.of( + "document", + "procedure", + "direction", + "offset", + "limit", + "max_instructions" + ) + ); + requireDocument(params); + Function function = resolveProcedure(requireString(params, "procedure")); + String direction = requireString(params, "direction"); + if (!direction.equals("incoming") && !direction.equals("outgoing")) { + throw new RequestFailure("invalid_request", "direction must be incoming or outgoing"); + } + int offset = requireBoundedInteger(params, "offset", 0, Integer.MAX_VALUE); + int limit = requireBoundedInteger(params, "limit", 1, 500); + int maximum = requireBoundedInteger(params, "max_instructions", 1, 5_000); + InstructionScan scan = scanInstructions(function, maximum); + List references = collectReferences(scan.instructions, direction); + JsonArray edges = new JsonArray(); + for (Reference reference : references) { + edges.add(referenceEdge(reference)); + } + JsonObject result = new JsonObject(); + result.add("procedure", procedureIdentity(function)); + result.addProperty("direction", direction); + result.add("references", bounded(edges, offset, limit, !scan.truncated)); + result.addProperty("instructions_scanned", scan.instructions.size()); + result.addProperty("instruction_scan_truncated", scan.truncated); + return result; + } + + private JsonArray xrefs(JsonObject params) throws Exception { + requireKeys(params, Set.of("document", "address")); + requireDocument(params); + Address address = requireAddress(params, "address"); + ReferenceIterator references = currentProgram.getReferenceManager().getReferencesTo(address); + Set
sources = new HashSet<>(); + while (references.hasNext()) { + monitor.checkCancelled(); + Reference reference = references.next(); + if (reference.isEntryPointReference()) { + continue; + } + sources.add(reference.getFromAddress()); + if (sources.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Cross-reference set exceeds the 100000-item limit"); + } + } + List
ordered = new ArrayList<>(sources); + ordered.sort(Address::compareTo); + JsonArray result = new JsonArray(); + for (Address source : ordered) { + result.add(canonicalAddress(source)); + } + return result; + } + + private JsonObject analyzeFunction(JsonObject params) throws Exception { + requireKeys( + params, + Set.of( + "procedure", + "include_assembly", + "limit", + "max_pseudocode_chars", + "max_instructions", + "pseudocode_offset", + "assembly_offset", + "collection_offset" + ) + ); + Function function = resolveProcedure(requireString(params, "procedure")); + boolean includeAssembly = requireBoolean(params, "include_assembly"); + int limit = requireBoundedInteger(params, "limit", 1, 500); + int maximumCharacters = requireBoundedInteger( + params, + "max_pseudocode_chars", + 1, + 100_000 + ); + int maximumInstructions = requireBoundedInteger( + params, + "max_instructions", + 1, + 5_000 + ); + int pseudocodeOffset = requireBoundedInteger( + params, + "pseudocode_offset", + 0, + Integer.MAX_VALUE + ); + int assemblyOffset = requireBoundedInteger( + params, + "assembly_offset", + 0, + Integer.MAX_VALUE + ); + JsonObject offsets = requireCollectionOffsets(params); + InstructionScan scan = scanInstructions(function, maximumInstructions); + String pseudocode = decompile(function); + if (pseudocode == null) { + pseudocode = ""; + } + List incomingReferences = collectReferences(scan.instructions, "incoming") + .stream() + .filter(reference -> !function.getBody().contains(reference.getFromAddress())) + .toList(); + List outgoingReferences = collectReferences(scan.instructions, "outgoing"); + JsonArray incoming = referenceEdges(incomingReferences); + JsonArray outgoing = referenceEdges(outgoingReferences); + JsonArray comments = comments(scan.instructions); + JsonArray callers = procedureIdentities(function.getCallingFunctions(monitor)); + JsonArray callees = procedureIdentities(function.getCalledFunctions(monitor)); + JsonArray referencedStrings = referencedStrings(outgoingReferences); + JsonArray referencedNames = referencedNames(outgoingReferences); + JsonArray blocks = basicBlockValues(function); + JsonArray assembly = includeAssembly + ? GSON.toJsonTree(renderAssemblyLines(scan.instructions)).getAsJsonArray() + : new JsonArray(); + + JsonObject procedure = procedureIdentity(function); + procedure.addProperty("signature", function.getPrototypeString(false, true)); + procedure.add("locals", functionLocals(function)); + JsonObject result = new JsonObject(); + result.add("procedure", procedure); + result.add( + "pseudocode", + pseudocodePage(pseudocode, pseudocodeOffset, maximumCharacters) + ); + result.add( + "assembly", + includeAssembly + ? bounded(assembly, assemblyOffset, maximumInstructions, !scan.truncated) + : bounded(assembly, 0, maximumInstructions, true) + ); + result.add( + "comments", + bounded(comments, collectionOffset(offsets, "comments"), limit, !scan.truncated) + ); + result.add("callers", bounded(callers, collectionOffset(offsets, "callers"), limit, true)); + result.add("callees", bounded(callees, collectionOffset(offsets, "callees"), limit, true)); + result.add( + "incoming_references", + bounded( + incoming, + collectionOffset(offsets, "incoming_references"), + limit, + !scan.truncated + ) + ); + result.add( + "outgoing_references", + bounded( + outgoing, + collectionOffset(offsets, "outgoing_references"), + limit, + !scan.truncated + ) + ); + result.add( + "referenced_strings", + bounded( + referencedStrings, + collectionOffset(offsets, "referenced_strings"), + limit, + !scan.truncated + ) + ); + result.add( + "referenced_names", + bounded( + referencedNames, + collectionOffset(offsets, "referenced_names"), + limit, + !scan.truncated + ) + ); + result.add( + "basic_blocks", + bounded(blocks, collectionOffset(offsets, "basic_blocks"), limit, true) + ); + JsonObject instructionScan = new JsonObject(); + instructionScan.addProperty("scanned", scan.instructions.size()); + instructionScan.addProperty("truncated", scan.truncated); + result.add("instruction_scan", instructionScan); + JsonArray limitations = new JsonArray(); + limitations.add( + "Unresolved computed or indirect flows without target addresses are not represented as reference edges." + ); + limitations.add( + "Thunk and external classifications are Ghidra FunctionManager observations; they do not resolve targetless calls." + ); + limitations.add( + "Pseudocode and assembly are Ghidra-specific representations, not original source or Hopper-equivalent text." + ); + limitations.add( + "Synthetic Ghidra entry-point references without actionable memory sources are omitted." + ); + result.add("limitations", limitations); + return result; + } + private JsonElement addressName(JsonObject params) { requireKeys(params, Set.of("document", "address")); requireDocument(params); @@ -530,6 +851,450 @@ public final class ReaGhidraBridge extends HeadlessScript { return matches.get(0); } + private String decompile(Function function) { + if (function.isExternal() || function.getBody().isEmpty()) { + return null; + } + DecompileResults results = decompiler.decompileFunction( + function, + DECOMPILE_TIMEOUT_SECONDS, + monitor + ); + if (results.isTimedOut()) { + throw new RequestFailure( + "decompile_timeout", + "Ghidra decompilation reached its 30-second deadline" + ); + } + if (results.isCancelled()) { + throw new RequestFailure("decompile_cancelled", "Ghidra decompilation was cancelled"); + } + if (!results.decompileCompleted()) { + throw new RequestFailure( + "decompile_failed", + "Ghidra decompilation failed: " + boundedMessage(results.getErrorMessage()) + ); + } + DecompiledFunction value = results.getDecompiledFunction(); + return value == null ? null : value.getC(); + } + + private InstructionScan scanInstructions(Function function, int maximum) throws Exception { + InstructionIterator iterator = currentProgram.getListing().getInstructions( + function.getBody(), + true + ); + List instructions = new ArrayList<>(); + while (iterator.hasNext() && instructions.size() < maximum) { + monitor.checkCancelled(); + instructions.add(iterator.next()); + } + return new InstructionScan(List.copyOf(instructions), iterator.hasNext()); + } + + private static String renderAssembly(List instructions) { + return String.join("\n", renderAssemblyLines(instructions)); + } + + private static List renderAssemblyLines(List instructions) { + List result = new ArrayList<>(); + for (Instruction instruction : instructions) { + StringBuilder line = new StringBuilder(); + line.append(canonicalAddress(instruction.getAddress())); + line.append(": "); + line.append(instruction.getMnemonicString()); + for (int index = 0; index < instruction.getNumOperands(); index += 1) { + line.append(index == 0 ? " " : ", "); + line.append(instruction.getDefaultOperandRepresentation(index)); + } + result.add(line.toString()); + } + return result; + } + + private List collectReferences( + List instructions, + String direction) throws Exception { + TreeMap observed = new TreeMap<>(); + for (Instruction instruction : instructions) { + monitor.checkCancelled(); + if (direction.equals("outgoing")) { + for (Reference reference : currentProgram.getReferenceManager() + .getReferencesFrom(instruction.getAddress())) { + addReference(observed, reference); + } + } + else { + ReferenceIterator iterator = currentProgram.getReferenceManager() + .getReferencesTo(instruction.getAddress()); + while (iterator.hasNext()) { + addReference(observed, iterator.next()); + } + } + } + List result = new ArrayList<>(observed.values()); + result.sort(REFERENCE_ORDER); + return result; + } + + private static void addReference(TreeMap observed, Reference reference) { + if (reference.isEntryPointReference()) { + return; + } + String key = canonicalAddress(reference.getFromAddress()) + "\u0000" + + canonicalAddress(reference.getToAddress()) + "\u0000" + + reference.getReferenceType().getName() + "\u0000" + + reference.getOperandIndex() + "\u0000" + + reference.isPrimary(); + observed.putIfAbsent(key, reference); + if (observed.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Reference set exceeds the 100000-item limit"); + } + } + + private JsonArray referenceEdges(List references) { + JsonArray result = new JsonArray(); + for (Reference reference : references) { + result.add(referenceEdge(reference)); + } + return result; + } + + private JsonObject referenceEdge(Reference reference) { + JsonObject result = new JsonObject(); + result.addProperty("source_address", canonicalAddress(reference.getFromAddress())); + result.addProperty("target_address", canonicalAddress(reference.getToAddress())); + Function source = containingFunction(reference.getFromAddress()); + Function target = containingFunction(reference.getToAddress()); + result.add( + "source_procedure", + source == null ? JsonNull.INSTANCE : procedureIdentity(source) + ); + result.add( + "target_procedure", + target == null ? JsonNull.INSTANCE : procedureIdentity(target) + ); + result.add("kind", referenceKind(reference)); + return result; + } + + private static JsonObject referenceKind(Reference reference) { + RefType type = reference.getReferenceType(); + JsonObject result = new JsonObject(); + result.addProperty("available", true); + result.addProperty("provenance", "ghidra-reference-manager"); + result.addProperty("type", type.getName()); + result.addProperty("flow", type.isFlow()); + result.addProperty("call", type.isCall()); + result.addProperty("jump", type.isJump()); + result.addProperty("data", type.isData()); + result.addProperty("read", type.isRead()); + result.addProperty("write", type.isWrite()); + result.addProperty("indirect", type.isIndirect()); + result.addProperty("computed", type.isComputed()); + result.addProperty("conditional", type.isConditional()); + result.addProperty("terminal", type.isTerminal()); + result.addProperty("primary", reference.isPrimary()); + result.addProperty("operand_index", reference.getOperandIndex()); + result.addProperty("external", reference.isExternalReference()); + return result; + } + + private Function containingFunction(Address address) { + Function result = currentProgram.getFunctionManager().getFunctionAt(address); + if (result == null && address.isMemoryAddress()) { + result = currentProgram.getFunctionManager().getFunctionContaining(address); + } + return result; + } + + private static String procedureName(Function function) { + Symbol symbol = function.getSymbol(); + return symbol == null ? function.getName() : symbol.getName(true); + } + + private static JsonObject functionClassification(Function function) { + JsonObject result = new JsonObject(); + result.addProperty("external", function.isExternal()); + result.addProperty("thunk", function.isThunk()); + Function target = function.isThunk() ? function.getThunkedFunction(false) : null; + if (target == null) { + result.add("thunk_target", JsonNull.INSTANCE); + } + else { + result.addProperty("thunk_target", canonicalAddress(target.getEntryPoint())); + } + result.addProperty("provenance", "ghidra-function-manager"); + return result; + } + + private static JsonArray functionLocals(Function function) { + Variable[] variables = function.getLocalVariables(); + if (variables.length > MAX_FUNCTION_ITEMS) { + throw functionLimit("Local-variable set exceeds the 100000-item limit"); + } + List ordered = new ArrayList<>(List.of(variables)); + ordered.sort( + Comparator.comparing(Variable::getName) + .thenComparing(variable -> variable.getVariableStorage().toString()) + ); + JsonArray result = new JsonArray(); + for (Variable variable : ordered) { + JsonObject item = new JsonObject(); + item.addProperty( + "description", + variable.getDataType().getDisplayName() + " " + variable.getName() + + " @ " + variable.getVariableStorage() + ); + item.addProperty("provenance", "ghidra-function-database"); + result.add(item); + } + return result; + } + + private JsonArray procedureIdentities(Set functions) { + if (functions.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Resolved call set exceeds the 100000-item limit"); + } + List ordered = new ArrayList<>(functions); + ordered.sort(Comparator.comparing(Function::getEntryPoint)); + JsonArray result = new JsonArray(); + for (Function function : ordered) { + result.add(procedureIdentity(function)); + } + return result; + } + + private List basicBlocks(Function function) throws Exception { + BasicBlockModel model = new BasicBlockModel(currentProgram, false); + CodeBlockIterator iterator = model.getCodeBlocksContaining(function.getBody(), monitor); + List result = new ArrayList<>(); + while (iterator.hasNext()) { + monitor.checkCancelled(); + if (result.size() >= MAX_FUNCTION_ITEMS) { + throw functionLimit("Basic-block set exceeds the 100000-item limit"); + } + result.add(iterator.next()); + } + result.sort(Comparator.comparing(CodeBlock::getFirstStartAddress)); + return result; + } + + private JsonArray basicBlockValues(Function function) throws Exception { + JsonArray result = new JsonArray(); + for (CodeBlock block : basicBlocks(function)) { + JsonObject item = new JsonObject(); + item.addProperty("start", canonicalAddress(block.getFirstStartAddress())); + item.addProperty("end", exclusiveAddress(block.getMaxAddress())); + Set
successors = new HashSet<>(); + CodeBlockReferenceIterator destinations = block.getDestinations(monitor); + while (destinations.hasNext()) { + CodeBlockReference destination = destinations.next(); + CodeBlock destinationBlock = destination.getDestinationBlock(); + if (destinationBlock == null) { + continue; + } + Address address = destinationBlock.getFirstStartAddress(); + if ( + !destination.getFlowType().isCall() && + function.getBody().contains(address) + ) { + successors.add(address); + } + } + List
ordered = new ArrayList<>(successors); + ordered.sort(Address::compareTo); + JsonArray values = new JsonArray(); + for (Address address : ordered) { + values.add(canonicalAddress(address)); + } + item.add("successors", values); + result.add(item); + } + return result; + } + + private static JsonArray comments(List instructions) { + TreeMap observed = new TreeMap<>(); + for (Instruction instruction : instructions) { + for (CommentType type : CommentType.values()) { + String text = instruction.getComment(type); + if (text == null || text.isEmpty()) { + continue; + } + String kind = type == CommentType.EOL ? "inline" : "comment"; + JsonObject item = new JsonObject(); + item.addProperty("address", canonicalAddress(instruction.getAddress())); + item.addProperty("kind", kind); + item.addProperty("text", text); + String key = canonicalAddress(instruction.getAddress()) + "\u0000" + + kind + "\u0000" + type.name() + "\u0000" + text; + observed.put(key, item); + if (observed.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Comment set exceeds the 100000-item limit"); + } + } + } + JsonArray result = new JsonArray(); + observed.values().forEach(result::add); + return result; + } + + private JsonArray referencedStrings(List references) { + TreeMap observed = new TreeMap<>(); + for (Reference reference : references) { + Data data = currentProgram.getListing().getDefinedDataContaining( + reference.getToAddress() + ); + if (data == null || !data.hasStringValue()) { + continue; + } + String value = StringDataInstance.getStringDataInstance(data).getStringValue(); + if (value == null) { + continue; + } + JsonObject item = new JsonObject(); + item.addProperty("address", canonicalAddress(data.getAddress())); + item.addProperty("value", value); + item.addProperty("source_address", canonicalAddress(reference.getFromAddress())); + String key = canonicalAddress(data.getAddress()) + "\u0000" + value + "\u0000" + + canonicalAddress(reference.getFromAddress()); + observed.put(key, item); + if (observed.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Referenced-string set exceeds the 100000-item limit"); + } + } + JsonArray result = new JsonArray(); + observed.values().forEach(result::add); + return result; + } + + private JsonArray referencedNames(List references) { + TreeMap observed = new TreeMap<>(); + for (Reference reference : references) { + Symbol symbol = currentProgram.getSymbolTable().getPrimarySymbol( + reference.getToAddress() + ); + if (symbol == null) { + continue; + } + JsonObject item = new JsonObject(); + item.addProperty("address", canonicalAddress(reference.getToAddress())); + item.addProperty("value", symbol.getName(true)); + item.addProperty("source_address", canonicalAddress(reference.getFromAddress())); + String key = canonicalAddress(reference.getToAddress()) + "\u0000" + + symbol.getName(true) + "\u0000" + canonicalAddress(reference.getFromAddress()); + observed.put(key, item); + if (observed.size() > MAX_FUNCTION_ITEMS) { + throw functionLimit("Referenced-name set exceeds the 100000-item limit"); + } + } + JsonArray result = new JsonArray(); + observed.values().forEach(result::add); + return result; + } + + private static JsonObject pseudocodePage(String value, int offset, int limit) { + int total = value.codePointCount(0, value.length()); + int start = Math.min(offset, total); + int returned = Math.min(limit, total - start); + int startIndex = value.offsetByCodePoints(0, start); + int endIndex = value.offsetByCodePoints(startIndex, returned); + int next = start + returned; + JsonObject result = new JsonObject(); + result.addProperty("text", value.substring(startIndex, endIndex)); + result.addProperty("total_chars", total); + result.addProperty("returned_chars", returned); + result.addProperty("truncated", next < total); + if (next < total) { + result.addProperty("next_offset", next); + } + else { + result.add("next_offset", JsonNull.INSTANCE); + } + return result; + } + + private static JsonObject bounded( + JsonArray values, + int offset, + int limit, + boolean complete) { + int start = Math.min(offset, values.size()); + int end = Math.min(values.size(), start + limit); + JsonArray items = new JsonArray(); + for (int index = start; index < end; index += 1) { + items.add(values.get(index).deepCopy()); + } + boolean hasMore = end < values.size(); + JsonObject result = new JsonObject(); + result.add("items", items); + if (complete) { + result.addProperty("total", values.size()); + } + else { + result.add("total", JsonNull.INSTANCE); + } + result.addProperty("returned", items.size()); + result.addProperty("truncated", !complete || hasMore); + if (complete && hasMore) { + result.addProperty("next_offset", end); + } + else { + result.add("next_offset", JsonNull.INSTANCE); + } + return result; + } + + private static JsonObject requireCollectionOffsets(JsonObject params) { + JsonElement value = params.get("collection_offset"); + if (value == null || !value.isJsonObject()) { + throw new RequestFailure("invalid_request", "collection_offset must be an object"); + } + JsonObject result = value.getAsJsonObject(); + requireKeys( + result, + Set.of( + "comments", + "callers", + "callees", + "incoming_references", + "outgoing_references", + "referenced_strings", + "referenced_names", + "basic_blocks" + ) + ); + for (String name : result.keySet()) { + requireBoundedInteger(result, name, 0, Integer.MAX_VALUE); + } + return result; + } + + private static int collectionOffset(JsonObject offsets, String name) { + return requireBoundedInteger(offsets, name, 0, Integer.MAX_VALUE); + } + + private static String exclusiveAddress(Address inclusive) { + Address next = inclusive.next(); + if (next != null && next.getAddressSpace().equals(inclusive.getAddressSpace())) { + return canonicalAddress(next); + } + BigInteger offset = new BigInteger(Long.toUnsignedString(inclusive.getOffset())); + return canonicalOffset(inclusive.getAddressSpace(), offset.add(BigInteger.ONE)); + } + + private static String boundedMessage(String value) { + if (value == null || value.isBlank()) { + return "native decompiler returned no detail"; + } + return truncate(value.replaceAll("[\\r\\n]+", " "), 512).value; + } + + private static RequestFailure functionLimit(String message) { + return new RequestFailure("limit_exceeded", message); + } + private JsonObject page( List inventory, int offset, @@ -600,11 +1365,8 @@ public final class ReaGhidraBridge extends HeadlessScript { 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) - ); + result.addProperty("name", procedureName(function)); + result.add("classification", functionClassification(function)); return result; } @@ -1021,9 +1783,16 @@ public final class ReaGhidraBridge extends HeadlessScript { Comparator.comparing(InventoryItem::address) .thenComparing(InventoryItem::value) .thenComparing(item -> GSON.toJson(item.facts)); + private static final Comparator REFERENCE_ORDER = + Comparator.comparing(Reference::getFromAddress) + .thenComparing(Reference::getToAddress) + .thenComparing(reference -> reference.getReferenceType().getName()) + .thenComparingInt(Reference::getOperandIndex) + .thenComparing(Reference::isPrimary); private record InventoryItem(Address address, String value, JsonObject facts) {} private record FunctionEntry(Function function, InventoryItem item) {} + private record InstructionScan(List instructions, boolean truncated) {} private record TruncatedValue(String value, boolean truncated) {} private record SessionDescriptor( String socketPath, diff --git a/bridge/hopper_bridge.py b/bridge/hopper_bridge.py index 1bc75217a..74070ad59 100644 --- a/bridge/hopper_bridge.py +++ b/bridge/hopper_bridge.py @@ -106,7 +106,11 @@ def _procedure_name(procedure): def _procedure_identity(procedure): - return {"address": _hex(procedure.getEntryPoint()), "name": _procedure_name(procedure)} + return { + "address": _hex(procedure.getEntryPoint()), + "name": _procedure_name(procedure), + "classification": None, + } def _procedure_locals(procedure): @@ -609,7 +613,7 @@ def _analyze_function(document, params): def collection(name, items, scan_limited=False): return _bounded(items, _collection_offset(params, name), limit, None, scan_limited) return { - "procedure": {"address": _hex(procedure.getEntryPoint()), "name": _procedure_name(procedure), "signature": procedure.signatureString(), "locals": _procedure_locals(procedure)}, + "procedure": {"address": _hex(procedure.getEntryPoint()), "name": _procedure_name(procedure), "classification": None, "signature": procedure.signatureString(), "locals": _procedure_locals(procedure)}, "pseudocode": {"text": pseudo_text, "total_chars": len(pseudo), "returned_chars": len(pseudo_text), "truncated": pseudo_next < len(pseudo), "next_offset": pseudo_next if pseudo_next < len(pseudo) else None}, "assembly": _bounded(assembly_lines, assembly_offset, max_instructions), "comments": collection("comments", comments, instruction_scan_truncated), @@ -620,6 +624,12 @@ def _analyze_function(document, params): "referenced_names": collection("referenced_names", referenced_names, instruction_scan_truncated), "basic_blocks": collection("basic_blocks", blocks), "instruction_scan": {"scanned": len(addresses), "truncated": instruction_scan_truncated}, + "limitations": [ + "Hopper's public Python API does not classify reference kinds.", + "Hopper's public Python API does not expose equivalent external or thunk classification in this dossier.", + "Unresolved indirect calls without reported target addresses are not represented as call edges.", + "Pseudocode and assembly are provider-specific representations, not original source.", + ], } @@ -766,7 +776,7 @@ def _dispatch(method, params): if method == "procedure_info": blocks = list(procedure.basicBlockIterator()) length = sum(max(0, block.getEndingAddress() - block.getStartingAddress()) for block in blocks) - return {"name": _procedure_name(procedure), "entrypoint": _hex(procedure.getEntryPoint()), "basicblock_count": procedure.getBasicBlockCount(), "length": length, "signature": procedure.signatureString(), "locals": _procedure_locals(procedure)} + return {"name": _procedure_name(procedure), "entrypoint": _hex(procedure.getEntryPoint()), "basicblock_count": procedure.getBasicBlockCount(), "length": length, "signature": procedure.signatureString(), "locals": _procedure_locals(procedure), "classification": None} if method == "set_address_name": address = _address(document, params.get("address")) result = document.setNameAtAddress(address, params["name"]) diff --git a/docs/adr/0001-provider-selection-and-analysis-profiles.md b/docs/adr/0001-provider-selection-and-analysis-profiles.md index 37cba24cf..f542eea18 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, - the private headless-session foundation, and ten read-only inventory - capabilities are implemented. Function-analysis capabilities remain gated on - operation-level conformance work. + the private headless-session foundation, ten read-only inventory capabilities, + and eight function-analysis capabilities are implemented with real + cross-format conformance. ## Context @@ -538,7 +538,7 @@ into false certainty. ## Implementation progress -The first five implementation stages are shipped: +The first six implementation stages are shipped: 1. Provider-specific target state was replaced by generic profile and snapshot v2 commitments while preserving Hopper execution behavior. @@ -551,9 +551,13 @@ The first five implementation stages are shipped: address/name resolution, containing-procedure resolution, and bounded search were admitted with exact wire schemas and real debug/stripped ELF conformance. +6. Function metadata, persistent bounded decompilation, assembly, resolved + callers/callees, typed references, xrefs, CFG, and complete function dossiers + were admitted. A bounded per-Program queue serializes API access, and real + conformance covers x86-64 and AArch64 ELF, PE, Mach-O, stripped symbols, + targetless indirect calls, cancellation, deadlines, and cleanup. -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. +Future stages may deepen format and indirect-flow coverage, but must continue +to compare normalized semantics rather than provider-specific pseudocode or +assembly text. 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 adb732fe1..097fc3049 100644 --- a/docs/api/assets/hierarchy.js +++ b/docs/api/assets/hierarchy.js @@ -1 +1 @@ -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 +window.hierarchyData = "eJylmd9vozgQx/8Xnr0cGP+AvHWj3m6l1bVqd9WHUxQ54KZWCeYMaVWt9n8/GZrW1KYY+pIWxHfmw3g8toffgZKybYLVvwhhCGAWJ6n+TSmACCMEEhqlCUBJou/jKMUgjmiCAMQYYRBjSugGBIrflTxvhayaYPU70Lb034odeLAKzipWPjeiOVdKqgAED6IqglUMUxAcVRmsgrxkTcObvwp5YKLacv1cEw5k4X17KAPQPxqsgrYpvmg7X/obIMjvRVkoXnWvQhBAiBKAUJoChLIMIBxDgDAkAOFE/5AIIKwfwVkMEIkQQASmABEUAUQwBIgQDBChKUAUI4AoIQBRqv/T9mgSZ5s/INDOjHf9Luuaq5lvaohmvSdJM4BIRxNRgCiMNJcmRLhno8QxDldKtjKX5cLxGMgneDuINHVAXFT1sV1I8Kb1cZ9lDveXx3a5f0PsAYBj12RYs5rtRCna518Ve2SiZLuSL+QZt+WDB105smZVzsuSF4uRTL0PRuLC+CkOXC4eJ1Ptg0AiA+FKyUdRcHXDX0rbTAi33gdjMGlPZs4KVrezK4tL7YOQxQbCVyWfGq4udw1Xj2xBKEYMeICQyCyuZ6oVdyxvL2uulnC49T4Y0Cxh5zqkVc4vqpbvlWifZ2K49T4YKHJg/BAHMXeG2Fof94NV/WTibzG7bllSH+cEG84vqkfetGLfjeKtVA9NzfK5GB8Y8QGiZk78qh4q+VRd871oWjU3I1xqH4Q0s7YeyyqmrfVxn9nul64bLrUHAo2ohbBwe+MQ+wDAyAK45gfZzk1GS+rjPLG3nldK5ryZu9e2tT7uEbbc37RMLUu+N6WPa2y++VpWd2J/XLQm2Fof98Rcov+RX0XF1PNlzed6t6Q+zqn57r3+J1N7PjfultTH+WDOX3F1EE0jZHXN/zsKNXvajxiYBulOoU6Sm1zW/JUAYnIiEFXL1R3L3yDqV9GVLEX+HL6zMorxamp4IIsjiqA+IGO46RkRHI0Wb9pPU77Y8eDscbAb55ti1edhOiueKLpvYKDc8p1ejKtWqudr3sij0ruj+ugJ9WTIw1Fbs0cT0zTa9LSpWeVvWn2+uuW7k/kFlJYNv8BBhBM62JqLYs9/sGOV309Q3HdVdmsquArNS28EhEYQuPo0BB+f/CPjBBHG6aYnw6m1Ip3VdSnyrrxbkI765CYcNTVdqSAiqXOT0h3MPFCGgvDd5bR/HA0OlN/uRaGYV8rsu0e3poKr0Lz0TBndOBxBmEyZaYgFKYPjKO5SRv9jkX3nrCh50/jky0d47+34DFYMM4vHJ1kGHK/Z8e7Swz8ebOpOypedoVfW1P2z23fa0GlrwWRPKOhyuh8/Qs3SvC7ql2aDT8x2/aNbWxU6bk0HL40HlXFd1Oe696NkNZPmvSx03Zvm0d18V+/z1P64kmpqhWVvJW9rNIB7AqfB2SOaxfo7A8IJ2vTQgyC+NhRLwSc3KV60vSXPyqU/hbhb6MPx/ATP5ICOBA5FJNYfa2AC+8DBxNVoPplfs6oQBWundiuzmF+NLqjAMAPd2qjhk5gS+1Rzw7uN5UeTxqQdiMLh1eRk6RJwjGDmRLG0oX1nZry6AHWR0h/kPmzOzoV1GnD0bBdNbl2fu09ROlkHR/ZDLRvRcp/KaOJawtC+M32M1d8zzV7mS21dHsURC+HY/blx1EvLpu/5xNlwgdaL6ZrV7VFN95xMZIc0dN2biOafP/8DdORXWQ==" \ No newline at end of file diff --git a/docs/api/assets/navigation.js b/docs/api/assets/navigation.js index e2e251c55..aff74f0d0 100644 --- a/docs/api/assets/navigation.js +++ b/docs/api/assets/navigation.js @@ -1 +1 @@ -window.navigationData = "eJy1fWuT2zp27X+xv07lJpPJ3Hvnm6xW2zrTLSmS2s6pVErFJtFqxBTJ8NG2z63891skSIoA9gtU55vd2mstYGPjSTz+/f99qNXP+sPfPkRFkeo4qnWeffjTh/hVp0mpsg9/+/fRYvGcl3X0nKpdmV90pT786UMR1a8f/vbhkidNqqr/NeE4udb/8Fpf0g9/+vBdZ8mHv/0Zkfi03R9Xd1fmt6jULQnD3eNsjX/+83//aWT+Een6Pi9H5FXipcnilpWRcAlsrb/+5b//Y6K2yKL0V6WrXZm/6USVjKsca5mretAy1SqrrwI6q1X5EsWcho13JP/lr0BmVj9V3PTxMVNspJDobQtVdny7vLwhgxaNRHdX5i86VXtV5emN+fWoZulviy4+3zEZPaMwNU4Iz1CHwppUW0ZZopOoVrfLjlSU/hiYs33tMlBqA2idqKzW9a9wNZdB4ltT0++juM7LiWT9qwhrK3oGR/If/+///qd/+TNVjWdJjmhObhkV0bNOdf3rTlVxqYs6L4MUIQJOdAAv3iKd9uggUYhAKnqMyrOqD01RWO1jgKrFwMnGpYpqRXQGSEfqiiM8Qf3p6i1KGyeoJD3rFRfUx3pNCaQvrLqTJAjoqXqtjJUStJ2yopnIstxBxbVXZ13V00ZHUlgDalZR+ZJxGlWVVFKWln/68/8hcv1JZ4nOzsERgiaiJ5zVjx7qqG7CuzU0LQ5xSJoOKlXxrLqDpmak9NMBxeUhi4rqNa+XUfzKTWMgSFBEImJUONpigiTYgeiYiqY7oAZAJKr3A+pep6oK828HEfm3VFHiokOzadQgJi+fk6lkqa8N423KIBXt4rLWL1Fcr37WZRQLekDPXha8HmydFY1gFubLIVRkz2ZMByTrW1/UYRC59HMZFa/LPKvqsgnwrAcTOfix6VYRtnHclKXKYsFEB9XzuCjfdu2Ofvk10C3zrLYWEGgf++oIIVGBXMSuFX43/ZaNEjfDzyFkkvO0hQrW9snE0ps84ZtloXLLxQpDsTZPFos0QHSf5++S04GHEEz0WVX1MsryTMdROl/RISIkdZaon1dvVJ9+3RbLMB+RgEtUq1JHqf5D3elSdRPz1k03xDRKSSQjU1GpqnoXlTc1JRYNIVdEZ7V9ma9j8IRAqb6rX5NymC/lMlGieV5fLe+nyxfBqi4VIVvn26YumvpBX3R9Q05tHlGPu87eVGavRlE97WgeNIRZZ7U6l7r+tctTHQvW2jw1hImc87gk/jhxhrzDJUnAJqr1m3rMm6y+Of8eF5UAPcBDR3FXXY+CbhJ0NukRgdCSyqJUhHwVR9k7SIM0jOzYT72TPs5H1+mmfs1L/YdKQms3DhTV885nEnHECYQ8Q03645POovLXQVUVO5OwTEV5RsihNQWbnJCy1xAsQ/sDnCwLH5+7P1XmT/0StVH6yz/937/88z8S7grUAz7sCdwm+qro63DKzpLTp7zJEpX8VuWZYDXEtRYvhEyAXMB7Gg6eW/noTY/tn0KlXAK6BpX5j6pdldaJPWkBPWcbixxnZhaoDJInRwgkkeRr+1yp8g34wE1kz8HIgp6RwyIfVhQlxK0DHuagyjctLFIfJsp21K6q/aG+qedPTZbwK6C4mstEzXmjom7K1vQQl0plkpVBXBhio8TzSxF15ksDDAxpKAUYpSgZ11S/Z0p8VnJNoIrzN1V+U8+PcXHM85Sd4eBpAMjItYGqUHH9TT3vovMNObd5CMFUV3VPYz7s3pBVn4sQzjt8VzbuiCRU16MiW9LrJ3vhWBMAiBqTtqynn+j3KqroDQ2QEszCfXd/bnSakDmFnQylAOOivdzt+ljm2Ys+28tboIsda+EQpsrTNzXFHssoq8xqvmRNzZPlKQWZ7j84mhB1vqDimfdRIifwkkhXjaoKk2PN29vRIIbjF8JQRZqWLor8comy5PCqL3tVpBFXx11zmfNxEczrng6nbPm5qqOyJlQR/3oSMA/n0CKvdK1k21M9c6lDMRFomuqLMLL2dDV2jf2tdahDHRWUivFp28I0pUraLxVcM2EbyyYrw7KM/kOhYlgebTmCis5jmVfVV1VW3TdcWYcLQUT5Ha2HUV47+hG0haAgTEZVT5fiEEfivaFwGghGQUKGNd8b1Uea0LxnitxNKc9y5rUf/s7Rp+P2cXFcL0/7p83pYf24Pi6O6+2GOxYAJwJjIw4LmDk9F4FIZQMTQTFSn4SarPucEjmBFyJtczCLyQ5az80vzCUTv12SEqq76Yzg6xqsMsKDWsqq1mfBdlUUJutxMbT84AaeAJ6calFQ9Lap4/zCb36ZkbCemhzrNpmgpGThcU0RxTovamRLoCw8YFH0upmnXXbRFZSGQL84K6a4ArunZPkaZWeVfFKv0ZvOxSu30pQh9POKTjRjocHi4XaqapWQ6qG16zqxQcnJOU63LVeWtMAyG2Y/rAJZbHfqRZWlStqvE8OHPkE7jcJERTVFf+s2gMLKSGHh4jQxVVDR8JHzvjsmFiXfdP060HVUXEHhqeK5iQo/gtvZyU6VFy1aYBSkxiako6TbBjVs02VCw7KVLX41GaaA5M7W8PD0gHI8cjRbzWWg9fqFXHctSypmweliymPrzBdYPJ2NrJp2pstXFX/n66ShnUCo2mbMvuQV/xXOIm4RPO94QiM85RZUrrQ2XyhEjRckd8VTmodfVa0uV09IZ+O9JAJnhoduTCFRayRGe2qe4yRDSO3CyIqwavvEUjpsdK0DRom4EJwZTwqmEWUu6PM5AhJllRVE4g7TlKXF+YQOgETf0HGcKO/9t8eBRfIhk1AE2JjPmYOp8HsmoQ2w0WGWvUZZrBLnkzHo46mpLKRgcmhd3CYnpNr1cCsDfWUyexb6DwRcTkCMrEEw3+dthqqnYMsN1iU5ichRP9vtZiDpzJQQjNQOgMt7p4NgpKPZQgg2ogEA8V40GxuW0+uONPvv3Ka02zUBGpFLH1Ry5r6g2bayJgKhB9sIm55Ss7+a2ZbuAQCsX6PUoM3/bl/W+bsbz/ib4iHv+fYiDw7Ge1U1Kd9dAyo2A7nQMVhKPscBShaeDLvX/KKeS/WDdtlgJXJUUebP6ovHCyd+ZLZQZJKtRZlhzM+0PzBGdu5jf1zfL5bH03L7uFvs14ft5rTbb7+u71Z77gsSIktREp+RRtjn/WL35d0SYbMR+p+eNncPq3f0A05IpGK5eHg47RbHmx3gE1GqXxabz6u706fVl8XX9XZ/szjGR6Th/mmzbL80vmMJUJRESvarxenbdv/3+4ftt1uTAHKR2svt5nDcP5mE36wOshH6h+Pw8fe4flzdqo+wEfo/8vL7S5r/cC7j4hpaRB9hkzfA3/Lye1VEsTrUecnMHgmgeDQIcwTl3lHGWblR4vunhaAli+RBZ83PL3lRcEPHiaHI5Z39XbvBTj/LvvlOFTw0NeiZAO/yH1maR0m4mI0Xyq2zqo7SVLSCiihOKMJE3eGkvxeGVgQHk94WmAnuIWqy+FWV7gK6WNgmECnvovh7dFb30UWn5IVmnqSF5LS0cQlYGeC6ONXz0eRq0mjVn+Ayt54pdio+5cdZZNJDUUh2NCO6UwpOtC+MxyiLzqr014CEwjANJ354jUqVPOjnMmr3/vQb3/mOz5PHiIgEFFFZKaIp5JVhBupLl4qSmxRBAroTyfPiOYq/S/YY2LayrgShxxpaW4EU9HdCY2KI32xygIF03GMUS/re0UzkrtE6pHe6SkBwymuuPd8v4VqyPqlvbwHnwYV01XORZOFcP8r3X+5rJrQBgKjASCFonQ0SYsXtFberedt+r8oyZ9b2aM2RhNwbP9nufYUulU51dmZ7AygBNCN5PhIC7tV/NYr/FCpPSU/IbiQjIyAgERiZMM6HPfiCnUcISBTv7QD7ut3/przb4iwx7Ycyj1VV9QdMpXUeBon80Fayst60lxpmsUpTfgiIqflM1FamznivorSttXKnk9oeXYCrr+cAQ3x9RckaWVbS76hQQWFKvJ6rW6vmUyIpgIkoyRpQDk4vwBcB0OKLvC/pbgAhVtzubgrHI7PqmFFBqAJ8+6BfVPwrTpmFLgQU4uNdqYrINIiikR8mCdORmzfbpymObaubRenqp+Y7UkTaIyJas+EkccvgDj3DVH0mcgDR2Q2JvC+jC39EBVMGydhBw77JHqNMv0hGLJiwS0SI9ifiD6quU3URXK+HiXpE1Py5iz6ncZsrDJKRM+lURdVg3z5a0ZSCO/gweYSOTEB3dPyKuCG6IS5R+9VuwSxynXFnSX37oJ4BkqE6hokMp+zMQvprWq9fv1cvLyrmP5cDMiiXyLOplnk01UGeTHXXaZlLEMXNf6r/ASSgGvy+3epxh1hlUanze8FHpYkqTkK1gGZHVg8atn44+4l4aZyFbJPy/1Rx7XgrQBYmkISMbCOtYywLnv12uTocxF8lXQ0Xzx5qdYZZwo27rizFJXHol6jMVCVr2Xpb2S5EMKiFuRuEYBI6MiXTC2EeP3Z0/dC3T0s8pTMpGC7Ru31W4YpPdFVPYksCBbrJy0u7CCNZwgAQosLNesRYMlF76kva8Nh6CBdRyC5Ccv+dSBq8B286GEmirtGq8zhPV+055HlZhogkdbVzjfWOCVGqg7H8W/Wy/yFk0jSqeAxUt6mrdaZrc7N1sqt/tZvthJ4cBSEOyUehIY2heh4BdbSk/QpixbO0dxzlAAouRM5lN67tvoLy7Y1lLR1eIRJ4jNgqjKz7Mltn+1SIHp9DtQye/OqlU5XVeO7Q/t8WhGkkwwBEFw0UWwCm4YKlG3+N68OCHUgwRho4AFS2BgZpEnzkFx8m1+Dyp1yfW/psGxAuCWiRQ3o4IdkOvuXflQf7XEai9Qw4HTgltw/sXR1CMJLVoV26N59DF91Svn2YEaoMEEJUFV50WZlmPWm/ISRJaQ2+4eyCaiATWfD/1ejRcFGW/Ld9UBfg4VXbjRQ6i2tz3utLVL3yo0VKHeLjU3Hf69zlVaX5lpZKgEPFa+8q1SR5LHh/hZK9sjAB/aK69yYO3Qrb+lKw5zJBiOxkYmfq4PlMQnIglWQm8EVX7b1GcZQazK7dM3Qf6bQpJYEGpUXGTSQOpBXMBfGS+FgOP5mVU+MueGbIpMM7sv0eKclHUnyWCnslq+0LrsSp6ZGyYUhbcIlD40kj40tSnWKmRp7d1jYuQQFBO0gSvPyyHoD71Yf7bYli6cPbNPchFXHcgK+mYKPX7qOJW7xuoxoSN706yUzGjQEyKQoooz5BFG944Rzb8fSMsulwoqKRNLEh5WKUcVaqTGTN7DulRnBlxt3qfvH0cDztV/er/WqzXJ0O26f9cnVaf95s96v2+NZxtd8cuHkukTSpBDEHRim62yH/RxJnmIk07Rb7w2rx6WEFYBebz0+Lz6tbEiahJ1IHN6Ng6Ac0ACZpLHdII/A1rhZJVLBrUShsThPwNa7W2UtOTepxPZhLMq/3kYGlMEkFzEd6vmyyWl+YBZzeSPb1xjylAr9tBGdooAegZNqH93uGh6Xzho0YECLKFyMGrUHBYoIk2ItPEIDtFuTafk9g+7huCs6ndVMIfVg3xUJ2yZRhnSCoHqszE318mNBynxo6I2k3POEV9LCdnfBOgwkzf4fB9KWEfmcvf6bAKKBQrhXr4B2uvDifDjEtDyLSGMJ2lb3pMs/sfVSkFIDkFONhL3T78JXxDdeOGUEASG7G6K2P+SWdJXMFEjKJqtsrNjsztoMxAhaEWqVqr/ezGgmKdbCmPoGZazX8Kk3xOiDJ8YXDd52mG6WSqj9BI23mPo4UVUuRtRR6pMAWU3qLpSUvluzRtjKhZmqYE0+MRtX+Mx4wJDN5akki89oR9LkqBwJ88WeSH2ZiOLWUjViGmnTXRbxKQqrJIISRMAOYuil6J3rrJGjebIAoi1Zx9UD++SNIDWcSNeE9YmktZsuUXbxIL/B0Hao746RdRRUuEVGOPEDDx9QujZgNPKOZKH4qn5TIQUdbwQJQaqUtYWcn3ELGt/FEBowQTkL0Lkwrz4qCeNqFw+l1WevoWMvH7W5ngg1XXYEJmBwSP+122/1xdXdaPqxXm+PpbnW/3qzbC2LYJRNfkyAjFkgq1JVIubm6LgFZcMORhb3KElVyM1fXWlRwuAQ0X/UkaE33ssqnTEvGUaOZKAejdbuz2Fz/y4bgVQFAUzE4moumkoAMN6UcDdcz87GW5kA4uQQk+Elm2WRAWcNV5CowRbGjf6QkOA0ATFbBp+x7lv8Q3rHsGMvCd/P3zfbb5rRffV4fjvvfxXvEXTGUiGjOGpvjQWff2SbN1YU4iNLrzR8b81KRdGs6ourS0GVZnMso4crQGInKblNc+v7eWdXA6lLP7eComuSYypodWIZtegwsSGKCEVC7h2b84bXDCx6S8cbRvTE/eHfYZaN0s8qBFjUSrr0SCKaXSrwopRWuCL7JhAqYZveAQAWbVrFn8+TvB+T1mqTo3wTGn6TsGU6+rahKUhLDiIaQ4FTtdffl3e70ab/9dlhdL4o8re9Wm+P6+DvUflPKFJfXhFuPEiXFcBylfyAHPnQzEQfspd4lpQAPQ1KSFLhjxyvmLo+bCzyP8XVHY1n+DCgZjo+6jQnF72LZ5eP+qoe43YWv8UsKKE2Ig1zY7PGXmUJ3+YWnx09rCxT409njEXL8vLBAR3JA+BLprEvPUwmOYimZKZYclFzB7qEfPKihUz1sjXXp8bra09N6TkvYB/8hLnUBDx9wHQtLf2y8gtud19Y7Fbi7etOQo4UeO1XqA39MyKGl/jVKG2gnky9jLIVz4m50vFdxXiZ8I9YzWyiu+YrSNP+hkkPUHpT6QyXiOtKLAXiiKj7nTZaoBDuNh6pMcOS3rzT61b5X1t89gg7xUB2QgVoErL7UdRHqsxFFbVtuLs+q7ABB3BMcueG8jY0qnH4KZPnn0vPs3Ub3xK0XIoEplBpqm52nP+O0SeDrcFANG8pq4DdWMArs9SvtxZTZObwUJji29cuzzH1MDGr6RjNxbwcQQ13dlZiQcTq5pOi6LLZ7s7g7CNurDY8WQY+sAX7xzWXHKYz5hAB764nWgnm4Mh9tJZM/11ha/rgIEAWeCCvsTwBXD6vlcT+5pF46A/TFSTZuDrjKku7eFNqrvZHYm739na7i/E2V8P2wkAAEJvclXe3Nwas5SgbJyHxTz4c8/q5q32PeAGkq4uHYGV5SmASNSK6mDcQ+khq99O4FY4DWAaCE0GtULWdnCQRzLYb1wpuzUxSIbt9cFOf9lVnLpCC2o9IyHgWbs24LYJR6D4VB2bJtZXkaMG13hL5FRoj4BFyW2i7Au0MMyM7ELmhRxu6q4EZhyj3FUU3CcBEM3xNO2ScozjGH6EU9qjpKojoiPTM1lO26iF7a0VyRZxWgAObB0oDwbG7iUqkMfs9rqjOahcy7EX44J1cFCM3lwzRFkmbFspT2nAg9HLa2AiNpB2+aVwqXAx1nk4MMRC+QFyq7SRAi4Arrm3p+jAtgFAIUl2MrKrChIzRYJjuugA0mszKM+brdBnFeEC2lZyrKyPjweTLFUxnydWAOyYbZwR59IA8XhTlIZ+6y81ddNVF6p19ecEdaZsL9nubmuux8bU7I7NgSIJzZ5JZVutZvql2oYvtQyFqUr341zMJT2QKFIBJyzaW9j+o2SYCDdGc3vmxXOh6j4l7V7TsquDcBY5EzpzjvanugmYd0AA6qsX9pYVMMGZSQoM/AfNCNoWs0Y+Gdmea4lnUT5zWZLcloQBan2TkNJKP7uygli8IcJjmDRdQTjUZUGXTH312uSa4MwcSKy1pdRuZ6VLA5L2v9EsX1smtSdJVnq5/dhV2gNwzVCQXJXAW8grn6t8Xj7mEFLWhIZAlKclVjYGzfwV5OPMXm3ALIcj1BbqKL9+WX03Dx3NrA6JLjdvtwWm43x/1iCZ9JZqVhKmLb18Cz+tlR6HZtr2jqQ/yqLtGcJJCEgoS0T+tldV7+eqd0QHxkpPVtpjjQIHtRnA1bPEKKHRSDichMqn5kJc4lCBBlc1zGDMknLIdQ0TnNXtvvcElX/HQWLUtZ3noI31Q45C6QayMsuAniivGgLQgRELVROemT1ENE0aagy6o9++/lDiipiZ1sKtS/ndpdLtAetRTlZ6qCMFAN2hTR3xanb1V2eUh3DkORoBEDChI5GnqtWDRiwGUJSjL3evpGa09GRhUImJ/r9pPNZslkG9ak+IiIW2++rg7H9edFh+19xDS0cAJgJkJ6uJV8udgdn/btlSPTR5vnJIFmDEpKf/vJ+6SiJ5Mk4H2CgaAj4z+LugmytIMHzGUb30cc3QFC/DaW6wM3i+P66ypoGAGKQjSkJ+1HiQRtKAiQDSged8fuuIYVdaIWFBYlCblcX4paFDuOqSinuw6zKM/dLskBi83JESGYhJqz7yyGWXIhMt2WZp1nf9eZt/mO15miudqx228fd0dpxfAUHTTRvJXd+b7PjU5UYhKKLH4gUj6eXBYp+i0Rh25KAH6fsbRsY9mEvx9h7Sz09IYroMAcHYyDLbbhdh3Vj+ug0+6UMEjA7th0UrtOJMNSXxzjEQyLXUe9TwJsNrqTNntq9qvfVsNg644bLQHuR3jIprUyX7rGN6P4uSmMkK28th/1zD1Z4iUVRA6mIrzcft97H2mQiXRyPen1JcN/yF7k4G4k0feop+3X1X6/ZgMJFIOJxJkU506Wre3Li451lPJDO5vbxXFt0fP0CjdxmNiaGAcRmqvNl8VmuboLGk/aqggFIbq9v18v14uHG0QRCkL0sDoc1oHrb7YmzEBIzpeSS+R5usiy3Bz6DYz9j+2fIgttJPwbjKaThxki8RVKKQgmFYiAGpE2P9ZKILflwjryK3LR4gAH1r6Gg6fG1nCJBOhIBvBgoQRowJM+T4KeF8DU+GzALXNzZlqwoOoZy1ZV+08siAxW2W0hkESwMn2TKEhCiJp1hJskAQpq4NR3ojdJgiSEaD/0ukkT4iAnk91Zmqk5PZv0FQEKckLZXxcRMjREIKJKMtzFMfRpwnVZTBKlA4aJ01wneXsMFdtacJ1FvWioFzLok2MXOrluMe0GYl1Dt3EiGiieG1cay7pbZOgnpyqrgYfoEWEUHzC5fun2tGGjWUQYxBN1KHYTGqyIMMhm8S1DtfqvJkqhmivLo8FT2wq73UELLE5ZPRBPNhMDwyGLCniHsyM1GAbVCp8djMmR28Wxe0sc+086S6yXHcPkenioavf4xlzNDhyq6J4bCpMEzw6h9XxAiavdqAszCKrdvzaq/LUGz3FwWj1UXNeQMuQFCRpCvNsth9cOXhYkIAQrVZrHPW8RRUkoYaxKCuSo6giKjE9u52UXAHPUXA6B7GPU7jWtbsiizSCXlHcRmCTWSaCSbpsTrAg1O6DgfCVEAtpped2JgXd9nmnQBssrDL6vC1fBGNgm28MxC454EkgqwT5HN+nvk4YpFz1kbI8lDG4E947jsi5aFE6fy6h4ZSOpswoNIvtIIxg7htfBsIOKYStrcvZWv0n+FiAmH/fJiiqBI+SApaIdy2OU6RfrqIJA0UJK5cY9uDOy6GClkhvgMyqpsxF8Nh1st3HclKV9V6VA4grjhNZZrc6lrn+Z+X+inS/fhBgMlTaMbkCJWyUjTtOE7P6+SR5kER0vGJH4La+OsocQtV4j6oDcbsCqTBnYQypeZaLuWmWlaUqyNzAf6tzxi+PaqZFsJz3I6nvTIv6Eq1gONHaLMn7V7QWejf+UN84+RXFVsPMqnBOvbCwpD8hNr1Y/VdzUbT36oqIEfqAYFXLBdHGb4wr0ZZSDlG8rK3xKwy4gQAFAcwXVQ+7K9pmHpLvTB/qMw4u6DDOEZ2TVggslu4uoKrwLIuRGaKgU/ORIgKDspZEedXA3l0nlDuBGM3+Xg8/Adm6QKspDjfbb2470yy+ypvhVH1AnmCTtwOS2FK4ZmJiGtAKmpXrQ6KgWoPeg/Oisu/Lqm3pur/zopn1yNQDM6bVpshJZBWoiBJzueCFjj7XuKOQ0ATCnN/rEv/eMU/Ogwvq4MFdPbkt91pm4Rk6VCSKiSvao4UqkG4RtCl7SpPAGwSkBL3etVTdIuiSErPar1xxhlIaQTuFaNkeepCKS8MOtBnPEERLK6dWDrlUZpQ95XjxH8ff2evjM2jOIdS+W0zEaakm0b2agJkqi6eMlHRl6VZAtFHJPkEmUai9kmGxjpFvAgR/GCppb6lI1ShCEcno5mEpphDrXq4EsdM3wUxyqTZCQqwvPTZZ0Wxe4BXXXUDb0cUDkIpunAKPZ7tNBCYvSFSdoqK4FTPLt6mGL58Zx5AjaFbSRZEMTR2m6a3mxUBkMRCGy7I2pNmUktIzZXTa9MRl0HrUsyOJpQtjiHUUAGFWaVpLCVYRB89zoNFl6herFzMhvAehQeY2ys0o+qdfoTefA9UYDtW0nCxwbQ5eyww9i2TK3QcKid5RxEioQoOTeKi2MjhedJUusGP0YcTQBNBkww+Uakuk4YCsKnOll0OyEDhKBCbjwGVDsOgAlGbwSYKcVb2IhUYxCsihgJ5hcFYCkMQpOWk1u7Ouu5mNrCaSOsFBbv8GQuEk8cKKjvAi5ST18XuuFySx9moyZ4kIRMysVNBk5oO4uSME/JZifgzZi9o91qKS7ZuXKPNwUbzPDKFvQvh7+iigi8zjTUxa9RTpt3RSoiTFI9IOkxKxduQVRXxESfrO5P0hgApEo7Mq8zuM8DdKwQBKVo76oPDAjUwypMewyKFRpbhARqYAoSmf6pVEk4QFIdm+JRqYBwyglcyVjE+ArH0Hxj9sltbCCewAJ+7jdI0jCRkl0HvRFy4rbR1D8X9qPkWVY6wtheI0AaiHjzty4EkA8RYj45W0SAOEV9uqS17Lo9AA8+6GOSlnMuPY8d0hL6iMo/vX0FqZvefm9KqJY5iMCSiluctNEbgsla4g8AMW+a99lr8wHcfNwlUgDgZFK/emhRRIVtbDCQRiJxngDR5CKjaJ0xgfwzrqqS1nrCmHEY7LrzX7UDiZogHZFUtuYIEebhz7gw9p8MfVoiajt93BZEB8kPF6PM0d1BFOSVpkcI+yMFVSCx4g9UuUPcMYRGy1EADlN027e6eic5VWt4/YIOi0GITgVz9v3kU67Z1mJ/T9YSVlYdsedqTjI1Mhbdus1IRTxgfL12rU1RZ88ycT1owFWBvgyAo2Ef4vEF0DHvksqUCs2YFvPmoRzW2RVyI7YYdgILkoCVXXgBnBULR3M/TfhBBrIA3SgwKF5bsOE35TqqVhIiRRWR1xidvF0GLnnMdmwuLyDPbtu2NuvsjeV5gV/MnpUgpHUQp2TtHApGymQMs+BhgtNcQKZcAGWupCeGx+pC+k5cXMIVLDbfKS2EexW5gBmC0B/IOmNzIdatn0zZkGtXDvH3+WpjuFXFGEBHyxpHdxMgHXZUQBzhNZnYy2Onp4cQosjyc0UWuq9GIQmYstG3+cluyOfzNxIIA3n0OwBYGrP1HBaea4cQkDWKf+Cb7Re+aaiutXvrrgfEk/kB1Bw0YT/fDT4EUSWq4/D3+Px77q78nBgwwZ8Ph/8yXp2MsqODkkHXbSbvLy0AUJ/W2Zw0kJ/1plato+uIa82CtUcJqL82+tSVFZDM/Y5qjaXIO664+I3aFo8hJ7uL7x5l4z6ZJRytWjqfEPvIGUVRxJCKeshavlC3U/AaU1pqEbeZP4GoZ6B0CjViyr72crtxQawUT1LXtbwS/dCOUNAKXTvyi+ypC3Xd8khwhjYmZm2F/8kjSJErdydvrQv3g0gZ6OHP3DE1SAmahQ5vsX4WxXo5UHRYiBKNrFTNkvL4SDUulY+TQ91VDdhI4VBy2KgIra5XKL2Cc1ZKiOaUGjarjpP31Qylu4sLYAnsBagV02i2iH3TY6pgq4jZhUsNDe1uUecFKyKEUkTAJRooDJSlr6kcFjrzevwJJCM1HZI4dD2pqSI7wYYoHd5VWlVsjcDIPaiEL+GS+o9d4A3866Sz0I18YO1f/FVuCJyL51/I8EAECzgYJogD9lgBa3FQ8aiMuRX4q0aDOpgHFwdpnPouRbOI5tx0K1fo7SBrlG1pIyRbGdekpSqqlRit/Z+TFrMFor8XDcY7qxpo5R+500RbfqDOrfzukPXfZOLfBa/DZPU2r5WkMHVkzsQaX/Qm7ONr6UFgokmPzKOvdNVHdHNgSXjwLj1NaTQaQ0fycnc5XH3IBE1sPQlRhRHjxa9QISMAV+q3Zu8zJuMGo77IiOKo28raZiTOgRH222zSpoykPsK4wT2Ko1qlQxBESbjgjmxvk0IExlAZMOtwf1KaBMOm8vOEZV5VX1VpTmwOaGhziwgejQXf2Rjgtg32Lga0XbRoWre1pc5ovD+F1abvBNXKC27GRfeB3eDMhZs/vExMjbYLgxJi4SVPLthO3FuMmCeEGEzrHg3/SmdNBkj3bukwmFjvx+68ezfCe+1rWhMUHzU1wMfCFSRG5KBVBYgEQ/qHMW/3tsnNCvX272XYwgycvH8Tb9fGig2yffZ90oHQ0iOEf6zah9ju2hibftqIhoL/AYw+tOiCelvGL81IdJVa/dN16/ao/ccNWH3caw/Dq9RgQ+TRguxNzprmUsMsQOi3PKbn16r+wVIuU52hLBN+JXcwZC9xYsqgVSDZWjIbQhbfN04mSy+zkJcfA6f517D9hvCC7p3220BFPnXcLogwsEjKJB+giHXS81LR9Chb8fTrqHI4b35QZ+ziLiM0+N2cVwpmLep+5ui19kbvSfSk0PgnGqiLlF2TtXhh37hi99TBeBkTeuAj1H8modr+WheapdKjkxjUhM0LzUW9Gw5h4GQbNM1veqVPxDvaSIUZEUrxiM67lZCp6K5hqKKdj0A9LmMMuaklacAoamzMI+tcXa+wg5xXpDrsp4kTEGeErETGaTmYGUy/JZPQoff8mmf2bKudg9S6tEyqfCCmlVC12PvSBNMyFyx7GGUK0bpFH8piRIzQLnSnYo18YWXkBqQ7KpIqqLhErMrmhofe6IIBblLLquai7oaB8m5YHYui1cygRrIQO4PjtLGgoTI+WhC6ty2LvN0HCi53669Zap9MSDSGbmByxNxoOTcOs2jxKsoQWGIcdBT+vz7zJJyseTUojCHu5dRUVPflW0z2a6A9hnAOqrpZtbmHTHkR8T27b1fVa0uy1cVf+8ukg3UcOGUXHvtQP8uRHf9eICUCyU7DaQgWJEdVTSQxAF/IJhUOLCPA48H+QP9ZOEogb3KElWq5NgGdxal9yXzmd0RAvHkF/FXfQnNzYihiOfmQJxyG8eO7R0ZCE0dxhq/RAIR7LdYjpYPJlrGqKlf83Zv4RCVscqiUuchTdfHkaT/sbqSYCcX+qMWdjrx5UVItafof4qvFLRmtyOs27DJnJLANVuKqqNgT2gkqtRvYzadBARJG6Yht046qBTos6rqawq8p3cl2h3HVfvKgak+rD4vlr+fdvvtcnU4nJaL3fFpvzo9rg6HxedVkHjafUsYfjr1BX26qKoyOziwNGTTPd4zCtvCsyU9rXezalFHIK9Bo2u3j7vFfn3Ybk5368fV5rDebg5hwoNnx6A6jZuoqciyudz9lnOS0JftJLpZr7s1a3gte5b8yBJfWVD/9/f4dG/hCNZfcFk1UBQDBaNppPw5o1zSKCVXBkZxXkCLY7mwVWa2Uo6eqJ1ylOeH7qDKRuxblOqknfnNnip8HCjsWuNp4hOTr4ZAHjxXgGzdEAGvq6oJGJ5NVElGauDGuZsZTk2SADOJpoP8eVfPUuRnbkSDjkvdM68uBTE4FfY7AmmSiRoeC/sdQRJoKmorCTN+RcPKO23sUFCno2RjSYE0ySSJaGl/MNiFtBpoj4o2F6MKzCCYxGM9qr0KC6vZWHbNF3OgRApxp38xtHD0jdWQUYcmIuoHOfZmZQE03x5gfTirBuKpfersnBmrgqMkRkHVfm4ex4oiDKKd1LNyCcEpNX4sz0tiHLwuNfqU6vocZGvaTnWyqi6bjry/OxBfFoDNRW2rDV2mkb74cl4uEUGCjFyEn6J2Zf5MdpgibcMiFu1Z2ldLb5aecgUU8ldV6hftbiQhC3oKERX2Wwv4tbdIxNm11CAmsbenTJLbUZhcf7R/f5v8LrstZY/yuwd73y1h5UCMpQmnFt3kcmvKBDe74BLcSW8WKQrmvd/YIIMmXg/g4oZSAIQ8Bj4rEbLz4Dawf/AtcYf/N6XGJg1LEFWhbkqUT8wlDOighKfH+bQx3MS40UYeChU75O+YLoBdnDK23b45dYjCrBT+DxUsJkHuxhtvyjnkTRmrpXkqme/tCZSwjRTpOrWQUiUZ+b1G5oloh4R59oxOEMFJLpm0eykdzEOUnRv68C+dFpKV3GJzUHHZvvbz/TZnuETM+NOi+lxGBf6kIGQsCsEvuqrzsr3jB5ShQs+IgARcpIEg6jypXFp0ktRFPkaZflHoi2Mi9YGD036FUi1oB6ECxqmYNdCmVqD3Dq/Rn//lr/IAN+ngGdk9gEwcCtOBUwUnwA+JW9IAB4d927gD2XVn/s0dHn9X1KZIUWw4dNzq0buUB84UKj+3NEiykOZ3fSnysm6daO0sppthCzRnRHAlUO7Q3F9VJ8U5YnITlTEDCOjVGCI5BGVIqTAf70HrOeXAf9KApUAa39V2DiudNFHar1MRebPsxHPyMukRdHdrk/tAfo6JZIPRoTLlifRmzFTaprQwrEDRfjme4TAfKJn72i4WjAlsUYyCnJ9ZFDMkATyh13h+CZbEKKgRT9cnoyEJNF22JIgnujCTxPl6IJ5pF5mVUKCNx9oIcgmo45Gt5qiSut+op1IldZFR/p1nyL/TnmmyWl9UfwUI7iHLTOSpqim6DmuTJz69n1pbAACT2Wj3i+p4b0iWeVm2NxFRGcIAoqwdEDAZHKgizcaFEUYraz3QRAloiRYFQwtXtYJTJVyqjHuEMi5fZElPRQQmmhaUjA7UX5fnPB2eWMLD0zKT7ZqKanXuvr53Z6TbB6qo8aejAKHJz/ZV3F4TvH3+z3hpDszKtQCwUGo4AzJTbIQL5Do3zM7aFE3Gww/1bJ6YYEPCsxRFRWf8h/o2gKlRmq8AorkW6RueJUbOQ3JSEZQ+tnnxhQkeojnxeGYoIxzkeryN+WN6TyIZM394N2PCMdN7o9+7l4xeIaqBL4SRcLWhB9zplxcqWxMzUZ7M1pm2hIctiUxNmAogYEFFAHNDSX2jsuZ/koATJonDqQpJQ1eACU2oKoTm96ZOEknHI51BNgzzrFZZPTwiToaibSoKx2/q+ah+AvRebDjkDpALkB+2uaiIHEWQgp1NohkEi8qRBCm4EmtvAMvqvMTXu6ZG0nH+c9qmY6+qboWKWuKy2D0ktYD4bYIc7NmHMCw5lEEqe4hLXfCvb6CiEzwjOSSv2wwR61RTX3NdPRgs2jcR63TaGZkE02F5lcYZuG1jLWi+nESmckONaRevMj5SImMSRH9ygWVGJFeVH+Pirh9Ik7V5aieq0IP1tw57zPOUGwZYEhhcMBCAs0SqfSMz6F+whSRO0uZbOjQRPRyYEgULg3huJHyIS6Uy+3UHP1KuVrLRoqnm36ZAJlAmCiiaK8LrOPMK5AJ0qovCBQEK+ZHQ+kb4lKbnxzyYjHTQY4HooTcmJRp8Y8UsCfyJMMMjGhK7BR6aBIaIrvS22wKlEbxU8RY1+VCWil6o85u6Fucgd3i1j5QvhwfGPkWV+utfxJogGuh0p03p+VUnZetIqD383P04LFHsyvxFQ68HG44TaC08z9G90sXIXXNPClJk5AjEIJapBo9qW5rGSJQ3mHW4bRBixSXsGwandt41/FyyP5of4u4v+YjGdvYb/J2Ozlle1ToOFkqmUFqlv6xvbpZKA5fmqXsWCDsywUhVLRY5FYFFlrNATygBi/GCGPPcNpnOoSIAATWfo8tJLmgz8IpQ/JmunRG6ArnenQgKkdIECUv5cXGnXiL4qU1LazCTRcSX9d1+cVpsFg+/H9aH03H9uNo+HU+H1XK7uQNPtsNiDBHRi/bIT/v13efV6etq356EDxa24bzc4+LfTsvdU7BOj5MJfFktdrMUWqBM4mG9WZ0+/X5chZeVDefl9qt/fVodjmPRPoZL+hS87OG42B+fdrfI+hTktNFtC9gad7UMaIYnKHHTOFXCWKjm0Yw2ifwhY6epLsIhGDLd5XGdA1+jbKnOSOTH4brq7iJGg96VefseIrh1BpIhKKhNtuax5CkTdOs7LU2SCLy5bm9BS7F9LJbi1DQgQqew7p5LPkAtJYSF77+nkC85cptziG5LEiYLledMcfSefyYJ4laB0RcPm36L3iJzFjKanXGHgxI9PO122/1xdXfqm+nfFl/bXum37Z5t4S1lgojoXjyUdOhBa/MjkLPHEtIUW+okFdGAnceyWmVvuswz7OIHTtqhoI6BmVpAtV0SWZRG1GL23xywF1sdWcs6qN3skdtCleD3K1III2GnJCYA15uvq81xu//9tN2t9osjdkMVnQaci4hsXfEOQAvZTgBOxR1+cXDO+rhQHmUKVHfnhjfIQ5NFMMwfoiaLX6FtP5bmYBYQ2O21H6mqKl8BXKcaFWA0v2ZlLJEHOCipCZBXGdK1KM/dM7TifhfJn8PD97uuY25NgMPDJ8AAgvXMf6X003AJEvBCFJXon2mYqdOjKbEzWNB8pz3qIQSCWu3PbMBaDc9eyFrtM4NVbGSmhKD6NViaRbD7KLZ34QA9IiJlEQh7w91++3V9t9qf1nerzXF9/J3tCq/iCAO/ZDFCjtvtw2m53Rz3i+WR74VRaZtHsHixV1WRZ5X61Ly8sDFjGwdEDqYCxo+jwktDsWTbixtKgTbaWOLO3edNLXauMZ7hXFeFdG6vwktTzjX2wc4ltAOc27fCTqcPunZqGuBYWAF0q6XAiUIunVqLHcqoirv1HjQcW2/tqFYXl50wcM3us84SCMt2kZY6xiLoJ3uAaIpn2YZH0Dp78a4yJfg9rLALO6wO7YpCew/p4tP6YX1cCxb7HWmcSTCdO7w2dZL/yBZxe5QyVclZidYL7DQwbLKJFeh5kTxMIgmoPP6u6mWeZdirnraqYx4SVh30S9Segygl7YQrBdFQzURU11H8OkXxTnU1fQ6iJGODm1pvM/hhZ1oVISKLs+iPd6EFOBgEddKXvFZ0VzLSehC+//hU6uSshs4UaWwcARvDNTJnu7vm1itGLQgnq8MD5kFnVMmPSgiU2bD0mhdFN2yCCs+4CF8oMeCTbSYKiy8dclEUaX9tFb5WAougBFSwTDnAdgPWmv6XaicwdwUJ0NN4Y0lN4CkFwdQd9as3LDN1K7B04EGZV9uaSlUPOmt+3qkL2IPBshaMbOT6BHJb8XoZ0FoU54bgIY8SVS7Kc3Wfl8eoPMM9CK2GMZFnJ7q9e0xmhQmgyAS+xjYCWpoBGwFhVqfRsFhxCbuVmNpRkxFOQzABMeaH9lrV0h6sce75aH7obmQttYHiO+YMHF8bs1SC1sYwZrAgRmZKyCmM7W632svWpxAthIEY0bsQfn1KJh2wPjVEBjlLs1TDZ2l49GFRbmu4eCrSdTWEsIqypmi3KuoSfkmWUERYqO+pPSJgcibQnzk5wx0uUgc5BE0vPzWzRedMzfqZxpQBm7LQYgjRzClLrxU0ZTHS2GTCZbStuYFNfyUdPbJ3JTwQ3eUzMxSXvaTnJvZ0oT0m4Xu5/avsZEIDfuLu8GVDvh7QZKusLn85TxD7HFcrLmTaNzmQic9OZYnOzuPHdKDtHR5G9ExFjiAEhp4TF2Ak7Q7UNaZGNHJJ0Ur1rtRv7RVj5kKffQ4dLhwlPVuZHwkJz5G+BKfquNKzFjlTIiv0Z8e4/ZGpsnrVBeVN21Lky9Y66ZGfy7wpmGw5Eh6cGg64aHT7IioHMQgUx5EDdBiBE7PAXFM/dQW4XVCm6eI52dikkSjMa5uJamMkRAOdm9chbtPFSLiB1fC2G71LD5VFOMhuNhoSuG+yNTiOReVcMKFTqVTF9XBfwtQla/iVIlSUZCK7ymE6c9dux7CGLECzY1kKm3AD6o76NIWv4rfjjgrCQDXli+e8NBcqRBo5mYTKAViuUv6IdH2flyPyTqURePMDKgoyiIptN450mFLrDYMKbXjArSlU+aYraHkfk0EpqHIbWgYLWUQ/ZMMaJwUcGdOdTGHEmrIw//zyspvSLCrsiwbCRQeOENk6L+Y4G6cJER+D5D2S4JKRu/DbuFAJFDJBaSB4AvyAn9wU5l1+ghMoN1l7SRS88E7WriqSDscbzkEdJWEmumZhFZkemrNdh8HEaVcN9DQ1ErWpywmACm+IH8DyB9zcDFy9CUng+XE6nktc7Mr8XIKdTs88sRH5ZmK/V+2dxmS6p+wAklsYuBR1ewlMquDFsl7ENZT2mxbogF+IhsnAFHxpc9KeFz1liof0qbkz/q57WDpZtbXQWhp0HAtay5aXaB0vh7CSQN/L31lXdftdzlxJcn1htr33icgoBRPmWKYMZJ3UDkka44zu6iuxDzrrWVl3dNgcGyWBPpK/T2X+o1KlLHtT46DcwSpo5iwdXhzLWnfHbGAUQ6CwrJKqeJYhXXmiEBes2tlyaQB88VrWQZlGdNDc2koCfSx/2WuUxSoR5m9qLcrfFLHvWNwTbn5XB6thTFSPx+QS966lLMg95t2+1wAuk8Q87CLCogjXw/PqKQrTwuRZGFFT61l5FZeppSTQR/J33wsENoswLCjHnDKadUQ7JGmIM9rjllWtz11NlJW4DwlyAqWIOgDQlCYHyfgmqvWbMMYntkFZBTXQPE5VWGUkV9uXFx3rKJXly7KWfVqaIEJ7A1sNY5L0BkguUc/ayoLcI94dvh6FNRwgKiiOGF0037ByQLpwP1wK6GIuX7+1k+0vb3TSre1cirqPB/gJPUQDwktiaYqTxNKgB+JF3uv3Apk35UQR5CGCoofQQ3PpKwrTQudZ1ixNjUU5nQAE622gjE8hCR44W5xX7WYIz63/Nlm/lgFcM+G60reV7uvBNfx8ASqssvsCVH8OjltMcuxEuWlf0EbYvby4/B6W3549XwwmkPitDZvuoVBNzE0AW5H/7lab30+rdsvrZrk63a8fVqfd9mG9BDftElooD7F1t8Ps9tvl6nC4QdVmIPQW++P6frE8npbbx91ivz5sN+N+32DHfoz6VahTPPau7TLssLfa3uA9ORXytLl7WL1PEp67FZPABCwXDw+n3eL45QbhOErTU4sRCX5ZbD6v7k6fVl8WX9fb/S26r1F2VsnpWb1GbzovJfL3T5vlsTsi+h4uH+p5oNPHGJ0tPHw0E4jt2wtKD8f9k8n3fM3uVY6qLhuTZYH04bg4rpen/dOmvZjyBmnzCOHwSCYuPW0v6zxPH/LzGXyQuxec2IjaxzQ/t4lb/VRxw3SVU2oXRrbztTM/Qq9/nggB9qL8sFpgtiA1USrAnMIXTlty4tdp63wZpf0ME9tF7TO7KPAD83/8fzSMG34=" \ 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 5714a118f..64de9d34c 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 31fb62945..1045b8aef 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 9957091cb..1b5633345 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 070f5dc45..28a49c75a 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/domain_permissionPolicy.PermissionGrantError.html b/docs/api/classes/domain_permissionPolicy.PermissionGrantError.html index e4fd32529..1259facaf 100644 --- a/docs/api/classes/domain_permissionPolicy.PermissionGrantError.html +++ b/docs/api/classes/domain_permissionPolicy.PermissionGrantError.html @@ -14,7 +14,7 @@

        A proposed grant exceeds the administrator-owned maximum authority.

        -
        +

        Hierarchy

        • Error diff --git a/docs/api/classes/ghidra_GhidraClient.GhidraClient.html b/docs/api/classes/ghidra_GhidraClient.GhidraClient.html index bf3360730..895855aa7 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:65
      @@ -48,7 +48,7 @@
    • options: GhidraClientOptions

    Returns GhidraClient

+
  • Defined in src/ghidra/GhidraClient.ts:115
    • @@ -56,19 +56,19 @@
    • - +
      -

      Execute one admitted inventory operation after the exact session handshake.

      +

      Execute one admitted operation through the bounded per-Program queue.

      Parameters

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

      Returns Promise<Result<JSONType, GhidraSessionError>>

    +
  • Defined in src/ghidra/GhidraClient.ts:175
    • +
  • Defined in src/ghidra/GhidraClient.ts:189
    • +
  • Defined in src/ghidra/GhidraClient.ts:200
    • - +

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

      @@ -103,9 +103,9 @@

      Parameters

      -

      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:164
      • @@ -120,7 +120,7 @@
    • Optionalsignal: AbortSignal

    Returns Promise<GhidraStartResult>

    +
  • Defined in src/ghidra/GhidraClient.ts:137
    • diff --git a/docs/api/classes/ghidra_GhidraLauncher.GhidraLaunchError.html b/docs/api/classes/ghidra_GhidraLauncher.GhidraLaunchError.html index 3d6c0851b..86dc7ed5e 100644 --- a/docs/api/classes/ghidra_GhidraLauncher.GhidraLaunchError.html +++ b/docs/api/classes/ghidra_GhidraLauncher.GhidraLaunchError.html @@ -14,7 +14,7 @@

    Local launch failure retained as the cause of a provider-neutral error.

    -
    +

    Hierarchy

    • Error diff --git a/docs/api/classes/ghidra_GhidraProvider.GhidraProvider.html b/docs/api/classes/ghidra_GhidraProvider.GhidraProvider.html index 2faa5d8db..5978364b6 100644 --- a/docs/api/classes/ghidra_GhidraProvider.GhidraProvider.html +++ b/docs/api/classes/ghidra_GhidraProvider.GhidraProvider.html @@ -19,7 +19,7 @@
    +
  • Defined in src/ghidra/GhidraProvider.ts:241
    • @@ -56,7 +56,7 @@
  • clientFactory: GhidraProviderClientFactory = ...

    • Returns GhidraProvider

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

    Returns readonly CapabilityDescriptor[]

    +
  • Defined in src/ghidra/GhidraProvider.ts:256
    • +
  • Defined in src/ghidra/GhidraProvider.ts:330
    • +
  • Defined in src/ghidra/GhidraProvider.ts:252
    • +
  • Defined in src/ghidra/GhidraProvider.ts:260
    • +
  • Defined in src/ghidra/GhidraProvider.ts:279
    • +
  • Defined in src/ghidra/GhidraProvider.ts:318
    • diff --git a/docs/api/classes/ghidra_GhidraRequestQueue.GhidraRequestQueue.html b/docs/api/classes/ghidra_GhidraRequestQueue.GhidraRequestQueue.html new file mode 100644 index 000000000..7d31624df --- /dev/null +++ b/docs/api/classes/ghidra_GhidraRequestQueue.GhidraRequestQueue.html @@ -0,0 +1,109 @@ +GhidraRequestQueue | rea-agents - v1.6.0
    +
    rea-agents - v1.6.0 + +
      +
      +
      Preparing search index...
      +
      +
      +
      + +

      Class GhidraRequestQueue

      +
      +

      Bounded FIFO that admits one Ghidra Program request at a time.

      +
      +
      +
      +
      +
      Index
       +
      +
      + +
      constructor +
      +
      + +
      failQueued +run +
      +
      + +
      +
      + +
      +
      + +
      +
      + +
      +
      + +
      +
      +
      +
      +
      +

      Settings

       +
      +
      Member Visibility +
        +
        • +
      +
      +
      +

      On This Page

       +
      +
      Constructors +
      +
      Methods +
      +
      +
      +
      diff --git a/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html b/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html index 7c6f357be..a9a3b8649 100644 --- a/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html +++ b/docs/api/classes/ghidra_GhidraSessionError.GhidraSessionError.html @@ -14,7 +14,7 @@

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

      -
      +

      Hierarchy

      • Error diff --git a/docs/api/classes/ghidra_protocol.GhidraRemoteError.html b/docs/api/classes/ghidra_protocol.GhidraRemoteError.html index e3ccd8796..78ab21b7b 100644 --- a/docs/api/classes/ghidra_protocol.GhidraRemoteError.html +++ b/docs/api/classes/ghidra_protocol.GhidraRemoteError.html @@ -14,7 +14,7 @@

        Expected operation failure returned by the authenticated Java bridge.

        -
        +

        Hierarchy

        • Error diff --git a/docs/api/functions/contracts_toolOutputSchemas.requireOutputSchema.html b/docs/api/functions/contracts_toolOutputSchemas.requireOutputSchema.html index f1d6760af..289adcb82 100644 --- a/docs/api/functions/contracts_toolOutputSchemas.requireOutputSchema.html +++ b/docs/api/functions/contracts_toolOutputSchemas.requireOutputSchema.html @@ -25,7 +25,7 @@
        • name: string

      Returns ZodObject

      +
    • Defined in src/contracts/toolOutputSchemas.ts:48
      • diff --git a/docs/api/functions/domain_functionComparison.compareFunctions.html b/docs/api/functions/domain_functionComparison.compareFunctions.html index 411271530..b6dec8073 100644 --- a/docs/api/functions/domain_functionComparison.compareFunctions.html +++ b/docs/api/functions/domain_functionComparison.compareFunctions.html @@ -27,7 +27,7 @@
    • limit: number

      • Returns {
          changes: {
              items: {
                  conclusion_kind:
                      | "contradiction"
                      | "derived_relationship"
                      | "unresolved_branch";
                  dimension: | "comments"
                  | "pseudocode"
                  | "assembly"
                  | "identity"
                  | "calls"
                  | "references"
                  | "strings_names"
                  | "cfg";
                  evidence_links: string[];
                  left_count: number
                  | null;
                  left_digest: string | null;
                  limitations: string[];
                  right_count: number | null;
                  right_digest: string | null;
                  status:
                      | "unknown"
                      | "truncated"
                      | "unchanged"
                      | "added"
                      | "removed"
                      | "changed";
                  text_delta: | {
                      added_lines: number;
                      hunks: number;
                      removed_lines: number;
                  }
                  | null;
              }[];
              limit: number;
              next_offset: number
              | null;
              offset: number;
              total: number;
          };
          dimensions: {
              conclusion_kind: | "contradiction"
              | "derived_relationship"
              | "unresolved_branch";
              dimension: | "comments"
              | "pseudocode"
              | "assembly"
              | "identity"
              | "calls"
              | "references"
              | "strings_names"
              | "cfg";
              evidence_links: string[];
              left_count: number
              | null;
              left_digest: string | null;
              limitations: string[];
              right_count: number | null;
              right_digest: string | null;
              status:
                  | "unknown"
                  | "truncated"
                  | "unchanged"
                  | "added"
                  | "removed"
                  | "changed";
              text_delta: | {
                  added_lines: number;
                  hunks: number;
                  removed_lines: number;
              }
              | null;
          }[];
          function_match: {
              left_name: string;
              method: "symbol"
              | "explicit";
              right_name: string;
              status: "unknown" | "matched" | "mismatched" | "ambiguous";
          };
          left_subject_sha256: string;
          limitations: string[];
          right_subject_sha256: string;
          status: | "unknown"
          | "truncated"
          | "unchanged"
          | "added"
          | "removed"
          | "changed";
          summary: {
              changed: number;
              truncated: number;
              unchanged: number;
              unknown: number;
          };
      }

      +
    • Defined in src/domain/functionComparison.ts:60
      • diff --git a/docs/api/functions/domain_functionComparisonNormalization.combineCoverage.html b/docs/api/functions/domain_functionComparisonNormalization.combineCoverage.html index 0647764ac..680ca6e21 100644 --- a/docs/api/functions/domain_functionComparisonNormalization.combineCoverage.html +++ b/docs/api/functions/domain_functionComparisonNormalization.combineCoverage.html @@ -27,7 +27,7 @@
    • right: FunctionCollection<Item>

      • Returns FunctionCollection<Item>

      +
    • Defined in src/domain/functionComparisonNormalization.ts:177
      • diff --git a/docs/api/functions/domain_functionComparisonNormalization.commentProjection.html b/docs/api/functions/domain_functionComparisonNormalization.commentProjection.html index aa68a88ae..cf88b5ccf 100644 --- a/docs/api/functions/domain_functionComparisonNormalization.commentProjection.html +++ b/docs/api/functions/domain_functionComparisonNormalization.commentProjection.html @@ -22,7 +22,7 @@
    • snapshot: FunctionSnapshot

      • Returns readonly unknown[] | null

      +
    • Defined in src/domain/functionComparisonNormalization.ts:129
      • diff --git a/docs/api/functions/domain_functionComparisonNormalization.isAutoName.html b/docs/api/functions/domain_functionComparisonNormalization.isAutoName.html index ee1df7fde..3dd2586da 100644 --- a/docs/api/functions/domain_functionComparisonNormalization.isAutoName.html +++ b/docs/api/functions/domain_functionComparisonNormalization.isAutoName.html @@ -22,7 +22,7 @@
    • name: string

      • Returns boolean

      +
    • Defined in src/domain/functionComparisonNormalization.ts:195
      • diff --git a/docs/api/functions/domain_functionComparisonNormalization.project.html b/docs/api/functions/domain_functionComparisonNormalization.project.html index 8df169115..9ab128f9f 100644 --- a/docs/api/functions/domain_functionComparisonNormalization.project.html +++ b/docs/api/functions/domain_functionComparisonNormalization.project.html @@ -28,7 +28,7 @@
    • mapper: (item: Input) => Output

      • Returns Output[]

      +
    • Defined in src/domain/functionComparisonNormalization.ts:190
      • diff --git a/docs/api/functions/domain_functionComparisonNormalization.referenceKindProjection.html b/docs/api/functions/domain_functionComparisonNormalization.referenceKindProjection.html new file mode 100644 index 000000000..fcd7b18b6 --- /dev/null +++ b/docs/api/functions/domain_functionComparisonNormalization.referenceKindProjection.html @@ -0,0 +1,42 @@ +referenceKindProjection | rea-agents - v1.6.0
      +
      rea-agents - v1.6.0 + +
        +
        +
        Preparing search index...
        +
        +
        +
        + +

        Function referenceKindProjection

        +
        +
        +
        +
        +
        +
        +

        Settings

         +
        +
        Member Visibility +
          +
          • +
        +
        +
        +
        +
        diff --git a/docs/api/functions/domain_functionComparisonNormalization.sorted.html b/docs/api/functions/domain_functionComparisonNormalization.sorted.html index 2c0386e45..a2050cfbd 100644 --- a/docs/api/functions/domain_functionComparisonNormalization.sorted.html +++ b/docs/api/functions/domain_functionComparisonNormalization.sorted.html @@ -22,7 +22,7 @@
      • values: readonly unknown[]

        • Returns readonly unknown[]

        +
      • Defined in src/domain/functionComparisonNormalization.ts:172
        • diff --git a/docs/api/functions/domain_functionComparisonNormalization.stringAndNameProjection.html b/docs/api/functions/domain_functionComparisonNormalization.stringAndNameProjection.html index b50d08cce..85294bd76 100644 --- a/docs/api/functions/domain_functionComparisonNormalization.stringAndNameProjection.html +++ b/docs/api/functions/domain_functionComparisonNormalization.stringAndNameProjection.html @@ -22,7 +22,7 @@
      • snapshot: FunctionSnapshot

        • Returns readonly unknown[] | null

        +
      • Defined in src/domain/functionComparisonNormalization.ts:142
        • diff --git a/docs/api/functions/domain_hopperValues.parseAddressedPage.html b/docs/api/functions/domain_hopperValues.parseAddressedPage.html index 47da35570..4dd28a2e1 100644 --- a/docs/api/functions/domain_hopperValues.parseAddressedPage.html +++ b/docs/api/functions/domain_hopperValues.parseAddressedPage.html @@ -24,7 +24,7 @@
      • value: JSONType

        • Returns Result<AddressedPage, HopperProtocolError>

        +
      • Defined in src/domain/hopperValues.ts:290
        • diff --git a/docs/api/functions/domain_hopperValues.parseDocuments.html b/docs/api/functions/domain_hopperValues.parseDocuments.html index b2abe5180..770beac9e 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:371
        • diff --git a/docs/api/functions/domain_hopperValues.parseFunctionDossier.html b/docs/api/functions/domain_hopperValues.parseFunctionDossier.html index 322c932e5..9273374f9 100644 --- a/docs/api/functions/domain_hopperValues.parseFunctionDossier.html +++ b/docs/api/functions/domain_hopperValues.parseFunctionDossier.html @@ -16,7 +16,7 @@
      • -

        Strictly parse a complete Hopper function dossier at the provider boundary.

        +

        Strictly parse a complete provider-neutral function dossier.

        Parameters

        @@ -24,7 +24,7 @@
      • value: JSONType

        • Returns Result<JSONType, AnalysisOutputError>

        +
      • Defined in src/domain/hopperValues.ts:274
        • diff --git a/docs/api/functions/domain_hopperValues.parseListCount.html b/docs/api/functions/domain_hopperValues.parseListCount.html index 9b7cf8fcd..a01fca690 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:383
        • diff --git a/docs/api/functions/domain_hopperValues.parseNames.html b/docs/api/functions/domain_hopperValues.parseNames.html index ee856418b..55fe94877 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:326
        • diff --git a/docs/api/functions/domain_hopperValues.parseProcedures.html b/docs/api/functions/domain_hopperValues.parseProcedures.html index a7553f7bb..f60afc59e 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:307
        • diff --git a/docs/api/functions/domain_hopperValues.parseRelatedAddresses.html b/docs/api/functions/domain_hopperValues.parseRelatedAddresses.html index b0c9d7eab..c9c4c8d22 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:348
        • diff --git a/docs/api/functions/domain_hopperValues.parseSegments.html b/docs/api/functions/domain_hopperValues.parseSegments.html index 47ab7dacf..905ee4cac 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:359
        • diff --git a/docs/api/functions/ghidra_GhidraFunctionValues.isGhidraFunctionOperation.html b/docs/api/functions/ghidra_GhidraFunctionValues.isGhidraFunctionOperation.html new file mode 100644 index 000000000..dc2d95509 --- /dev/null +++ b/docs/api/functions/ghidra_GhidraFunctionValues.isGhidraFunctionOperation.html @@ -0,0 +1,44 @@ +isGhidraFunctionOperation | rea-agents - v1.6.0
        +
        rea-agents - v1.6.0 + +
          +
          +
          Preparing search index...
          +
          +
          +
          + +

          Function isGhidraFunctionOperation

          +
          +
            +
          • + +
            +

            Narrow an application operation to the Ghidra function-analysis surface.

            +
            +
            +

            Parameters

            +
              +
            • operation: string
            +

            Returns operation is
                | "analyze_function"
                | "procedure_assembly"
                | "procedure_callees"
                | "procedure_callers"
                | "procedure_info"
                | "procedure_references"
                | "procedure_pseudo_code"
                | "xrefs"

          +
          +
          +
          +
          +

          Settings

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

            Function parseGhidraFunctionInput

            +
            +
              +
            • + +
              +

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

              +
              +
              +

              Parameters

              +
                +
              • operation:
                    | "analyze_function"
                    | "procedure_assembly"
                    | "procedure_callees"
                    | "procedure_callers"
                    | "procedure_info"
                    | "procedure_references"
                    | "procedure_pseudo_code"
                    | "xrefs"
                • +
              • value: Readonly<Record<string, JsonValue>>
              +

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

            +
            +
            +
            +
            +

            Settings

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

              Function parseGhidraFunctionResult

              +
              +
                +
              • + +
                +

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

                +
                +
                +

                Parameters

                +
                  +
                • operation:
                      | "analyze_function"
                      | "procedure_assembly"
                      | "procedure_callees"
                      | "procedure_callers"
                      | "procedure_info"
                      | "procedure_references"
                      | "procedure_pseudo_code"
                      | "xrefs"
                  • +
                • value: JSONType
                +

                Returns Result<JSONType, AnalysisOutputError>

              +
              +
              +
              +
              +

              Settings

               +
              +
              Member Visibility +
                +
                • +
              +
              +
              +
              +
              diff --git a/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html index ebc40184f..282eaeb61 100644 --- a/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html +++ b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryInput.html @@ -25,7 +25,7 @@
            • value: Readonly<Record<string, JsonValue>>

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

              +
            • Defined in src/ghidra/GhidraInventoryValues.ts:76
              • diff --git a/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html index df551ecc5..640adf2f1 100644 --- a/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html +++ b/docs/api/functions/ghidra_GhidraInventoryValues.parseGhidraInventoryResult.html @@ -25,7 +25,7 @@
            • value: JSONType

              • Returns Result<JSONType, AnalysisOutputError>

              +
            • Defined in src/ghidra/GhidraInventoryValues.ts:238
              • diff --git a/docs/api/functions/ghidra_GhidraSessionValues.isGhidraShutdownAcknowledgement.html b/docs/api/functions/ghidra_GhidraSessionValues.isGhidraShutdownAcknowledgement.html index e92ed95ef..711fe236d 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:79
              • diff --git a/docs/api/functions/ghidra_GhidraSessionValues.parseGhidraSessionInfo.html b/docs/api/functions/ghidra_GhidraSessionValues.parseGhidraSessionInfo.html index 6f3664d2e..5fb3b14fd 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: 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;
                        };
                    },
                    Error,
                >

              +
            • Defined in src/ghidra/GhidraSessionValues.ts:53
              • diff --git a/docs/api/hierarchy.html b/docs/api/hierarchy.html index fa77899ca..8c7c98bea 100644 --- a/docs/api/hierarchy.html +++ b/docs/api/hierarchy.html @@ -39,52 +39,52 @@
            • NoBinaryOpenError
            • BinaryTargetError
            • PermissionRequiredError
              • -
            • ProcessCaptureError
              • +
            • ProcessCaptureError
              • +
            • BinarySession
              • +
            • GhidraProvider
              • +
            • HopperProvider
              • +
            • HopperApplicationLauncher
              • +
            • CdpBrowserProvider
              • +
            • CdpElectronProvider
              • +
            • GhidraHeadlessLauncher
              • +
            • PermissionRequest
              • +
            • PermissionGrant
              • +
            • BridgeLaunch
              • +
            • GhidraLaunch
              • +
            • StableWebResource
              • diff --git a/docs/api/index.html b/docs/api/index.html index 5fa3d8cd0..55707fd84 100644 --- a/docs/api/index.html +++ b/docs/api/index.html @@ -9,7 +9,7 @@

              rea-agents - v1.6.0

              -
              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
              +
              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/GhidraFunctionValues
              ghidra/GhidraInstallation
              ghidra/GhidraInventoryValues
              ghidra/GhidraLauncher
              ghidra/GhidraProvider
              ghidra/GhidraRequestQueue
              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/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
              +
              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/GhidraFunctionValuesghidra/GhidraInstallationghidra/GhidraInventoryValuesghidra/GhidraLauncherghidra/GhidraProviderghidra/GhidraRequestQueueghidra/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 StableWebResource {
                  content_size: number | null;
                  mime_type: string;
                  origin: string | null;
                  resource_key: string;
                  type: string;
                  url: string;
              }
              -
              +

              Hierarchy (View Summary)

              • WebInventoryResourceInput diff --git a/docs/api/interfaces/domain_webInventory.WebInventoryResourceInput.html b/docs/api/interfaces/domain_webInventory.WebInventoryResourceInput.html index 2d185af9c..5bac03af0 100644 --- a/docs/api/interfaces/domain_webInventory.WebInventoryResourceInput.html +++ b/docs/api/interfaces/domain_webInventory.WebInventoryResourceInput.html @@ -12,7 +12,7 @@
              • WebInventoryResourceInput

              Interface WebInventoryResourceInput

              interface WebInventoryResourceInput {
                  content_size: number | null;
                  mime_type: string;
                  origin: string | null;
                  type: string;
                  url: string;
              }
              -
              +

              Hierarchy (View Summary)

              • WebInventoryResourceInput diff --git a/docs/api/interfaces/ghidra_GhidraLauncher.GhidraLaunch.html b/docs/api/interfaces/ghidra_GhidraLauncher.GhidraLaunch.html index b87590894..9e1509982 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)

              • ProviderProcessLaunch diff --git a/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html b/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html index 5c799802d..1cab0a47d 100644 --- a/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html +++ b/docs/api/interfaces/ghidra_GhidraSessionError.GhidraSessionErrorOptions.html @@ -15,7 +15,7 @@

                Additional structured context for a Ghidra session failure.

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

              Hierarchy

              • ErrorOptions diff --git a/docs/api/interfaces/hopper_BridgeLauncher.BridgeLaunch.html b/docs/api/interfaces/hopper_BridgeLauncher.BridgeLaunch.html index 7ce4ce9ad..7534fbf24 100644 --- a/docs/api/interfaces/hopper_BridgeLauncher.BridgeLaunch.html +++ b/docs/api/interfaces/hopper_BridgeLauncher.BridgeLaunch.html @@ -15,7 +15,7 @@

                Process handle returned by a bridge launcher.

              interface BridgeLaunch {
                  cleanup?: () => Promise<ProcessCleanupResult>;
                  ownsProcessLifetime: boolean;
                  process: ChildProcess;
                  shutdownByCleanup?: boolean;
              }
              -
              +

              Hierarchy (View Summary)

              • ProviderProcessLaunch diff --git a/docs/api/interfaces/process_ProviderProcess.ProviderProcessLaunch.html b/docs/api/interfaces/process_ProviderProcess.ProviderProcessLaunch.html index 2e4fcc1bb..6bc306c61 100644 --- a/docs/api/interfaces/process_ProviderProcess.ProviderProcessLaunch.html +++ b/docs/api/interfaces/process_ProviderProcess.ProviderProcessLaunch.html @@ -15,7 +15,7 @@

                Process handle returned by a provider-specific launcher.

              interface ProviderProcessLaunch {
                  cleanup?: () => Promise<ProcessCleanupResult>;
                  ownsProcessLifetime: boolean;
                  process: ChildProcess;
              }
              -
              +

              Hierarchy (View Summary)

              • ProviderProcessLaunch diff --git a/docs/api/modules/domain_functionComparisonNormalization.html b/docs/api/modules/domain_functionComparisonNormalization.html index 8cda98663..e3614400b 100644 --- a/docs/api/modules/domain_functionComparisonNormalization.html +++ b/docs/api/modules/domain_functionComparisonNormalization.html @@ -11,7 +11,7 @@
              • domain/functionComparisonNormalization

              Module domain/functionComparisonNormalization

              -
              combineCoverage
              commentProjection
              functionMatch
              identityProjection
              isAutoName
              normalizeCfg
              project
              referenceProjection
              sorted
              stringAndNameProjection
              +
              combineCoverage
              commentProjection
              functionMatch
              identityProjection
              isAutoName
              normalizeCfg
              project
              referenceKindProjection
              referenceProjection
              sorted
              stringAndNameProjection
              @@ -27,7 +27,7 @@

              On This Page

              Functions -
              +
              @@ -37,7 +37,7 @@
              Type Aliases
              Variables -
              +
              Functions
              diff --git a/docs/api/modules/ghidra_GhidraClient.html b/docs/api/modules/ghidra_GhidraClient.html index e02456ef8..73b2cf8aa 100644 --- a/docs/api/modules/ghidra_GhidraClient.html +++ b/docs/api/modules/ghidra_GhidraClient.html @@ -12,6 +12,8 @@

              Module ghidra/GhidraClient

              GhidraClient
              +
              +
              GhidraOperation
              GhidraClientOptions → GhidraClientOptions
              GhidraDiagnostic → GhidraDiagnostic
              GhidraRequestOptions → GhidraRequestOptions
              GhidraStartResult → GhidraStartResult
              @@ -30,6 +32,8 @@
              Classes
              +
              Type Aliases +
              References
              diff --git a/docs/api/modules/ghidra_GhidraDefaults.html b/docs/api/modules/ghidra_GhidraDefaults.html index 0b004df4d..da732c590 100644 --- a/docs/api/modules/ghidra_GhidraDefaults.html +++ b/docs/api/modules/ghidra_GhidraDefaults.html @@ -11,7 +11,7 @@
            • ghidra/GhidraDefaults

              • Module ghidra/GhidraDefaults

              -
              GHIDRA_ANALYSIS_TIMEOUT_SECONDS
              GHIDRA_BRIDGE_VERSION
              GHIDRA_MAX_CPU
              GHIDRA_MAX_HEAP
              GHIDRA_MAX_LINE_BYTES
              GHIDRA_REQUEST_TIMEOUT_MS
              GHIDRA_STARTUP_TIMEOUT_MS
              +
              GHIDRA_ANALYSIS_TIMEOUT_SECONDS
              GHIDRA_BRIDGE_VERSION
              GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS
              GHIDRA_DECOMPILE_TIMEOUT_SECONDS
              GHIDRA_MAX_CPU
              GHIDRA_MAX_HEAP
              GHIDRA_MAX_LINE_BYTES
              GHIDRA_MAX_QUEUED_REQUESTS
              GHIDRA_REQUEST_TIMEOUT_MS
              GHIDRA_STARTUP_TIMEOUT_MS
              @@ -27,7 +27,7 @@

              On This Page

              Variables -
              +
              @@ -33,7 +33,7 @@
              Type Aliases
              Variables -
              +
              Functions
              diff --git a/docs/api/modules/ghidra_GhidraRequestQueue.html b/docs/api/modules/ghidra_GhidraRequestQueue.html new file mode 100644 index 000000000..ae2c1950b --- /dev/null +++ b/docs/api/modules/ghidra_GhidraRequestQueue.html @@ -0,0 +1,40 @@ +ghidra/GhidraRequestQueue | rea-agents - v1.6.0
              +
              rea-agents - v1.6.0 + +
                +
                +
                Preparing search index...
                +
                +
                +
                + +

                Module ghidra/GhidraRequestQueue

                +
                +
                GhidraRequestQueue
                +
                +
                GhidraQueuedRequestResult
                GhidraQueueFailureFactory
                GhidraRequestExecutor
                +
                +
                +
                +
                +

                Settings

                 +
                +
                Member Visibility +
                  +
                  • +
                +
                +
                +

                On This Page

                 +
                +
                Classes +
                +
                Type Aliases +
                +
                +
                +
                diff --git a/docs/api/types/domain_hopperValues.FunctionDossier.html b/docs/api/types/domain_hopperValues.FunctionDossier.html index e1052b343..80b6044ae 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:271
                • diff --git a/docs/api/types/ghidra_GhidraClient.GhidraOperation.html b/docs/api/types/ghidra_GhidraClient.GhidraOperation.html new file mode 100644 index 000000000..2b58416d6 --- /dev/null +++ b/docs/api/types/ghidra_GhidraClient.GhidraOperation.html @@ -0,0 +1,35 @@ +GhidraOperation | rea-agents - v1.6.0
                +
                rea-agents - v1.6.0 + +
                  +
                  +
                  Preparing search index...
                  +
                  +
                  +
                  + +

                  Type Alias GhidraOperation

                  +
                  GhidraOperation: GhidraInventoryOperation | GhidraFunctionOperation
                  +

                  Closed Java-bridge operation union callable after the exact handshake.

                  +
                  +
                  +
                  +
                  +
                  +

                  Settings

                   +
                  +
                  Member Visibility +
                    +
                    • +
                  +
                  +
                  +
                  +
                  diff --git a/docs/api/types/ghidra_GhidraFunctionValues.GhidraFunctionOperation.html b/docs/api/types/ghidra_GhidraFunctionValues.GhidraFunctionOperation.html new file mode 100644 index 000000000..cd455de56 --- /dev/null +++ b/docs/api/types/ghidra_GhidraFunctionValues.GhidraFunctionOperation.html @@ -0,0 +1,35 @@ +GhidraFunctionOperation | rea-agents - v1.6.0
                  +
                  rea-agents - v1.6.0 + +
                    +
                    +
                    Preparing search index...
                    +
                    +
                    +
                    + +

                    Type Alias GhidraFunctionOperation

                    +
                    GhidraFunctionOperation: typeof GHIDRA_FUNCTION_OPERATIONS[number]
                    +

                    One function-analysis 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 index 8cfe1b0f2..d9e4979f6 100644 --- a/docs/api/types/ghidra_GhidraProvider.GhidraProviderClientFactory.html +++ b/docs/api/types/ghidra_GhidraProvider.GhidraProviderClientFactory.html @@ -27,7 +27,7 @@
                  • options: GhidraClientOptions

                    • Returns Pick<GhidraClient, "start" | "callTool" | "close">

                    +
                  • Defined in src/ghidra/GhidraProvider.ts:236
                    • diff --git a/docs/api/types/ghidra_GhidraRequestQueue.GhidraQueueFailureFactory.html b/docs/api/types/ghidra_GhidraRequestQueue.GhidraQueueFailureFactory.html new file mode 100644 index 000000000..6736ad15e --- /dev/null +++ b/docs/api/types/ghidra_GhidraRequestQueue.GhidraQueueFailureFactory.html @@ -0,0 +1,49 @@ +GhidraQueueFailureFactory | rea-agents - v1.6.0
                    +
                    rea-agents - v1.6.0 + +
                      +
                      +
                      Preparing search index...
                      +
                      +
                      +
                      + +

                      Type Alias GhidraQueueFailureFactory

                      +
                      GhidraQueueFailureFactory: (
                          kind: "cancelled" | "timeout" | "protocol",
                          message: string,
                          timeoutMs?: number,
                      ) => GhidraSessionError
                      +

                      Bind queue failures to the owning client's live diagnostics.

                      +
                      +
                      +

                      Type Declaration

                      +
                        +
                      • +
                          +
                        • (
                              kind: "cancelled" | "timeout" | "protocol",
                              message: string,
                              timeoutMs?: number,
                          ): GhidraSessionError
                          • +
                        • +
                          +

                          Parameters

                          +
                            +
                          • kind: "cancelled" | "timeout" | "protocol"
                            • +
                          • message: string
                            • +
                          • OptionaltimeoutMs: number
                          +

                          Returns GhidraSessionError

                      +
                      +
                      +
                      +
                      +

                      Settings

                       +
                      +
                      Member Visibility +
                        +
                        • +
                      +
                      +
                      +
                      +
                      diff --git a/docs/api/types/ghidra_GhidraRequestQueue.GhidraQueuedRequestResult.html b/docs/api/types/ghidra_GhidraRequestQueue.GhidraQueuedRequestResult.html new file mode 100644 index 000000000..826c8d2b1 --- /dev/null +++ b/docs/api/types/ghidra_GhidraRequestQueue.GhidraQueuedRequestResult.html @@ -0,0 +1,35 @@ +GhidraQueuedRequestResult | rea-agents - v1.6.0
                      +
                      rea-agents - v1.6.0 + +
                        +
                        +
                        Preparing search index...
                        +
                        +
                        +
                        + +

                        Type Alias GhidraQueuedRequestResult

                        +
                        GhidraQueuedRequestResult: Result<JsonValue, GhidraSessionError>
                        +

                        Result settled by one queued Ghidra Program request.

                        +
                        +
                        +
                        +
                        +
                        +

                        Settings

                         +
                        +
                        Member Visibility +
                          +
                          • +
                        +
                        +
                        +
                        +
                        diff --git a/docs/api/types/ghidra_GhidraRequestQueue.GhidraRequestExecutor.html b/docs/api/types/ghidra_GhidraRequestQueue.GhidraRequestExecutor.html new file mode 100644 index 000000000..0f3077144 --- /dev/null +++ b/docs/api/types/ghidra_GhidraRequestQueue.GhidraRequestExecutor.html @@ -0,0 +1,49 @@ +GhidraRequestExecutor | rea-agents - v1.6.0
                        +
                        rea-agents - v1.6.0 + +
                          +
                          +
                          Preparing search index...
                          +
                          +
                          +
                          + +

                          Type Alias GhidraRequestExecutor

                          +
                          GhidraRequestExecutor: (
                              method: string,
                              parameters: JsonValue,
                              options: GhidraRequestOptions,
                          ) => Promise<GhidraQueuedRequestResult>
                          +

                          Socket execution seam used after a request reaches the queue head.

                          +
                          +
                          +

                          Type Declaration

                          +
                          +
                          +
                          +
                          +
                          +

                          Settings

                           +
                          +
                          Member Visibility +
                            +
                            • +
                          +
                          +
                          +
                          +
                          diff --git a/docs/api/types/ghidra_GhidraSessionValues.GhidraSessionInfo.html b/docs/api/types/ghidra_GhidraSessionValues.GhidraSessionInfo.html index 84ecd55f8..b41b13aff 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:50
                          • diff --git a/docs/api/variables/contracts_toolOutputSchemas.artifactOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.artifactOutputSchemas.html index c00241dd5..4ff1a2ff3 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:527
                          • diff --git a/docs/api/variables/contracts_toolOutputSchemas.enhancedOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.enhancedOutputSchemas.html index 1c24842c3..086bfe38c 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:420
                          • diff --git a/docs/api/variables/contracts_toolOutputSchemas.nativeOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.nativeOutputSchemas.html index 5b185aac5..bf4043901 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:518
                          • diff --git a/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html index f73c71b8a..72ca9017c 100644 --- a/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html +++ b/docs/api/variables/contracts_toolOutputSchemas.officialOutputSchemas.html @@ -15,7 +15,7 @@

                          Exact structured-content schemas shared by direct analysis providers.

                          +
                        • Defined in src/contracts/toolOutputSchemas.ts:367
                          • diff --git a/docs/api/variables/contracts_toolOutputSchemas.sessionOutputSchemas.html b/docs/api/variables/contracts_toolOutputSchemas.sessionOutputSchemas.html index 570554cad..716cda40c 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:533
                          • diff --git a/docs/api/variables/domain_hopperValues.functionDossierSchema.html b/docs/api/variables/domain_hopperValues.functionDossierSchema.html index 12cf3bc12..baad4f46b 100644 --- a/docs/api/variables/domain_hopperValues.functionDossierSchema.html +++ b/docs/api/variables/domain_hopperValues.functionDossierSchema.html @@ -11,9 +11,9 @@
                        • domain/hopperValues
                        • functionDossierSchema

                          • 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:179
                          • diff --git a/docs/api/variables/domain_hopperValues.localVariableSchema.html b/docs/api/variables/domain_hopperValues.localVariableSchema.html new file mode 100644 index 000000000..6d96a307e --- /dev/null +++ b/docs/api/variables/domain_hopperValues.localVariableSchema.html @@ -0,0 +1,33 @@ +localVariableSchema | rea-agents - v1.6.0
                          +
                          rea-agents - v1.6.0 + +
                            +
                            +
                            Preparing search index...
                            +
                            +
                            +
                            + +

                            Variable localVariableSchemaConst

                            +
                            localVariableSchema: ZodObject<
                                { description: ZodString; provenance: ZodString },
                                $strict,
                            > = ...
                            +
                            +
                            +
                            +
                            +

                            Settings

                             +
                            +
                            Member Visibility +
                              +
                              • +
                            +
                            +
                            +
                            +
                            diff --git a/docs/api/variables/domain_hopperValues.procedureClassificationSchema.html b/docs/api/variables/domain_hopperValues.procedureClassificationSchema.html new file mode 100644 index 000000000..209a37a52 --- /dev/null +++ b/docs/api/variables/domain_hopperValues.procedureClassificationSchema.html @@ -0,0 +1,33 @@ +procedureClassificationSchema | rea-agents - v1.6.0
                            +
                            rea-agents - v1.6.0 + +
                              +
                              +
                              Preparing search index...
                              +
                              +
                              +
                              + +

                              Variable procedureClassificationSchemaConst

                              +
                              procedureClassificationSchema: ZodObject<
                                  {
                                      external: ZodBoolean;
                                      provenance: ZodString;
                                      thunk: ZodBoolean;
                                      thunk_target: ZodNullable<ZodString>;
                                  },
                                  $strict,
                              > = ...
                              +
                              +
                              +
                              +
                              +

                              Settings

                               +
                              +
                              Member Visibility +
                                +
                                • +
                              +
                              +
                              +
                              +
                              diff --git a/docs/api/variables/domain_hopperValues.procedureIdentitySchema.html b/docs/api/variables/domain_hopperValues.procedureIdentitySchema.html new file mode 100644 index 000000000..446a787cf --- /dev/null +++ b/docs/api/variables/domain_hopperValues.procedureIdentitySchema.html @@ -0,0 +1,33 @@ +procedureIdentitySchema | rea-agents - v1.6.0
                              +
                              rea-agents - v1.6.0 + +
                                +
                                +
                                Preparing search index...
                                +
                                +
                                +
                                + +

                                Variable procedureIdentitySchemaConst

                                +
                                procedureIdentitySchema: ZodObject<
                                    {
                                        address: ZodString;
                                        classification: ZodDefault<
                                            ZodNullable<
                                                ZodObject<
                                                    {
                                                        external: ZodBoolean;
                                                        provenance: ZodString;
                                                        thunk: ZodBoolean;
                                                        thunk_target: ZodNullable<ZodString>;
                                                    },
                                                    $strict,
                                                >,
                                            >,
                                        >;
                                        name: ZodString;
                                    },
                                    $strict,
                                > = ...
                                +
                                +
                                +
                                +
                                +

                                Settings

                                 +
                                +
                                Member Visibility +
                                  +
                                  • +
                                +
                                +
                                +
                                +
                                diff --git a/docs/api/variables/domain_hopperValues.referenceKindSchema.html b/docs/api/variables/domain_hopperValues.referenceKindSchema.html new file mode 100644 index 000000000..d3157da09 --- /dev/null +++ b/docs/api/variables/domain_hopperValues.referenceKindSchema.html @@ -0,0 +1,33 @@ +referenceKindSchema | rea-agents - v1.6.0
                                +
                                rea-agents - v1.6.0 + +
                                  +
                                  +
                                  Preparing search index...
                                  +
                                  +
                                  +
                                  + +

                                  Variable referenceKindSchemaConst

                                  +
                                  referenceKindSchema: ZodDiscriminatedUnion<
                                      [
                                          ZodObject<{ available: ZodLiteral<false>; reason: ZodString }, $strict>,
                                          ZodObject<
                                              {
                                                  available: ZodLiteral<true>;
                                                  call: ZodBoolean;
                                                  computed: ZodBoolean;
                                                  conditional: ZodBoolean;
                                                  data: ZodBoolean;
                                                  external: ZodBoolean;
                                                  flow: ZodBoolean;
                                                  indirect: ZodBoolean;
                                                  jump: ZodBoolean;
                                                  operand_index: ZodNumber;
                                                  primary: ZodBoolean;
                                                  provenance: ZodString;
                                                  read: ZodBoolean;
                                                  terminal: ZodBoolean;
                                                  type: ZodString;
                                                  write: ZodBoolean;
                                              },
                                              $strict,
                                          >,
                                      ],
                                      "available",
                                  > = ...
                                  +
                                  +
                                  +
                                  +
                                  +

                                  Settings

                                   +
                                  +
                                  Member Visibility +
                                    +
                                    • +
                                  +
                                  +
                                  +
                                  +
                                  diff --git a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html index 1ccd1f178..fa17c7042 100644 --- a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html +++ b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_BRIDGE_VERSION.html @@ -11,11 +11,11 @@
                                • ghidra/GhidraDefaults
                                • GHIDRA_BRIDGE_VERSION

                                  • Variable GHIDRA_BRIDGE_VERSIONConst

                                  -
                                  GHIDRA_BRIDGE_VERSION: 2
                                  +
                                  GHIDRA_BRIDGE_VERSION: 3

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

                                  +
                                • Defined in src/ghidra/GhidraDefaults.ts:20
                                  • diff --git a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS.html b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS.html new file mode 100644 index 000000000..5566d9122 --- /dev/null +++ b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS.html @@ -0,0 +1,35 @@ +GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS | rea-agents - v1.6.0
                                  +
                                  rea-agents - v1.6.0 + +
                                    +
                                    +
                                    Preparing search index...
                                    +
                                    +
                                    +
                                    + +

                                    Variable GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MSConst

                                    +
                                    GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS: 35000 = 35_000
                                    +

                                    Socket deadline leaves bounded time to project a native decompiler timeout.

                                    +
                                    +
                                    +
                                    +
                                    +
                                    +

                                    Settings

                                     +
                                    +
                                    Member Visibility +
                                      +
                                      • +
                                    +
                                    +
                                    +
                                    +
                                    diff --git a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_DECOMPILE_TIMEOUT_SECONDS.html b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_DECOMPILE_TIMEOUT_SECONDS.html new file mode 100644 index 000000000..6d126770d --- /dev/null +++ b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_DECOMPILE_TIMEOUT_SECONDS.html @@ -0,0 +1,35 @@ +GHIDRA_DECOMPILE_TIMEOUT_SECONDS | rea-agents - v1.6.0
                                    +
                                    rea-agents - v1.6.0 + +
                                      +
                                      +
                                      Preparing search index...
                                      +
                                      +
                                      +
                                      + +

                                      Variable GHIDRA_DECOMPILE_TIMEOUT_SECONDSConst

                                      +
                                      GHIDRA_DECOMPILE_TIMEOUT_SECONDS: 30
                                      +

                                      Per-function ceiling passed to Ghidra's native decompiler process.

                                      +
                                      +
                                      +
                                      +
                                      +
                                      +

                                      Settings

                                       +
                                      +
                                      Member Visibility +
                                        +
                                        • +
                                      +
                                      +
                                      +
                                      +
                                      diff --git a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_LINE_BYTES.html b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_LINE_BYTES.html index a4c53a348..2f0421738 100644 --- a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_LINE_BYTES.html +++ b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_LINE_BYTES.html @@ -15,7 +15,7 @@

                                      Maximum encoded response line accepted from the Java bridge.

                                      +
                                    • Defined in src/ghidra/GhidraDefaults.ts:18
                                      • diff --git a/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_QUEUED_REQUESTS.html b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_QUEUED_REQUESTS.html new file mode 100644 index 000000000..a19eeb03e --- /dev/null +++ b/docs/api/variables/ghidra_GhidraDefaults.GHIDRA_MAX_QUEUED_REQUESTS.html @@ -0,0 +1,35 @@ +GHIDRA_MAX_QUEUED_REQUESTS | rea-agents - v1.6.0
                                      +
                                      rea-agents - v1.6.0 + +
                                        +
                                        +
                                        Preparing search index...
                                        +
                                        +
                                        +
                                        + +

                                        Variable GHIDRA_MAX_QUEUED_REQUESTSConst

                                        +
                                        GHIDRA_MAX_QUEUED_REQUESTS: 32
                                        +

                                        Maximum active plus queued calls for one serial headless Program.

                                        +
                                        +
                                        +
                                        +
                                        +
                                        +

                                        Settings

                                         +
                                        +
                                        Member Visibility +
                                          +
                                          • +
                                        +
                                        +
                                        +
                                        +
                                        diff --git a/docs/api/variables/ghidra_GhidraFunctionValues.GHIDRA_FUNCTION_OPERATIONS.html b/docs/api/variables/ghidra_GhidraFunctionValues.GHIDRA_FUNCTION_OPERATIONS.html new file mode 100644 index 000000000..e1f641965 --- /dev/null +++ b/docs/api/variables/ghidra_GhidraFunctionValues.GHIDRA_FUNCTION_OPERATIONS.html @@ -0,0 +1,35 @@ +GHIDRA_FUNCTION_OPERATIONS | rea-agents - v1.6.0
                                        +
                                        rea-agents - v1.6.0 + +
                                          +
                                          +
                                          Preparing search index...
                                          +
                                          +
                                          +
                                          + +

                                          Variable GHIDRA_FUNCTION_OPERATIONSConst

                                          +
                                          GHIDRA_FUNCTION_OPERATIONS: readonly [
                                              "analyze_function",
                                              "procedure_assembly",
                                              "procedure_callees",
                                              "procedure_callers",
                                              "procedure_info",
                                              "procedure_pseudo_code",
                                              "procedure_references",
                                              "xrefs",
                                          ] = ...
                                          +

                                          Read-only function operations admitted by the Ghidra adapter.

                                          +
                                          +
                                          +
                                          +
                                          +
                                          +

                                          Settings

                                           +
                                          +
                                          Member Visibility +
                                            +
                                            • +
                                          +
                                          +
                                          +
                                          +
                                          diff --git a/docs/api/variables/ghidra_GhidraInventoryValues.ghidraBoundedIdentifierSchema.html b/docs/api/variables/ghidra_GhidraInventoryValues.ghidraBoundedIdentifierSchema.html new file mode 100644 index 000000000..09d9cdedc --- /dev/null +++ b/docs/api/variables/ghidra_GhidraInventoryValues.ghidraBoundedIdentifierSchema.html @@ -0,0 +1,33 @@ +ghidraBoundedIdentifierSchema | rea-agents - v1.6.0
                                          +
                                          rea-agents - v1.6.0 + +
                                            +
                                            +
                                            Preparing search index...
                                            +
                                            +
                                            +
                                            + +

                                            Variable ghidraBoundedIdentifierSchemaConst

                                            +
                                            ghidraBoundedIdentifierSchema: ZodString = ...
                                            +
                                            +
                                            +
                                            +
                                            +

                                            Settings

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

                                              Variable ghidraCanonicalAddressSchemaConst

                                              +
                                              ghidraCanonicalAddressSchema: ZodString = ...
                                              +
                                              +
                                              +
                                              +
                                              +

                                              Settings

                                               +
                                              +
                                              Member Visibility +
                                                +
                                                • +
                                              +
                                              +
                                              +
                                              +
                                              diff --git a/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_IDENTITY.html b/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_IDENTITY.html index 8373aa9ac..05f750b98 100644 --- a/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_IDENTITY.html +++ b/docs/api/variables/ghidra_GhidraProvider.GHIDRA_PROVIDER_IDENTITY.html @@ -15,7 +15,7 @@

                                              Public identity committed by every Ghidra-backed observation.

                                              +
                                            • Defined in src/ghidra/GhidraProvider.ts:64
                                              • 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 00bc97904..446b6fd66 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 (
                                                  | 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.

                                              +
                                              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">
                                                  | ToolContract<"swift_classes">
                                                  | ToolContract<"get_objc_classes">
                                                  | ToolContract<"get_objc_protocols">
                                                  | ToolContract<"batch_decompile">
                                                  | ToolContract<"get_call_graph">
                                                  | ToolContract<"analyze_swift_types">
                                                  | ToolContract<"find_xrefs_to_name">
                                                  | ToolContract<"binary_overview">
                                                  | ToolContract<"analyze_function">
                                                  | ToolContract<"trace_feature">
                                              )[] = ...
                                              +

                                              Provider-neutral read-only contracts implemented by the Ghidra adapter.

                                              +
                                            • Defined in src/ghidra/GhidraProvider.ts:78
                                              • diff --git a/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html b/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html index 0d492347b..7d02b5196 100644 --- a/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html +++ b/docs/api/variables/ghidra_GhidraSessionValues.GHIDRA_SESSION_CAPABILITIES.html @@ -11,11 +11,11 @@
                                            • ghidra/GhidraSessionValues
                                            • GHIDRA_SESSION_CAPABILITIES

                                              • 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",
                                              ] = ...
                                              +
                                              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",
                                                  "analyze_function",
                                                  "procedure_assembly",
                                                  "procedure_callees",
                                                  "procedure_callers",
                                                  "procedure_info",
                                                  "procedure_pseudo_code",
                                                  "procedure_references",
                                                  "xrefs",
                                              ] = ...

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

                                              +
                                            • Defined in src/ghidra/GhidraSessionValues.ts:10
                                              • diff --git a/docs/architecture.mermaid b/docs/architecture.mermaid index f76866815..ee14f3b4f 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
                                              authenticated read-only inventory"] + GHIDRA_BRIDGE["bridge/ghidra/ReaGhidraBridge.java
                                              Packaged HeadlessScript
                                              inventory, decompiler, references, CFG"] 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 & inventory operations
                                              launcher, client, doctor, protocol"] + GHIDRA["src/ghidra/
                                              Ghidra discovery, profile & function analysis
                                              bounded queue, launcher, client, 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 da7ace9a4..1ceb8cbbd 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -71,8 +71,10 @@ desktop display. Unattended package-manager access requires 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. +ten bounded inventory/name/search operations, and eight function-analysis +operations covering metadata, decompilation, assembly, resolved calls, typed +references, xrefs, CFG, and dossiers. GUI state and analysis mutations remain +unavailable through Ghidra. Extract Ghidra and install the JDK outside REA, then export absolute paths: @@ -101,8 +103,17 @@ 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. +One persistent decompiler is owned by the Program, Ghidra API calls cross a +bounded 32-request serial queue, and each native decompile is limited to 30 +seconds. Unresolved computed calls remain unknown, reference-kind provenance is +preserved, and provider-specific pseudocode is never treated as original source +or Hopper-equivalent text. + Run `GHIDRA_INSTALL_DIR=... npm run verify:ghidra` from a source checkout to -compile and analyze the source-owned debug and stripped conformance fixtures. +compile and analyze source-owned x86-64 debug/stripped ELF, AArch64 ELF, +x86-64 PE, and x86-64 Mach-O conformance fixtures. The verifier expects `cc`, +`clang`, and `lld-link` on `PATH`; `REA_CC`, `REA_CLANG`, and `REA_LLD_LINK` can +select alternate command paths. ## Diagnose, update, and remove diff --git a/docs/product-catalog.json b/docs/product-catalog.json index 2dd5409fa..3f8731857 100644 --- a/docs/product-catalog.json +++ b/docs/product-catalog.json @@ -143,15 +143,23 @@ "version": null, "capabilities": [ "address_name", + "analyze_function", "list_documents", "list_names", "list_procedures", "list_segments", "list_strings", "procedure_address", + "procedure_assembly", + "procedure_callees", + "procedure_callers", + "procedure_info", + "procedure_pseudo_code", + "procedure_references", "resolve_containing_procedure", "search_procedures", - "search_strings" + "search_strings", + "xrefs" ] }, { @@ -423,10 +431,10 @@ "mcp_resource_templates": 7 }, "digests": { - "tools_sha256": "8ca80bad31cd3f843b020fbef3c4b7da589e74345a2c7eec5edf18bd7f5f3bda", + "tools_sha256": "58a6f3049700072bbf3a4a81ed16b166f69b88a609d5806182c1d603459ccddc", "prompts_sha256": "cb1a0316708d1bdb5f4325c2000e466211b16070af8c927bc201340301f194c4", "resources_sha256": "e603aad57a79479004fbdc267644092e8365dd64d94ad772b9da4425a49abd73", - "combined_sha256": "8a3d3b22fdecc75a773dc2f6aba201ac9c61d4fdd69d341933a211410f72ccb3" + "combined_sha256": "c2e89ec36ca1191db9993a2d966c05206fe11d7d4286805794999c211143dd2e" } } } diff --git a/docs/provider-evaluation.md b/docs/provider-evaluation.md index d47715149..49fb56928 100644 --- a/docs/provider-evaluation.md +++ b/docs/provider-evaluation.md @@ -1,9 +1,9 @@ # Static-analysis provider evaluation -Status: the Ghidra read-only inventory provider is shipped. It validates an +Status: the Ghidra read-only analysis 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 +import, and publishes 18 operation-level capabilities after the authenticated post-analysis handshake. The provider-neutral target, provider registry, deterministic target binding, @@ -12,11 +12,12 @@ provider-process lifecycle foundations are implemented. The Ghidra launcher, packaged Java bridge, doctor/setup projection, bounded client lifecycle, and 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. +containing-procedure resolution, bounded search, function metadata, +decompilation, assembly, resolved calls, typed references, xrefs, CFG, and +function dossiers are admitted. A provider is not a drop-in replacement for +Hopper: every capability is mapped explicitly, with truthful `unavailable`, +unknown, 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, @@ -62,14 +63,15 @@ 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 the exact authenticated `ping`, `shutdown`, and ten -inventory methods, and deletes the socket. Close, cancellation, timeout, +inventory plus eight function-analysis 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 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. +The provider catalog lists only the 18 proved Ghidra operations. GUI cursor, +navigation, and mutation operations remain absent; the router therefore +reports them unavailable instead of borrowing Hopper semantics or inferring +capability from a successful import. ## Admitted inventory semantics @@ -83,13 +85,29 @@ semantics or inferring capability from a successful import. | 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. | +| Analysis state | The socket is exposed only after default auto-analysis. A 300-second analysis timeout fails target opening; ordinary established requests have a 10-second client deadline and every response has a 1 MiB 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. +## Admitted function-analysis semantics + +| Concern | Ghidra contract | +| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| Decompiler lifetime | One persistent `DecompInterface` is opened for the imported Program and disposed during bridge shutdown. Each native decompile has a 30-second deadline; the socket leaves a bounded 35-second projection window. External functions or functions without bodies return `null`; timeout, cancellation, and native failure remain distinct. | +| Serialization | A bounded FIFO admits at most 32 active-plus-queued requests and sends one Program request at a time. Queue wait counts against the caller's deadline, and queued cancellation is prompt. This is an adapter safety commitment, not a claim that every Ghidra API is thread-safe. | +| Function identity | Every function result carries the entry address and Ghidra FunctionManager classification for external, thunk, and resolved thunk target. These are observations, not proof that unresolved targetless calls have been recovered. | +| Assembly and pseudocode | Assembly is bounded Ghidra Listing text; pseudocode is bounded Ghidra decompiler output. Neither is original source, and cross-provider comparison never treats Hopper and Ghidra text as equal or unequal semantic facts. | +| Calls and references | Callers/callees contain only resolved functions. Reference edges preserve exact ReferenceManager type and call/jump/data/read/write/indirect/computed/conditional/terminal/external facts. Targetless computed flow remains unknown. Synthetic entry-point references without actionable memory sources are omitted explicitly. | +| CFG | Dossiers use `BasicBlockModel` and retain only non-call successors inside the function body. CFG topology is address-normalized for comparison; provider-specific block construction remains a declared difference. | +| Bounds | Direct assembly fails above 100,000 instructions or the wire ceiling. Dossiers scan at most 5,000 requested instructions, return bounded independent pages, mark unknown totals after an incomplete scan, and paginate pseudocode by Unicode code points. | + +`npm run verify:ghidra` compiles the versioned C oracles into x86-64 debug and +stripped ELF, AArch64 ELF, x86-64 PE, and x86-64 Mach-O targets. It proves all +18 operations, external functions, resolved thunks, exports, stripped-name +behavior, direct and targetless indirect calls, typed references, strings/xrefs, +multi-block CFG, semantic enhanced workflows, cancellation, deadlines, +serialized concurrency, malformed-target rejection, profile identity, and +process/project cleanup against real Ghidra 12.1.2. Unit fixtures separately +cover analysis/decompile timeouts, process exit, queue saturation, and malformed +wire output. ## Shared provider-process foundation @@ -109,19 +127,19 @@ only the generic process mechanisms. ## Shortlist -| 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 | 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. | +| 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 | Read-only analysis shipped: exact BYO checks, isolated state, bounded process and queue, packaged bridge, 18 admitted inventory/function operations, and real ELF/PE/Mach-O x86-64 plus AArch64 conformance. GUI and mutation semantics remain intentionally unavailable. | +| [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. | ## Recommended order 1. Use the implemented explicit provider registry and target binding without changing Hopper behavior. -2. Extend the admitted Ghidra inventory boundary with function capabilities - admitted individually through the shared conformance corpus. +2. Maintain the admitted Ghidra function boundary through the shared + conformance corpus and add formats or semantics only after real proof. 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 7bb80a7b6..9976b97a7 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -13,19 +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, 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. +post-analysis handshake, complete cleanup, ten admitted read-only inventory +operations, and eight function-analysis operations. Real source-owned x86-64 +debug/stripped ELF, AArch64 ELF, PE, and Mach-O fixtures cover program, +procedure, string, symbol, external/thunk, memory, resolution, search, +decompilation, assembly, calls, typed references, xrefs, and CFG semantics. -## Next Ghidra milestone +## Ghidra maintenance boundary -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. +Extend formats or semantics only with normalized provider-neutral contracts and +real source-owned conformance. Hopper and Ghidra pseudocode or assembly text is +not expected to match; unresolved targetless flow remains unknown. 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 525e82dfd..8508d5094 100644 --- a/scripts/verify-real-ghidra.mjs +++ b/scripts/verify-real-ghidra.mjs @@ -1,7 +1,7 @@ #!/usr/bin/env node import { execFile } from "node:child_process"; -import { access, mkdtemp, rm } from "node:fs/promises"; +import { access, mkdtemp, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { isAbsolute, join } from "node:path"; import { fileURLToPath } from "node:url"; @@ -9,6 +9,11 @@ import { promisify } from "node:util"; import { resolveGhidraAnalysisProfile } from "../dist/ghidra/GhidraAnalysisProfile.js"; import { GhidraClient } from "../dist/ghidra/GhidraClient.js"; +import { GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS } from "../dist/ghidra/GhidraDefaults.js"; +import { + parseGhidraFunctionInput, + parseGhidraFunctionResult, +} from "../dist/ghidra/GhidraFunctionValues.js"; import { parseGhidraInventoryResult } from "../dist/ghidra/GhidraInventoryValues.js"; import { inspectGhidraInstallation, @@ -42,18 +47,93 @@ const fixtureRoot = await mkdtemp(join(tmpdir(), "rea-ghidra-fixtures-")); const sourcePath = fileURLToPath( new URL("../tests/conformance/ghidra/inventory.c", import.meta.url), ); +const crossFormatSourcePath = fileURLToPath( + new URL("../tests/conformance/ghidra/cross-format.c", import.meta.url), +); const debugPath = join(fixtureRoot, "rea-ghidra-inventory-debug"); const strippedPath = join(fixtureRoot, "rea-ghidra-inventory-stripped"); +const arm64ElfPath = join(fixtureRoot, "rea-ghidra-cross-arm64"); +const peObjectPath = join(fixtureRoot, "rea-ghidra-cross-x86_64.obj"); +const pePath = join(fixtureRoot, "rea-ghidra-cross-x86_64.exe"); +const peImportLibraryPath = join(fixtureRoot, "rea-ghidra-cross-x86_64.lib"); +const machObjectPath = join(fixtureRoot, "rea-ghidra-cross-x86_64.o"); +const malformedPath = join(fixtureRoot, "rea-ghidra-malformed"); const compiler = process.env.REA_CC ?? "cc"; +const clang = process.env.REA_CLANG ?? "clang"; +const lldLink = process.env.REA_LLD_LINK ?? "lld-link"; try { 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]); + await exec(clang, [ + "--target=aarch64-linux-gnu", + "-O0", + "-g", + "-fno-inline", + "-fno-pie", + "-nostdlib", + "-static", + "-fuse-ld=lld", + crossFormatSourcePath, + "-Wl,-e,rea_cross_start", + "-o", + arm64ElfPath, + ]); + await exec(clang, [ + "--target=x86_64-pc-windows-msvc", + "-O0", + "-gcodeview", + "-fno-inline", + "-c", + crossFormatSourcePath, + "-o", + peObjectPath, + ]); + await exec(lldLink, [ + "/entry:rea_cross_start", + "/subsystem:console", + "/nodefaultlib", + "/export:rea_cross_entry", + `/implib:${peImportLibraryPath}`, + `/out:${pePath}`, + peObjectPath, + ]); + await exec(clang, [ + "--target=x86_64-apple-darwin", + "-O0", + "-g", + "-fno-inline", + "-c", + crossFormatSourcePath, + "-o", + machObjectPath, + ]); + await writeFile(malformedPath, Buffer.from("not-a-binary\n", "utf8")); - const debug = await verifyTarget(debugPath, "debug"); - const stripped = await verifyTarget(strippedPath, "stripped"); + const debug = await verifyTarget(debugPath, "debug", { + format: "elf", + architecture: "x86_64", + }); + const stripped = await verifyTarget(strippedPath, "stripped", { + format: "elf", + architecture: "x86_64", + }); + const arm64Elf = await verifyTarget(arm64ElfPath, "cross-arm64-elf", { + format: "elf", + architecture: "arm64", + }); + const pe = await verifyTarget(pePath, "cross-x86_64-pe", { + format: "pe", + architecture: "x86_64", + }); + const machObject = await verifyTarget(machObjectPath, "cross-x86_64-mach-o", { + format: "mach-o", + architecture: "x86_64", + }); assertDebugFixture(debug); assertStrippedFixture(stripped); + for (const fixture of [arm64Elf, pe, machObject]) assertCrossFixture(fixture); + await assertMalformedFixture(malformedPath); const customPath = process.env.GHIDRA_TARGET_PATH; const custom = @@ -62,8 +142,15 @@ try { `${JSON.stringify({ ok: true, provider: { id: "ghidra", version: SUPPORTED_GHIDRA_VERSION }, - fixture_source: sourcePath, - fixtures: [summary(debug), summary(stripped)], + fixture_sources: [sourcePath, crossFormatSourcePath], + fixtures: [ + summary(debug), + summary(stripped), + summary(arm64Elf), + summary(pe), + summary(machObject), + ], + malformed_target: "rejected-before-provider-start", custom_target: custom === null ? null : summary(custom), cleanup: "complete", })}\n`, @@ -72,9 +159,17 @@ try { await rm(fixtureRoot, { recursive: true, force: true }); } -async function verifyTarget(targetPath, variant) { +async function verifyTarget(targetPath, variant, expectedTarget = null) { const parsedTarget = await parseBinaryTarget(targetPath); if (!parsedTarget.ok) throw parsedTarget.error; + if ( + expectedTarget !== null && + (parsedTarget.value.format !== expectedTarget.format || + parsedTarget.value.architecture !== expectedTarget.architecture) + ) + throw new Error( + `Fixture header classification drifted for ${variant}: ${JSON.stringify(parsedTarget.value)}`, + ); const profile = await resolveGhidraAnalysisProfile( parsedTarget.value, GHIDRA_PROVIDER_IDENTITY, @@ -96,6 +191,7 @@ async function verifyTarget(targetPath, variant) { targetPath: parsedTarget.value.path, providerVersion: SUPPORTED_GHIDRA_VERSION, profileDigest: profile.value.profile.digest, + requestTimeoutMs: GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, }); let runtimeCoordinates; @@ -158,7 +254,16 @@ async function verifyInventoryOperations({ names, strings, }) { - const rejections = await verifyBridgeRejections(client); + if (variant.startsWith("cross-")) + return verifyCrossFormatOperations({ + client, + variant, + procedures, + names, + strings, + }); + const rejections = + variant === "debug" ? await verifyBridgeRejections(client) : null; const stringSearch = await call(client, "search_strings", { pattern: String.raw`^REA_GHIDRA_(?:INVENTORY_ENTRY|LEAF_VALUE)$`, mode: "regex", @@ -185,8 +290,13 @@ async function verifyInventoryOperations({ filteredStrings.items[0]?.address !== stringItem.address ) throw new Error("Ghidra exact-address string filter drifted"); - if (variant === "stripped") - return { rejections, stringSearch, filteredStrings }; + if (variant === "stripped") { + const functionAnalysis = await verifyStrippedFunctionOperations( + client, + stringItem, + ); + return { rejections, stringSearch, filteredStrings, functionAnalysis }; + } const entry = findValue(procedures, "rea_ghidra_inventory_entry"); if (entry === undefined) @@ -239,6 +349,11 @@ async function verifyInventoryOperations({ !filteredNames.items.some((item) => item.value === name.value) ) throw new Error("Ghidra exact-address name filter drifted"); + const functionAnalysis = await verifyDebugFunctionOperations(client, { + procedures, + strings, + entry, + }); return { rejections, addressName, @@ -248,6 +363,322 @@ async function verifyInventoryOperations({ stringSearch, filteredNames, filteredStrings, + functionAnalysis, + }; +} + +async function verifyDebugFunctionOperations( + client, + { procedures, strings, entry }, +) { + const leaf = requireProcedure(procedures, "rea_ghidra_inventory_leaf"); + const branch = requireProcedure(procedures, "rea_ghidra_inventory_branch"); + const indirect = requireProcedure( + procedures, + "rea_ghidra_inventory_indirect", + ); + const main = requireProcedure(procedures, "main"); + const entryString = strings.find( + (item) => item.value === "REA_GHIDRA_INVENTORY_ENTRY", + ); + if (entryString === undefined) + throw new Error("Ghidra debug string function probe is unavailable"); + + const [info, assembly, pseudocode, callees, callers, outgoing, entryXrefs] = + await Promise.all([ + functionCall(client, "procedure_info", { + document: null, + procedure: entry.value, + }), + functionCall(client, "procedure_assembly", { + document: null, + procedure: entry.value, + }), + functionCall(client, "procedure_pseudo_code", { + document: null, + procedure: entry.value, + }), + functionCall(client, "procedure_callees", { + document: null, + procedure: entry.value, + }), + functionCall(client, "procedure_callers", { + document: null, + procedure: entry.value, + }), + functionCall(client, "procedure_references", { + document: null, + procedure: entry.value, + direction: "outgoing", + }), + functionCall(client, "xrefs", { + document: null, + address: entry.address, + }), + ]); + assertLocalProcedureInfo(info, entry.address); + assertProviderText(assembly, pseudocode, entry.address); + for (const expected of [branch.address, indirect.address]) + if (!callees.includes(expected)) + throw new Error(`Ghidra call graph missed ${expected}`); + if (!callers.includes(main.address) || entryXrefs.length === 0) + throw new Error("Ghidra caller or xref relation missed main"); + const xrefOwners = []; + const xrefOwnerFailures = []; + for (const address of entryXrefs) { + try { + xrefOwners.push( + await call(client, "resolve_containing_procedure", { + document: null, + address, + }), + ); + } catch (cause) { + xrefOwnerFailures.push({ + address, + message: cause instanceof Error ? cause.message : String(cause), + }); + } + } + if ( + !xrefOwners.some( + (owner) => owner.found && owner.procedure.address === main.address, + ) + ) + throw new Error( + `Ghidra entry xrefs were not attributable to main: ${JSON.stringify({ entryXrefs, callers, xrefOwners, xrefOwnerFailures })}`, + ); + assertReferenceMetadata(outgoing); + const stringXrefs = await functionCall(client, "xrefs", { + document: null, + address: entryString.address, + }); + if (stringXrefs.length === 0) + throw new Error("Ghidra xrefs missed the entry string"); + + const entryDossier = await functionCall(client, "analyze_function", { + procedure: entry.address, + include_assembly: true, + limit: 500, + max_pseudocode_chars: 100_000, + max_instructions: 5_000, + }); + assertDossier(entryDossier, { + address: entry.address, + expectedCallees: [branch.address, indirect.address], + expectedString: "REA_GHIDRA_INVENTORY_ENTRY", + requireAssembly: true, + }); + + const branchDossier = await functionCall(client, "analyze_function", { + procedure: branch.address, + limit: 500, + max_pseudocode_chars: 100_000, + max_instructions: 5_000, + }); + assertDossier(branchDossier, { + address: branch.address, + expectedCallees: [leaf.address], + requireMultiBlock: true, + }); + + const indirectDossier = await functionCall(client, "analyze_function", { + procedure: indirect.address, + include_assembly: true, + limit: 500, + max_pseudocode_chars: 100_000, + max_instructions: 5_000, + }); + assertDossier(indirectDossier, { + address: indirect.address, + requireAssembly: true, + }); + if ( + indirectDossier.callees.items.some( + ({ address }) => address === leaf.address, + ) + ) + throw new Error( + "Ghidra dossier falsely resolved a targetless callback as the fixture leaf", + ); + if (!/\bcall\b/iu.test(indirectDossier.assembly.items.join("\n"))) + throw new Error("Ghidra indirect-call fixture lost its computed call site"); + + const aborted = new AbortController(); + aborted.abort(); + const cancelled = await client.callTool( + "procedure_info", + { document: null, procedure: entry.address }, + { signal: aborted.signal }, + ); + if (cancelled.ok || cancelled.error.kind !== "cancelled") + throw new Error("Ghidra established-request cancellation drifted"); + const timedOut = await client.callTool( + "procedure_info", + { document: null, procedure: entry.address }, + { timeoutMs: 0 }, + ); + if (timedOut.ok || timedOut.error.kind !== "timeout") + throw new Error("Ghidra established-request deadline drifted"); + const concurrent = await Promise.all([ + functionCall(client, "procedure_info", { + document: null, + procedure: entry.address, + }), + functionCall(client, "xrefs", { + document: null, + address: leaf.address, + }), + ]); + if (concurrent.length !== 2) + throw new Error("Ghidra serial request queue lost a concurrent result"); + + return { + entry: dossierSummary(entryDossier), + branch: dossierSummary(branchDossier), + indirect: dossierSummary(indirectDossier), + cancellation: "cancelled-before-wire", + timeout: "expired-before-wire", + concurrency: "serialized-two-results", + }; +} + +async function verifyStrippedFunctionOperations(client, entryString) { + const stringXrefs = await functionCall(client, "xrefs", { + document: null, + address: entryString.address, + }); + if (stringXrefs.length === 0) + throw new Error("Ghidra stripped string xref probe is unavailable"); + const containing = await call(client, "resolve_containing_procedure", { + document: null, + address: stringXrefs[0], + }); + if (!containing.found) + throw new Error("Ghidra could not recover a stripped containing function"); + const procedure = containing.procedure; + const pseudocode = await functionCall(client, "procedure_pseudo_code", { + document: null, + procedure: procedure.address, + }); + if (typeof pseudocode !== "string" || pseudocode.trim().length === 0) + throw new Error("Ghidra did not decompile the stripped function"); + const dossier = await functionCall(client, "analyze_function", { + procedure: procedure.address, + include_assembly: true, + limit: 500, + max_pseudocode_chars: 100_000, + max_instructions: 5_000, + }); + assertDossier(dossier, { + address: procedure.address, + expectedString: "REA_GHIDRA_INVENTORY_ENTRY", + requireAssembly: true, + }); + if (symbolTail(dossier.procedure.name) === "rea_ghidra_inventory_entry") + throw new Error("Ghidra stripped dossier invented a source symbol"); + return dossierSummary(dossier); +} + +async function verifyCrossFormatOperations({ + client, + variant, + procedures, + names, + strings, +}) { + const message = strings.find( + (item) => item.value === "REA_GHIDRA_CROSS_FORMAT", + ); + if (message === undefined) + throw new Error(`${variant} string inventory missed the source oracle`); + const entry = + procedures.find((item) => matchesSymbol(item.value, "rea_cross_entry")) ?? + names.find((item) => matchesSymbol(item.value, "rea_cross_entry")); + if (entry === undefined) + throw new Error(`${variant} did not retain the exported entry symbol`); + const entryAddress = entry.address; + const info = await functionCall(client, "procedure_info", { + document: null, + procedure: entryAddress, + }); + assertLocalProcedureInfo(info, entryAddress); + const [pseudocode, assembly, callees, messageXrefs] = await Promise.all([ + functionCall(client, "procedure_pseudo_code", { + document: null, + procedure: entryAddress, + }), + functionCall(client, "procedure_assembly", { + document: null, + procedure: entryAddress, + }), + functionCall(client, "procedure_callees", { + document: null, + procedure: entryAddress, + }), + functionCall(client, "xrefs", { + document: null, + address: message.address, + }), + ]); + assertProviderText(assembly, pseudocode, entryAddress); + if (callees.length < 2) + throw new Error(`${variant} call graph missed direct fixture calls`); + if (messageXrefs.length === 0) + throw new Error(`${variant} xrefs missed the fixture string`); + + let messageOwner = null; + for (const address of messageXrefs) { + const candidate = await call(client, "resolve_containing_procedure", { + document: null, + address, + }); + if (candidate.found) { + messageOwner = candidate; + break; + } + } + if (messageOwner === null) + throw new Error(`${variant} did not resolve the string-owning function`); + const stringDossier = await functionCall(client, "analyze_function", { + procedure: messageOwner.procedure.address, + limit: 500, + max_pseudocode_chars: 100_000, + max_instructions: 5_000, + }); + assertDossier(stringDossier, { + address: messageOwner.procedure.address, + expectedString: "REA_GHIDRA_CROSS_FORMAT", + }); + + let branchAddress = null; + for (const address of callees) { + const candidate = await functionCall(client, "procedure_info", { + document: null, + procedure: address, + }); + if (candidate.basicblock_count > 1) { + branchAddress = address; + break; + } + } + if (branchAddress === null) + throw new Error(`${variant} did not recover the multi-block callee`); + const branchDossier = await functionCall(client, "analyze_function", { + procedure: branchAddress, + limit: 500, + max_pseudocode_chars: 100_000, + max_instructions: 5_000, + }); + assertDossier(branchDossier, { + address: branchAddress, + requireMultiBlock: true, + }); + return { + entry: entryAddress, + exported_symbol: entry.value, + string_owner: dossierSummary(stringDossier), + branch: dossierSummary(branchDossier), }; } @@ -303,12 +734,149 @@ async function expectRemoteFailure(client, operation, parameters, code) { async function call(client, operation, parameters) { const called = await client.callTool(operation, parameters); - if (!called.ok) throw called.error; + if (!called.ok) + throw new Error( + `Ghidra ${operation} failed for ${JSON.stringify(parameters)}: ${called.error.message}`, + { cause: called.error }, + ); const parsed = parseGhidraInventoryResult(operation, called.value); if (!parsed.ok) throw parsed.error; return parsed.value; } +async function functionCall(client, operation, parameters) { + const input = parseGhidraFunctionInput(operation, parameters); + if (!input.ok) throw input.error; + const called = await client.callTool(operation, input.value); + if (!called.ok) + throw new Error( + `Ghidra ${operation} failed for ${JSON.stringify(input.value)}: ${called.error.message}`, + { cause: called.error }, + ); + const parsed = parseGhidraFunctionResult(operation, called.value); + if (!parsed.ok) throw parsed.error; + return parsed.value; +} + +function assertLocalProcedureInfo(info, expectedAddress) { + if ( + info.entrypoint !== expectedAddress || + info.basicblock_count < 1 || + info.length < 1 || + typeof info.signature !== "string" || + info.signature.length === 0 || + info.classification.external || + info.classification.provenance !== "ghidra-function-manager" + ) + throw new Error( + `Ghidra procedure metadata drifted: ${JSON.stringify(info)}`, + ); +} + +function assertProviderText(assembly, pseudocode, expectedAddress) { + if ( + typeof assembly !== "string" || + !assembly.includes(`${expectedAddress}:`) || + assembly.trim().length === 0 + ) + throw new Error("Ghidra assembly rendering lost its address-bearing lines"); + if (typeof pseudocode !== "string" || pseudocode.trim().length === 0) + throw new Error("Ghidra local function pseudocode is unavailable"); +} + +function assertReferenceMetadata(observed) { + if ( + observed.instructions_scanned < 1 || + observed.instruction_scan_truncated || + observed.references.items.length === 0 || + !observed.references.items.every( + ({ kind }) => + kind.available && kind.provenance === "ghidra-reference-manager", + ) || + !observed.references.items.some(({ kind }) => kind.call) || + !observed.references.items.some(({ kind }) => kind.data) + ) + throw new Error( + `Ghidra typed reference metadata drifted: ${JSON.stringify(observed)}`, + ); +} + +function assertDossier( + dossier, + { + address, + expectedCallees = [], + expectedString = null, + requireAssembly = false, + requireMultiBlock = false, + }, +) { + if ( + dossier.procedure.address !== address || + dossier.procedure.classification === null || + dossier.procedure.classification.provenance !== "ghidra-function-manager" || + dossier.procedure.classification.external || + dossier.pseudocode.text.trim().length === 0 || + dossier.pseudocode.returned_chars !== [...dossier.pseudocode.text].length || + dossier.instruction_scan.scanned < 1 || + dossier.instruction_scan.truncated || + !dossier.limitations.some((value) => /indirect|computed/u.test(value)) || + !dossier.limitations.some((value) => /Ghidra|Hopper|provider/u.test(value)) + ) + throw new Error( + `Ghidra dossier truthfulness drifted: ${JSON.stringify(dossier)}`, + ); + if ( + ![ + ...dossier.incoming_references.items, + ...dossier.outgoing_references.items, + ].every( + ({ kind }) => + kind.available && kind.provenance === "ghidra-reference-manager", + ) + ) + throw new Error("Ghidra dossier lost typed reference provenance"); + for (const expected of expectedCallees) + if (!dossier.callees.items.some(({ address: value }) => value === expected)) + throw new Error(`Ghidra dossier missed callee ${expected}`); + if ( + expectedString !== null && + !dossier.referenced_strings.items.some( + ({ value }) => value === expectedString, + ) + ) + throw new Error( + `Ghidra dossier missed referenced string ${expectedString}`, + ); + if ( + requireAssembly && + (dossier.assembly.items.length === 0 || dossier.assembly.truncated) + ) + throw new Error("Ghidra dossier assembly was unavailable or truncated"); + if ( + requireMultiBlock && + (dossier.basic_blocks.items.length < 2 || + !dossier.basic_blocks.items.some( + ({ successors }) => successors.length > 0, + )) + ) + throw new Error( + "Ghidra dossier CFG missed the multi-block branch structure", + ); +} + +function dossierSummary(dossier) { + return { + address: dossier.procedure.address, + pseudocode_chars: dossier.pseudocode.total_chars, + instructions: dossier.instruction_scan.scanned, + callees: dossier.callees.returned, + outgoing_references: dossier.outgoing_references.returned, + referenced_strings: dossier.referenced_strings.returned, + basic_blocks: dossier.basic_blocks.returned, + }; +} + async function allItems(client, operation, parameters) { const items = []; let offset = 0; @@ -381,6 +949,29 @@ function assertStrippedFixture(observed) { assertSegments(observed.segments, observed.session.target.image_base); } +function assertCrossFixture(observed) { + if ( + observed.procedures.length === 0 || + observed.names.length === 0 || + observed.probes === null || + typeof observed.probes.entry !== "string" || + observed.probes.string_owner.referenced_strings < 1 || + observed.probes.branch.basic_blocks < 2 + ) + throw new Error( + `Cross-format Ghidra semantics drifted: ${JSON.stringify(summary(observed))}`, + ); + assertSegments(observed.segments, observed.session.target.image_base); +} + +async function assertMalformedFixture(path) { + const parsed = await parseBinaryTarget(path); + if (parsed.ok || parsed.error._tag !== "BinaryTargetError") + throw new Error( + "Malformed executable was not rejected before provider start", + ); +} + function assertStrings(strings) { for (const expected of [ "REA_GHIDRA_INVENTORY_ENTRY", @@ -417,6 +1008,18 @@ function findValue(items, expected) { return items.find((item) => symbolTail(item.value) === expected); } +function requireProcedure(items, expected) { + const observed = findValue(items, expected); + if (observed === undefined) + throw new Error(`Ghidra procedure probe is unavailable: ${expected}`); + return observed; +} + +function matchesSymbol(value, expected) { + const tail = symbolTail(value); + return tail === expected || tail === `_${expected}`; +} + function symbolTail(value) { if (typeof value !== "string") return undefined; return value.split("::").at(-1); diff --git a/src/contracts/enhancedInputs.ts b/src/contracts/enhancedInputs.ts index 2167d3ac5..689f1be3c 100644 --- a/src/contracts/enhancedInputs.ts +++ b/src/contracts/enhancedInputs.ts @@ -7,12 +7,12 @@ export const enhancedInputSchemas = { get_objc_protocols: z.object({}), batch_decompile: z.object({ addresses: z - .array(z.string().describe("A Hopper address")) + .array(z.string().describe("A provider-normalized procedure address")) .max(20) .default([]), }), get_call_graph: z.object({ - address: z.string().describe("A Hopper address"), + address: z.string().describe("A provider-normalized procedure address"), direction: z.enum(["forward", "backward"]).default("forward"), depth: z.number().int().min(1).max(5).default(2), }), diff --git a/src/contracts/toolContracts.ts b/src/contracts/toolContracts.ts index 132ac1a16..cedf50b7a 100644 --- a/src/contracts/toolContracts.ts +++ b/src/contracts/toolContracts.ts @@ -251,12 +251,12 @@ export const OFFICIAL_TOOL_CONTRACTS = [ ), official( "procedure_callees", - "Return Hopper's analyzed direct callees for one procedure identified by symbol or address. Indirect calls may be absent; use analyze_function and xrefs to corroborate the call path.", + "Return the provider's resolved direct callees for one procedure identified by symbol or address. Unresolved indirect calls may be absent; use analyze_function and typed references to preserve available edge uncertainty.", z.object({ procedure, document }), ), official( "procedure_callers", - "Return Hopper's analyzed direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit indirect references.", + "Return the provider's resolved direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit unresolved indirect references.", z.object({ procedure, document }), ), official( @@ -266,7 +266,7 @@ export const OFFICIAL_TOOL_CONTRACTS = [ ), official( "procedure_references", - "Return a bounded set of raw incoming or outgoing reference edges for one procedure. Endpoint procedures are resolved only when Hopper reports containment; reference kinds remain explicitly unavailable.", + "Return a bounded set of raw incoming or outgoing reference edges for one procedure. Endpoint procedures are resolved only from provider containment; Ghidra preserves observed reference kinds while providers without kind authority mark them unavailable.", z.object({ procedure, direction: z.enum(["incoming", "outgoing"]).default("outgoing"), @@ -278,7 +278,7 @@ export const OFFICIAL_TOOL_CONTRACTS = [ ), official( "procedure_pseudo_code", - "Decompile one analyzed procedure by symbol name or hexadecimal address. Returns Hopper pseudocode, not original source, and may return null; request procedure_assembly when instruction precision matters.", + "Decompile one analyzed procedure by symbol name or provider-normalized address. Returns provider-specific pseudocode, never original source or cross-provider text equivalence, and may return null; request procedure_assembly when instruction precision matters.", z.object({ procedure, document }), ), official( @@ -365,7 +365,7 @@ export const ENHANCED_TOOL_CONTRACTS = [ ), enhanced( "get_call_graph", - "Traverse Hopper's caller or callee relationships from one symbol or address for at most five levels. Every node has an ok/error status and failures use safe typed projections; indirect calls may be missing and results are not a whole-program CFG.", + "Traverse the bound provider's caller or callee relationships from one symbol or address for at most five levels. Every node has an ok/error status and failures use safe typed projections; unresolved indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph, ), enhanced( @@ -375,7 +375,7 @@ export const ENHANCED_TOOL_CONTRACTS = [ ), enhanced( "find_xrefs_to_name", - "Resolve an exact name through Hopper's exhaustively paged name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; xrefs remain untyped.", + "Resolve an exact name through the bound provider's exhaustively paged name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; this compact xref workflow returns address-only projections.", enhancedInputSchemas.find_xrefs_to_name, ), enhanced( @@ -385,7 +385,7 @@ export const ENHANCED_TOOL_CONTRACTS = [ ), enhanced( "analyze_function", - "Preferred bounded analysis for one procedure symbol or address. Returns identity, pseudocode, optional assembly, comments, calls, incoming references, and blocks; unsupported outgoing references and CFG edges carry explicit unavailable metadata.", + "Preferred bounded analysis for one procedure symbol or address. Returns identity, provider-specific pseudocode, optional assembly, comments, calls, typed-or-explicitly-unavailable references, referenced strings/names, and local CFG blocks with exact truncation metadata.", enhancedInputSchemas.analyze_function, ), enhanced( diff --git a/src/contracts/toolOutputSchemas.ts b/src/contracts/toolOutputSchemas.ts index f2e7930a8..d7b55a173 100644 --- a/src/contracts/toolOutputSchemas.ts +++ b/src/contracts/toolOutputSchemas.ts @@ -6,7 +6,13 @@ import { } from "../domain/processCapture.js"; import { evidenceBundleSchema } from "../domain/evidenceBundle.js"; import { residualUnknownSchema } from "../domain/residualUnknown.js"; -import { functionDossierSchema } from "../domain/hopperValues.js"; +import { + functionDossierSchema, + localVariableSchema, + procedureClassificationSchema, + procedureIdentitySchema, + referenceKindSchema, +} from "../domain/hopperValues.js"; import { demangleSwiftSchema, inspectMachoSchema, @@ -232,11 +238,8 @@ const sessionProvider = z.object({ const nullableText = z.string().nullable(); const addressList = z.array(z.string()); const addressedEntry = z.object({ address: z.string(), name: z.string() }); -const procedureIdentity = z.object({ address: z.string(), name: z.string() }); -const localVariable = z.object({ - description: z.string(), - provenance: z.literal("hopper-public-python-api"), -}); +const procedureIdentity = procedureIdentitySchema; +const localVariable = localVariableSchema; const containingProcedureResolution = z.discriminatedUnion("found", [ z.object({ query_address: z.string(), @@ -336,6 +339,7 @@ const procedureInfoOutput = resultOf( length: z.number().min(0), signature: nullableText, locals: z.array(localVariable), + classification: procedureClassificationSchema.nullable().default(null), }), ); const symbolDiscoveryOutput = (property: "classes" | "protocols") => @@ -391,7 +395,7 @@ export const officialOutputSchemas: Readonly> = { target_address: z.string(), source_procedure: procedureIdentity.nullable(), target_procedure: procedureIdentity.nullable(), - kind: unavailable, + kind: referenceKindSchema, }), ), instructions_scanned: z.number().int().min(0), diff --git a/src/domain/functionComparison.ts b/src/domain/functionComparison.ts index ccfbe99eb..9e6ac7e86 100644 --- a/src/domain/functionComparison.ts +++ b/src/domain/functionComparison.ts @@ -13,6 +13,7 @@ import { isAutoName, normalizeCfg, project, + referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, @@ -359,16 +360,30 @@ const compareReferences = ( rightCount: rightProjection.length, textDelta: null, limitations: [ - "Reference endpoints differ; exact reference kinds remain unavailable.", + "Reference endpoints differ independently of provider reference-kind metadata.", ], }); + const leftKinds = referenceKindProjection(left); + const rightKinds = referenceKindProjection(right); + if (leftKinds !== null && rightKinds !== null) + return compareValues( + "references", + leftKinds, + rightKinds, + links, + true, + true, + providersDiffer, + ); return unresolvedDimension( "references", "unknown", links, leftProjection.length, rightProjection.length, - ["Reference kinds are unavailable in the current dossier contract."], + [ + "At least one provider did not expose reference kinds, so equal endpoints do not prove equal edge semantics.", + ], ); }; diff --git a/src/domain/functionComparisonNormalization.ts b/src/domain/functionComparisonNormalization.ts index ea7d6cf73..c4efc9078 100644 --- a/src/domain/functionComparisonNormalization.ts +++ b/src/domain/functionComparisonNormalization.ts @@ -83,6 +83,49 @@ export const referenceProjection = (snapshot: FunctionSnapshot) => })), ]); +export const referenceKindProjection = ( + snapshot: FunctionSnapshot, +): readonly unknown[] | null => { + const edges = [ + ...snapshot.collections.incoming_references.items.map((edge) => ({ + direction: "in", + edge, + })), + ...snapshot.collections.outgoing_references.items.map((edge) => ({ + direction: "out", + edge, + })), + ]; + if (edges.some(({ edge }) => !edge.kind.available)) return null; + return sorted( + edges.map(({ direction, edge }) => { + if (!edge.kind.available) + throw new TypeError( + "Reference-kind availability changed during projection", + ); + return { + direction, + source: edge.source_procedure?.name ?? null, + target: edge.target_procedure?.name ?? null, + type: edge.kind.type, + flow: edge.kind.flow, + call: edge.kind.call, + jump: edge.kind.jump, + data: edge.kind.data, + read: edge.kind.read, + write: edge.kind.write, + indirect: edge.kind.indirect, + computed: edge.kind.computed, + conditional: edge.kind.conditional, + terminal: edge.kind.terminal, + primary: edge.kind.primary, + operand_index: edge.kind.operand_index, + external: edge.kind.external, + }; + }), + ); +}; + export const commentProjection = ( snapshot: FunctionSnapshot, ): readonly unknown[] | null => { diff --git a/src/domain/functionDossierEvidence.ts b/src/domain/functionDossierEvidence.ts index 8cbcc00bc..2628c90e0 100644 --- a/src/domain/functionDossierEvidence.ts +++ b/src/domain/functionDossierEvidence.ts @@ -95,7 +95,12 @@ export const parseFunctionEvidence = (input: unknown): FunctionSnapshot => { collections, instructionScan: first.dossier.instruction_scan, limitations: [ - ...new Set(pages.flatMap(({ evidence }) => evidence.limitations)), + ...new Set( + pages.flatMap(({ evidence, dossier }) => [ + ...evidence.limitations, + ...dossier.limitations, + ]), + ), ].sort((left, right) => left.localeCompare(right)), }; }; diff --git a/src/domain/hopperValues.ts b/src/domain/hopperValues.ts index a643282a6..6ac088ec2 100644 --- a/src/domain/hopperValues.ts +++ b/src/domain/hopperValues.ts @@ -86,16 +86,28 @@ const addressedPageSchema = z }); } }); -const unavailableSchema = z +const unavailableAnalysisFactSchema = z .object({ available: z.literal(false), reason: z.string() }) .strict(); -const procedureIdentitySchema = z - .object({ address: z.string(), name: z.string() }) +export const procedureClassificationSchema = z + .object({ + external: z.boolean(), + thunk: z.boolean(), + thunk_target: z.string().nullable(), + provenance: z.string().min(1), + }) .strict(); -const localVariableSchema = z +export const procedureIdentitySchema = z + .object({ + address: z.string(), + name: z.string(), + classification: procedureClassificationSchema.nullable().default(null), + }) + .strict(); +export const localVariableSchema = z .object({ description: z.string(), - provenance: z.literal("hopper-public-python-api"), + provenance: z.string().min(1), }) .strict(); const boundedSchema = (item: T) => @@ -131,13 +143,37 @@ const boundedSchema = (item: T) => }); } }); +const availableReferenceKindSchema = z + .object({ + available: z.literal(true), + provenance: z.string().min(1), + type: z.string(), + flow: z.boolean(), + call: z.boolean(), + jump: z.boolean(), + data: z.boolean(), + read: z.boolean(), + write: z.boolean(), + indirect: z.boolean(), + computed: z.boolean(), + conditional: z.boolean(), + terminal: z.boolean(), + primary: z.boolean(), + operand_index: z.number().int(), + external: z.boolean(), + }) + .strict(); +export const referenceKindSchema = z.discriminatedUnion("available", [ + unavailableAnalysisFactSchema, + availableReferenceKindSchema, +]); const referenceEdgeSchema = z .object({ source_address: z.string(), target_address: z.string(), source_procedure: procedureIdentitySchema.nullable(), target_procedure: procedureIdentitySchema.nullable(), - kind: unavailableSchema, + kind: referenceKindSchema, }) .strict(); export const functionDossierSchema = z @@ -146,6 +182,7 @@ export const functionDossierSchema = z .object({ address: z.string(), name: z.string(), + classification: procedureClassificationSchema.nullable().default(null), signature: z.string().nullable(), locals: z.array(localVariableSchema), }) @@ -226,13 +263,14 @@ export const functionDossierSchema = z instruction_scan: z .object({ scanned: z.number().int().min(0), truncated: z.boolean() }) .strict(), + limitations: z.array(z.string()).default([]), }) .strict(); /** Strict analyzed-function dossier shared by provider and comparison boundaries. */ export type FunctionDossier = z.infer; -/** Strictly parse a complete Hopper function dossier at the provider boundary. */ +/** Strictly parse a complete provider-neutral function dossier. */ export const parseFunctionDossier = ( value: JsonValue, ): Result => { diff --git a/src/ghidra/GhidraClient.ts b/src/ghidra/GhidraClient.ts index 51289c38f..2d4059197 100644 --- a/src/ghidra/GhidraClient.ts +++ b/src/ghidra/GhidraClient.ts @@ -16,6 +16,7 @@ import { } from "../process/ProviderProcess.js"; import { GHIDRA_MAX_LINE_BYTES, + GHIDRA_MAX_QUEUED_REQUESTS, GHIDRA_REQUEST_TIMEOUT_MS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js"; @@ -25,10 +26,12 @@ import type { GhidraStartResult, } from "./GhidraClientTypes.js"; import type { GhidraInventoryOperation } from "./GhidraInventoryValues.js"; +import type { GhidraFunctionOperation } from "./GhidraFunctionValues.js"; import { createGhidraDiagnostics } from "./GhidraDiagnostics.js"; import type { GhidraLaunch } from "./GhidraLauncher.js"; import { GhidraResponseBuffer } from "./GhidraResponseBuffer.js"; import { GhidraResponseRouter } from "./GhidraResponseRouter.js"; +import { GhidraRequestQueue } from "./GhidraRequestQueue.js"; import { bindGhidraSessionFailure, GhidraSessionError, @@ -53,6 +56,11 @@ export type { GhidraStartResult, } from "./GhidraClientTypes.js"; +/** Closed Java-bridge operation union callable after the exact handshake. */ +export type GhidraOperation = + | GhidraInventoryOperation + | GhidraFunctionOperation; + /** Owns one authenticated, private, read-only Ghidra headless session. */ export class GhidraClient { readonly #options: Required< @@ -79,6 +87,7 @@ export class GhidraClient { #startPromise: Promise | undefined; #closePromise: Promise | undefined; readonly #failure = bindGhidraSessionFailure(() => this.#diagnostics()); + readonly #requestQueue: GhidraRequestQueue; readonly #responseRouter = new GhidraResponseRouter({ pending: this.#pending, nextId: () => this.#nextId, @@ -110,6 +119,18 @@ export class GhidraClient { requestTimeoutMs: options.requestTimeoutMs ?? GHIDRA_REQUEST_TIMEOUT_MS, startupTimeoutMs: options.startupTimeoutMs ?? GHIDRA_STARTUP_TIMEOUT_MS, }; + this.#requestQueue = new GhidraRequestQueue( + GHIDRA_MAX_QUEUED_REQUESTS, + (method, parameters, requestOptions) => + this.#request(method, parameters, requestOptions), + (kind, message, timeoutMs) => + this.#failure( + kind, + message, + undefined, + timeoutMs === undefined ? {} : { timeoutMs }, + ), + ); } /** Launch Ghidra once and require its exact post-analysis handshake. */ @@ -150,15 +171,18 @@ export class GhidraClient { return this.#parseSessionInfo(result.value); } - /** Execute one admitted inventory operation after the exact session handshake. */ + /** Execute one admitted operation through the bounded per-Program queue. */ async callTool( - operation: GhidraInventoryOperation, + operation: GhidraOperation, parameters: Readonly>, options: GhidraRequestOptions = {}, ): Promise> { const started = await this.start(options.signal); if (!started.ok) return started; - return this.#request(operation, parameters, options); + return this.#requestQueue.run(operation, parameters, { + ...(options.signal === undefined ? {} : { signal: options.signal }), + timeoutMs: options.timeoutMs ?? this.#options.requestTimeoutMs, + }); } /** Stop the owned process group and remove all project/runtime artifacts. */ @@ -406,6 +430,9 @@ export class GhidraClient { async #cleanup(): Promise { this.#closing = true; try { + this.#requestQueue.failQueued( + this.#failure("process", "Ghidra session closed"), + ); const socket = this.#socket; if (socket !== undefined && !socket.destroyed) { const shutdown = await this.#request( diff --git a/src/ghidra/GhidraDefaults.ts b/src/ghidra/GhidraDefaults.ts index efcfd673b..4b66336e8 100644 --- a/src/ghidra/GhidraDefaults.ts +++ b/src/ghidra/GhidraDefaults.ts @@ -8,7 +8,13 @@ export const GHIDRA_MAX_HEAP = "2G"; export const GHIDRA_STARTUP_TIMEOUT_MS = 330_000; /** Default bounded wait for one established bridge request. */ export const GHIDRA_REQUEST_TIMEOUT_MS = 10_000; +/** Per-function ceiling passed to Ghidra's native decompiler process. */ +export const GHIDRA_DECOMPILE_TIMEOUT_SECONDS = 30; +/** Socket deadline leaves bounded time to project a native decompiler timeout. */ +export const GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS = 35_000; +/** Maximum active plus queued calls for one serial headless Program. */ +export const GHIDRA_MAX_QUEUED_REQUESTS = 32; /** 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 = 2; +export const GHIDRA_BRIDGE_VERSION = 3; diff --git a/src/ghidra/GhidraFunctionValues.ts b/src/ghidra/GhidraFunctionValues.ts new file mode 100644 index 000000000..3a0114718 --- /dev/null +++ b/src/ghidra/GhidraFunctionValues.ts @@ -0,0 +1,329 @@ +import { z } from "zod"; + +import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js"; +import { + functionDossierSchema, + type FunctionDossier, +} from "../domain/hopperValues.js"; +import { + jsonObjectSchema, + jsonValueSchema, + type JsonValue, +} from "../domain/jsonValue.js"; +import { err, ok, type Result } from "../domain/result.js"; +import { + ghidraBoundedIdentifierSchema, + ghidraCanonicalAddressSchema, +} from "./GhidraInventoryValues.js"; + +/** Read-only function operations admitted by the Ghidra adapter. */ +export const GHIDRA_FUNCTION_OPERATIONS = [ + "analyze_function", + "procedure_assembly", + "procedure_callees", + "procedure_callers", + "procedure_info", + "procedure_pseudo_code", + "procedure_references", + "xrefs", +] as const; + +/** One function-analysis operation implemented by the packaged Java bridge. */ +export type GhidraFunctionOperation = + (typeof GHIDRA_FUNCTION_OPERATIONS)[number]; + +const operationSet: ReadonlySet = new Set(GHIDRA_FUNCTION_OPERATIONS); + +/** Narrow an application operation to the Ghidra function-analysis surface. */ +export const isGhidraFunctionOperation = ( + operation: string, +): operation is GhidraFunctionOperation => operationSet.has(operation); + +const document = ghidraBoundedIdentifierSchema.nullable().default(null); +const procedure = ghidraBoundedIdentifierSchema; +const directProcedure = { document, procedure }; +const collectionOffsets = z + .object({ + comments: z.number().int().min(0).default(0), + callers: z.number().int().min(0).default(0), + callees: z.number().int().min(0).default(0), + incoming_references: z.number().int().min(0).default(0), + outgoing_references: z.number().int().min(0).default(0), + referenced_strings: z.number().int().min(0).default(0), + referenced_names: z.number().int().min(0).default(0), + basic_blocks: z.number().int().min(0).default(0), + }) + .strict() + .default({ + comments: 0, + callers: 0, + callees: 0, + incoming_references: 0, + outgoing_references: 0, + referenced_strings: 0, + referenced_names: 0, + basic_blocks: 0, + }); + +const inputSchemas = { + analyze_function: z + .object({ + procedure, + include_assembly: z.boolean().default(false), + limit: z.number().int().min(1).max(500).default(100), + max_pseudocode_chars: z + .number() + .int() + .min(1) + .max(100_000) + .default(20_000), + max_instructions: z.number().int().min(1).max(5_000).default(500), + pseudocode_offset: z.number().int().min(0).default(0), + assembly_offset: z.number().int().min(0).default(0), + collection_offset: collectionOffsets, + }) + .strict(), + procedure_assembly: z.object(directProcedure).strict(), + procedure_callees: z.object(directProcedure).strict(), + procedure_callers: z.object(directProcedure).strict(), + procedure_info: z.object(directProcedure).strict(), + procedure_pseudo_code: z.object(directProcedure).strict(), + procedure_references: z + .object({ + ...directProcedure, + direction: z.enum(["incoming", "outgoing"]).default("outgoing"), + offset: z.number().int().min(0).default(0), + limit: z.number().int().min(1).max(500).default(100), + max_instructions: z.number().int().min(1).max(5_000).default(500), + }) + .strict(), + xrefs: z.object({ document, address: ghidraCanonicalAddressSchema }).strict(), +} satisfies Readonly>; + +/** Validate and default one function request before it crosses the socket. */ +export const parseGhidraFunctionInput = ( + operation: GhidraFunctionOperation, + value: Readonly>, +): Result>, AnalysisInputError> => { + const parsed = inputSchemas[operation].safeParse(value); + return parsed.success + ? ok(jsonObjectSchema.parse(parsed.data)) + : err(new AnalysisInputError(operation, { cause: parsed.error })); +}; + +const classification = z + .object({ + external: z.boolean(), + thunk: z.boolean(), + thunk_target: ghidraCanonicalAddressSchema.nullable(), + provenance: z.literal("ghidra-function-manager"), + }) + .strict(); +const procedureIdentity = z + .object({ + address: ghidraCanonicalAddressSchema, + name: z.string().min(1), + classification, + }) + .strict(); +const localVariable = z + .object({ + description: z.string(), + provenance: z.literal("ghidra-function-database"), + }) + .strict(); +const referenceKind = z + .object({ + available: z.literal(true), + provenance: z.literal("ghidra-reference-manager"), + type: z.string().min(1), + flow: z.boolean(), + call: z.boolean(), + jump: z.boolean(), + data: z.boolean(), + read: z.boolean(), + write: z.boolean(), + indirect: z.boolean(), + computed: z.boolean(), + conditional: z.boolean(), + terminal: z.boolean(), + primary: z.boolean(), + operand_index: z.number().int(), + external: z.boolean(), + }) + .strict(); +const referenceEdge = z + .object({ + source_address: ghidraCanonicalAddressSchema, + target_address: ghidraCanonicalAddressSchema, + source_procedure: procedureIdentity.nullable(), + target_procedure: procedureIdentity.nullable(), + kind: referenceKind, + }) + .strict(); +const boundedReferences = z + .object({ + items: z.array(referenceEdge), + total: z.number().int().min(0).nullable(), + returned: z.number().int().min(0), + truncated: z.boolean(), + next_offset: z.number().int().min(0).nullable(), + }) + .strict() + .superRefine((value, context) => { + if (value.returned !== value.items.length) + context.addIssue({ + code: "custom", + path: ["returned"], + message: "returned must equal the number of reference items", + }); + if (value.total !== null && value.total < value.returned) + context.addIssue({ + code: "custom", + path: ["total"], + message: "total cannot be smaller than returned", + }); + if (value.next_offset !== null && !value.truncated) + context.addIssue({ + code: "custom", + path: ["next_offset"], + message: "a continuation requires truncated output", + }); + }); +const procedureReferences = z + .object({ + procedure: procedureIdentity, + direction: z.enum(["incoming", "outgoing"]), + references: boundedReferences, + instructions_scanned: z.number().int().min(0), + instruction_scan_truncated: z.boolean(), + }) + .strict(); +const procedureInfo = z + .object({ + name: z.string().min(1), + entrypoint: ghidraCanonicalAddressSchema, + basicblock_count: z.number().int().min(0), + length: z.number().int().min(0), + signature: z.string().nullable(), + locals: z.array(localVariable), + classification, + }) + .strict(); + +const ghidraFunctionDossier = functionDossierSchema.superRefine( + (value, context) => { + const addresses = [ + value.procedure.address, + ...value.comments.items.map(({ address }) => address), + ...value.callers.items.map(({ address }) => address), + ...value.callees.items.map(({ address }) => address), + ...value.incoming_references.items.flatMap(referenceAddresses), + ...value.outgoing_references.items.flatMap(referenceAddresses), + ...value.referenced_strings.items.flatMap( + ({ address, source_address }) => [address, source_address], + ), + ...value.referenced_names.items.flatMap(({ address, source_address }) => [ + address, + source_address, + ]), + ...value.basic_blocks.items.flatMap(({ start, end, successors }) => [ + start, + end, + ...successors, + ]), + ]; + if ( + addresses.some( + (address) => !ghidraCanonicalAddressSchema.safeParse(address).success, + ) + ) + context.addIssue({ + code: "custom", + message: "Ghidra dossier contains a non-canonical address", + }); + const identities = [ + value.procedure, + ...value.callers.items, + ...value.callees.items, + ...value.incoming_references.items.flatMap(referenceProcedures), + ...value.outgoing_references.items.flatMap(referenceProcedures), + ]; + if ( + identities.some( + ({ classification: facts }) => !classification.safeParse(facts).success, + ) + ) + context.addIssue({ + code: "custom", + message: "Ghidra dossier omitted function classification", + }); + if ( + value.procedure.locals.some( + (variable) => !localVariable.safeParse(variable).success, + ) || + [ + ...value.incoming_references.items, + ...value.outgoing_references.items, + ].some(({ kind }) => !referenceKind.safeParse(kind).success) + ) + context.addIssue({ + code: "custom", + message: "Ghidra dossier contains invalid provenance", + }); + if ( + !value.limitations.some((item) => /indirect|computed/u.test(item)) || + !value.limitations.some((item) => /provider|Ghidra|Hopper/u.test(item)) + ) + context.addIssue({ + code: "custom", + message: "Ghidra dossier omitted required uncertainty limitations", + }); + }, +); + +const resultSchemas = { + analyze_function: ghidraFunctionDossier, + procedure_assembly: z.string(), + procedure_callees: z.array(ghidraCanonicalAddressSchema), + procedure_callers: z.array(ghidraCanonicalAddressSchema), + procedure_info: procedureInfo, + procedure_pseudo_code: z.string().nullable(), + procedure_references: procedureReferences, + xrefs: z.array(ghidraCanonicalAddressSchema), +} satisfies Readonly>; + +/** Require exact, bounded Java-bridge function output before creating Evidence. */ +export const parseGhidraFunctionResult = ( + operation: GhidraFunctionOperation, + 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 function-analysis contract", + { cause: parsed.error }, + ), + ); +}; + +const referenceAddresses = ( + edge: FunctionDossier["incoming_references"]["items"][number], +): readonly string[] => [ + edge.source_address, + edge.target_address, + ...(edge.source_procedure === null ? [] : [edge.source_procedure.address]), + ...(edge.target_procedure === null ? [] : [edge.target_procedure.address]), +]; + +const referenceProcedures = ( + edge: FunctionDossier["incoming_references"]["items"][number], +): readonly NonNullable< + FunctionDossier["incoming_references"]["items"][number]["source_procedure"] +>[] => [ + ...(edge.source_procedure === null ? [] : [edge.source_procedure]), + ...(edge.target_procedure === null ? [] : [edge.target_procedure]), +]; diff --git a/src/ghidra/GhidraInventoryValues.ts b/src/ghidra/GhidraInventoryValues.ts index 004ee79e8..6b96f0f57 100644 --- a/src/ghidra/GhidraInventoryValues.ts +++ b/src/ghidra/GhidraInventoryValues.ts @@ -33,7 +33,8 @@ export const isGhidraInventoryOperation = ( operation: string, ): operation is GhidraInventoryOperation => operationSet.has(operation); -const boundedIdentifier = z.string().min(1).max(4096); +export const ghidraBoundedIdentifierSchema = z.string().min(1).max(4096); +const boundedIdentifier = ghidraBoundedIdentifierSchema; const document = boundedIdentifier.nullable().default(null); const explicitAddress = boundedIdentifier; const filteredAddress = explicitAddress.nullable().default(null); @@ -82,9 +83,10 @@ export const parseGhidraInventoryInput = ( return ok(jsonObjectSchema.parse(parsed.data)); }; -const canonicalAddress = z +export const ghidraCanonicalAddressSchema = z .string() .regex(/^(?:0x[0-9a-f]+|(?:[A-Za-z0-9._~-]|%[0-9A-F]{2})+:0x[0-9a-f]+)$/u); +const canonicalAddress = ghidraCanonicalAddressSchema; const valueTruncation = { value_truncated: z.boolean() }; const symbolFacts = z .object({ @@ -102,6 +104,9 @@ const procedureFacts = z thunk_target: canonicalAddress.nullable(), }) .strict(); +const functionClassification = procedureFacts + .extend({ provenance: z.literal("ghidra-function-manager") }) + .strict(); const stringFacts = z .object({ encoding: z.string().min(1), @@ -198,7 +203,11 @@ const containingProcedure = z.discriminatedUnion("found", [ query_address: canonicalAddress, found: z.literal(true), procedure: z - .object({ address: canonicalAddress, name: z.string().min(1) }) + .object({ + address: canonicalAddress, + name: z.string().min(1), + classification: functionClassification, + }) .strict(), }) .strict(), diff --git a/src/ghidra/GhidraProvider.ts b/src/ghidra/GhidraProvider.ts index a28238069..c9efc666b 100644 --- a/src/ghidra/GhidraProvider.ts +++ b/src/ghidra/GhidraProvider.ts @@ -24,15 +24,26 @@ import { } 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 { + ENHANCED_TOOL_CONTRACTS, + OFFICIAL_TOOL_CONTRACTS, +} from "../contracts/toolContracts.js"; import { GhidraClient } from "./GhidraClient.js"; import type { GhidraClientOptions } from "./GhidraClientTypes.js"; import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, + GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, + GHIDRA_DECOMPILE_TIMEOUT_SECONDS, GHIDRA_MAX_LINE_BYTES, GHIDRA_REQUEST_TIMEOUT_MS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js"; +import { + GHIDRA_FUNCTION_OPERATIONS, + isGhidraFunctionOperation, + parseGhidraFunctionInput, + parseGhidraFunctionResult, +} from "./GhidraFunctionValues.js"; import { GHIDRA_INVENTORY_OPERATIONS, isGhidraInventoryOperation, @@ -56,18 +67,25 @@ export const GHIDRA_PROVIDER_IDENTITY: ProviderIdentity = Object.freeze({ version: null, }); -const officialContractByName = new Map( - OFFICIAL_TOOL_CONTRACTS.map((contract) => [contract.name, contract]), +const providerContractByName = new Map( + [...OFFICIAL_TOOL_CONTRACTS, ...ENHANCED_TOOL_CONTRACTS].map((contract) => [ + contract.name, + contract, + ]), ); -/** Direct read-only contracts implemented by the Ghidra adapter. */ +/** Provider-neutral 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; - }), + [...GHIDRA_INVENTORY_OPERATIONS, ...GHIDRA_FUNCTION_OPERATIONS].map( + (operation) => { + const contract = providerContractByName.get(operation); + if (contract === undefined) + throw new TypeError( + `Missing provider-neutral contract for ${operation}`, + ); + return contract; + }, + ), ); const PAGINATED_OPERATIONS: ReadonlySet = new Set([ @@ -76,11 +94,17 @@ const PAGINATED_OPERATIONS: ReadonlySet = new Set([ "list_strings", "search_procedures", "search_strings", + "procedure_references", + "analyze_function", ]); const SEARCH_OPERATIONS: ReadonlySet = new Set([ "search_procedures", "search_strings", ]); +const DECOMPILE_OPERATIONS: ReadonlySet = new Set([ + "procedure_pseudo_code", + "analyze_function", +]); 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.", @@ -125,6 +149,44 @@ const limitationsFor = (operation: string): readonly string[] => { ...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.", ]; + case "procedure_pseudo_code": + return [ + ...common, + "Pseudocode is Ghidra decompiler output, not original source and not text-equivalent to Hopper output; each decompile has a 30-second native deadline.", + "External functions and functions without an analyzable body return null; other decompiler failures remain explicit.", + ]; + case "procedure_assembly": + return [ + ...common, + "Assembly is Ghidra Listing text and fails rather than silently truncating when the 100,000-instruction or 1 MiB wire bound is exceeded.", + ]; + case "procedure_callers": + case "procedure_callees": + return [ + ...common, + "Only resolved Ghidra call references are returned; unresolved computed or indirect calls remain unknown, while function classifications distinguish thunks and externals.", + ]; + case "xrefs": + return [ + ...common, + "The direct address list projects exact Ghidra references to one address but does not expose their kinds; procedure_references and analyze_function preserve available kind metadata.", + "Synthetic Ghidra entry-point references without actionable memory sources are omitted.", + ]; + case "procedure_references": + return [ + ...common, + "Reference kinds are direct Ghidra ReferenceManager observations; unresolved computed flows without a target are absent and remain unknown.", + "Synthetic Ghidra entry-point references without actionable memory sources are omitted.", + "Instruction scans stop at max_instructions; a truncated scan reports an unknown total and no false continuation.", + ]; + case "analyze_function": + return [ + ...common, + "The dossier combines Ghidra FunctionManager, Listing, ReferenceManager, BasicBlockModel, and decompiler observations; provider-specific pseudocode and assembly are not cross-provider text invariants.", + "Resolved reference metadata identifies computed, indirect, external, call, jump, and data edges; unresolved targetless flows remain unknown, and function classifications distinguish thunks and externals.", + "Synthetic Ghidra entry-point references without actionable memory sources are omitted.", + "The Java bridge serializes one function request per Program through a bounded 32-request queue and applies a 30-second native decompilation deadline.", + ]; default: return common; } @@ -158,7 +220,9 @@ const CAPABILITIES: readonly CapabilityDescriptor[] = Object.freeze( : 500 : null, maxPayloadBytes: GHIDRA_MAX_LINE_BYTES, - timeoutMs: GHIDRA_REQUEST_TIMEOUT_MS, + timeoutMs: DECOMPILE_OPERATIONS.has(contract.name) + ? GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS + : GHIDRA_REQUEST_TIMEOUT_MS, }), limitations: Object.freeze(limitationsFor(contract.name)), }), @@ -292,7 +356,11 @@ export class GhidraProvider implements AnalysisProviderCandidate { }); return { execute: async (operation, parameters, options) => { - if (operation !== "health" && !isGhidraInventoryOperation(operation)) + if ( + operation !== "health" && + !isGhidraInventoryOperation(operation) && + !isGhidraFunctionOperation(operation) + ) return err( new AnalysisCapabilityUnavailableError( GHIDRA_PROVIDER_IDENTITY.id, @@ -311,16 +379,21 @@ export class GhidraProvider implements AnalysisProviderCandidate { }), ); } - const input = parseGhidraInventoryInput(operation, parameters); + const input = isGhidraFunctionOperation(operation) + ? parseGhidraFunctionInput(operation, parameters) + : parseGhidraInventoryInput(operation, parameters); if (!input.ok) return input; - const called = await client.callTool( - operation, - input.value, - options?.signal === undefined ? {} : { signal: options.signal }, - ); + const called = await client.callTool(operation, input.value, { + ...(options?.signal === undefined ? {} : { signal: options.signal }), + ...(DECOMPILE_OPERATIONS.has(operation) + ? { timeoutMs: GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS } + : {}), + }); if (!called.ok) return err(projectSessionError(operation, called.error)); - const result = parseGhidraInventoryResult(operation, called.value); + const result = isGhidraFunctionOperation(operation) + ? parseGhidraFunctionResult(operation, called.value) + : parseGhidraInventoryResult(operation, called.value); if (!result.ok) return result; return ok( createAnalysisExecution(result.value, committedProfile.provider, { @@ -408,6 +481,13 @@ const projectSessionError = ( ? GHIDRA_ANALYSIS_TIMEOUT_SECONDS * 1_000 : GHIDRA_STARTUP_TIMEOUT_MS), ); + if (failure.kind === "remote" && failure.remoteCode === "decompile_timeout") + return new AnalysisTimeoutError( + operation, + GHIDRA_DECOMPILE_TIMEOUT_SECONDS * 1_000, + ); + if (failure.kind === "remote" && failure.remoteCode === "decompile_cancelled") + return new AnalysisCancelledError(operation); if ( failure.kind === "remote" && ["invalid_request", "not_found", "ambiguous"].includes( diff --git a/src/ghidra/GhidraRequestQueue.ts b/src/ghidra/GhidraRequestQueue.ts new file mode 100644 index 000000000..d0a9fef1a --- /dev/null +++ b/src/ghidra/GhidraRequestQueue.ts @@ -0,0 +1,185 @@ +import { performance } from "node:perf_hooks"; + +import type { JsonValue } from "../domain/jsonValue.js"; +import { err, type Result } from "../domain/result.js"; +import type { GhidraRequestOptions } from "./GhidraClientTypes.js"; +import type { GhidraSessionError } from "./GhidraSessionError.js"; + +/** Result settled by one queued Ghidra Program request. */ +export type GhidraQueuedRequestResult = Result; +/** Socket execution seam used after a request reaches the queue head. */ +export type GhidraRequestExecutor = ( + method: string, + parameters: JsonValue, + options: GhidraRequestOptions, +) => Promise; +/** Bind queue failures to the owning client's live diagnostics. */ +export type GhidraQueueFailureFactory = ( + kind: "cancelled" | "timeout" | "protocol", + message: string, + timeoutMs?: number, +) => GhidraSessionError; + +interface QueuedRequest { + readonly method: string; + readonly parameters: JsonValue; + readonly signal: AbortSignal | undefined; + readonly timeoutMs: number; + readonly deadline: number; + readonly resolve: (result: GhidraQueuedRequestResult) => void; + readonly timer: NodeJS.Timeout; + readonly onAbort: (() => void) | undefined; +} + +/** Bounded FIFO that admits one Ghidra Program request at a time. */ +export class GhidraRequestQueue { + readonly #queue: QueuedRequest[] = []; + #active = false; + #size = 0; + + constructor( + private readonly maximum: number, + private readonly execute: GhidraRequestExecutor, + private readonly failure: GhidraQueueFailureFactory, + ) {} + + /** Queue one request, counting queue wait against its declared deadline. */ + run( + method: string, + parameters: JsonValue, + options: GhidraRequestOptions & { readonly timeoutMs: number }, + ): Promise { + if (options.signal?.aborted === true) + return Promise.resolve( + err(this.failure("cancelled", "Ghidra request was cancelled")), + ); + if (options.timeoutMs <= 0) + return Promise.resolve( + err( + this.failure( + "timeout", + "Ghidra request deadline elapsed", + options.timeoutMs, + ), + ), + ); + if (this.#size >= this.maximum) + return Promise.resolve( + err( + this.failure( + "protocol", + `Ghidra serial request queue reached its ${String(this.maximum)}-request limit`, + ), + ), + ); + this.#size += 1; + return new Promise((resolve) => { + let entry: QueuedRequest; + const onAbort = + options.signal === undefined + ? undefined + : () => + this.#rejectQueued( + entry, + err(this.failure("cancelled", "Ghidra request was cancelled")), + ); + const timer = setTimeout( + () => + this.#rejectQueued( + entry, + err( + this.failure( + "timeout", + "Ghidra request deadline elapsed in the serial queue", + options.timeoutMs, + ), + ), + ), + options.timeoutMs, + ); + entry = { + method, + parameters, + signal: options.signal, + timeoutMs: options.timeoutMs, + deadline: performance.now() + options.timeoutMs, + resolve, + timer, + onAbort, + }; + this.#queue.push(entry); + if (onAbort !== undefined) + options.signal?.addEventListener("abort", onAbort, { once: true }); + this.#drain(); + }); + } + + /** Fail requests that have not crossed the socket during session cleanup. */ + failQueued(failure: GhidraSessionError): void { + for (const entry of this.#queue.splice(0)) { + this.#release(entry); + this.#size -= 1; + entry.resolve(err(failure)); + } + } + + #drain(): void { + if (this.#active) return; + const entry = this.#queue.shift(); + if (entry === undefined) return; + this.#release(entry); + const remaining = entry.deadline - performance.now(); + if (entry.signal?.aborted === true || remaining <= 0) { + this.#size -= 1; + entry.resolve( + err( + entry.signal?.aborted === true + ? this.failure("cancelled", "Ghidra request was cancelled") + : this.failure( + "timeout", + "Ghidra request deadline elapsed in the serial queue", + entry.timeoutMs, + ), + ), + ); + this.#drain(); + return; + } + this.#active = true; + void this.execute(entry.method, entry.parameters, { + ...(entry.signal === undefined ? {} : { signal: entry.signal }), + timeoutMs: remaining, + }) + .then(entry.resolve) + .catch(() => + entry.resolve( + err( + this.failure( + "protocol", + "Ghidra serial request execution rejected unexpectedly", + ), + ), + ), + ) + .finally(() => { + this.#active = false; + this.#size -= 1; + this.#drain(); + }); + } + + #rejectQueued(entry: QueuedRequest, result: GhidraQueuedRequestResult): void { + const index = this.#queue.indexOf(entry); + if (index < 0) return; + this.#queue.splice(index, 1); + this.#release(entry); + this.#size -= 1; + entry.resolve(result); + } + + #release(entry: QueuedRequest): void { + clearTimeout(entry.timer); + if (entry.signal !== undefined && entry.onAbort !== undefined) + entry.signal.removeEventListener("abort", entry.onAbort); + } +} diff --git a/src/ghidra/GhidraSessionValues.ts b/src/ghidra/GhidraSessionValues.ts index df689d383..a1143b4a3 100644 --- a/src/ghidra/GhidraSessionValues.ts +++ b/src/ghidra/GhidraSessionValues.ts @@ -4,12 +4,14 @@ 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"; +import { GHIDRA_FUNCTION_OPERATIONS } from "./GhidraFunctionValues.js"; /** Exact methods proved by the bridge handshake after auto-analysis. */ export const GHIDRA_SESSION_CAPABILITIES = [ "ping", "shutdown", ...GHIDRA_INVENTORY_OPERATIONS, + ...GHIDRA_FUNCTION_OPERATIONS, ] as const; const capabilitySchema = z.enum(GHIDRA_SESSION_CAPABILITIES); diff --git a/tests/conformance/ghidra/README.md b/tests/conformance/ghidra/README.md new file mode 100644 index 000000000..16e241d60 --- /dev/null +++ b/tests/conformance/ghidra/README.md @@ -0,0 +1,27 @@ +# Ghidra conformance corpus + +These source-owned fixtures are compiled at verification time; generated +binaries and Ghidra projects are never committed. + +- `inventory.c` produces separate x86-64 debug and stripped ELF executables. + It covers imports, an external `puts` function, linker thunks, source symbols, + direct calls, a targetless callback call, two referenced strings, and a + multi-block branch. +- `cross-format.c` is freestanding so the verifier can produce AArch64 ELF, + x86-64 PE, and x86-64 Mach-O targets from the same semantics. It preserves an + exported entry, direct and indirect calls, a volatile string reference, and a + multi-block branch across loaders. + +`scripts/verify-real-ghidra.mjs` uses `cc`, `clang`, and `lld-link` by default; +`REA_CC`, `REA_CLANG`, and `REA_LLD_LINK` can select alternate commands. The +verifier requires an exact bring-your-own Ghidra 12.1.2 installation through +`GHIDRA_INSTALL_DIR` and validates header classification before starting the +provider. + +Conformance compares semantic facts: provider/profile identity, function +classification, resolved call edges, typed references, strings/xrefs, and CFG +topology. It only requires provider pseudocode and assembly to be non-empty, +bounded, and address-bearing; it never compares their text with Hopper. The +callback fixture also proves that an unresolved targetless flow is not silently +promoted to a direct callee. Every target runs in a separate owned project and +must leave no process, socket, project, or runtime root after close. diff --git a/tests/conformance/ghidra/cross-format.c b/tests/conformance/ghidra/cross-format.c new file mode 100644 index 000000000..f8efebea7 --- /dev/null +++ b/tests/conformance/ghidra/cross-format.c @@ -0,0 +1,31 @@ +typedef int (*rea_cross_callback)(int); + +volatile int rea_cross_global = 7; +const volatile char rea_cross_message[] = "REA_GHIDRA_CROSS_FORMAT"; + +__attribute__((noinline, used)) int rea_cross_leaf(int value) { + return value + rea_cross_global + rea_cross_message[0] - 'R'; +} + +__attribute__((noinline, used)) int rea_cross_branch(int value) { + if (value > 10) { + return rea_cross_leaf(value); + } + return rea_cross_leaf(-value); +} + +__attribute__((noinline, used)) int rea_cross_indirect( + rea_cross_callback callback, int value) { + return callback(value); +} + +__attribute__((noinline, used, visibility("default"))) int rea_cross_entry(void) { + return rea_cross_branch(35) + rea_cross_indirect(rea_cross_leaf, 0); +} + +__attribute__((used, visibility("default"))) void rea_cross_start(void) { + volatile int result = rea_cross_entry(); + (void)result; + for (;;) { + } +} diff --git a/tests/conformance/ghidra/inventory.c b/tests/conformance/ghidra/inventory.c index 0ceaacd7a..704d57151 100644 --- a/tests/conformance/ghidra/inventory.c +++ b/tests/conformance/ghidra/inventory.c @@ -7,9 +7,22 @@ __attribute__((noinline, used)) int rea_ghidra_inventory_leaf(int 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); +__attribute__((noinline, used)) int rea_ghidra_inventory_branch(int value) { + if (value > 10) { + return rea_ghidra_inventory_leaf(value); + } + return rea_ghidra_inventory_leaf(-value); } -int main(void) { return rea_ghidra_inventory_entry() == 42 ? 0 : 1; } +__attribute__((noinline, used)) int rea_ghidra_inventory_indirect( + int (*callback)(int), int value) { + return callback(value); +} + +__attribute__((noinline, used)) int rea_ghidra_inventory_entry(void) { + puts("REA_GHIDRA_INVENTORY_ENTRY"); + return rea_ghidra_inventory_branch(35) + + rea_ghidra_inventory_indirect(rea_ghidra_inventory_leaf, 0); +} + +int main(void) { return rea_ghidra_inventory_entry() == 49 ? 0 : 1; } diff --git a/tests/fixtures/fakeGhidra.mjs b/tests/fixtures/fakeGhidra.mjs index 03769c427..9de4ffef6 100644 --- a/tests/fixtures/fakeGhidra.mjs +++ b/tests/fixtures/fakeGhidra.mjs @@ -102,6 +102,9 @@ else { ); continue; } + if (mode === "exit_tools" && request.method !== "shutdown") + process.exit(74); + if (mode === "hang_tools" && request.method !== "shutdown") continue; const inventory = inventoryResult(request.method); if (inventory !== undefined) { socket.write( @@ -132,7 +135,7 @@ const sessionInfo = ({ timedOut, }) => ({ name: "REA Ghidra bridge", - bridge_version: 2, + bridge_version: 3, run_id: sessionRunId, profile_digest: digest, provider: { id: "ghidra", version }, @@ -152,6 +155,14 @@ const sessionInfo = ({ "resolve_containing_procedure", "search_procedures", "search_strings", + "analyze_function", + "procedure_assembly", + "procedure_callees", + "procedure_callers", + "procedure_info", + "procedure_pseudo_code", + "procedure_references", + "xrefs", ], target: { name: "fixture", @@ -237,7 +248,16 @@ const inventoryResult = (method) => { return { query_address: "0x1001", found: true, - procedure: { address: "0x1000", name: "fixture_main" }, + procedure: { + address: "0x1000", + name: "fixture_main", + classification: { + external: false, + thunk: false, + thunk_target: null, + provenance: "ghidra-function-manager", + }, + }, }; case "search_procedures": return page([ diff --git a/tests/fixtures/ghidraFunction.ts b/tests/fixtures/ghidraFunction.ts new file mode 100644 index 000000000..8d90f9eeb --- /dev/null +++ b/tests/fixtures/ghidraFunction.ts @@ -0,0 +1,92 @@ +import type { JsonValue } from "../../src/domain/jsonValue.js"; + +export const ghidraFunctionClassification = () => ({ + external: false, + thunk: false, + thunk_target: null, + provenance: "ghidra-function-manager" as const, +}); + +export const ghidraFunctionIdentity = () => ({ + address: "0x401000", + name: "fixture_main", + classification: ghidraFunctionClassification(), +}); + +const ghidraReferenceKind = () => ({ + available: true as const, + provenance: "ghidra-reference-manager" as const, + type: "DATA", + flow: false, + call: false, + jump: false, + data: true, + read: true, + write: false, + indirect: false, + computed: false, + conditional: false, + terminal: false, + primary: true, + operand_index: 0, + external: false, +}); + +export const ghidraReferenceEdge = () => ({ + source_address: "0x401001", + target_address: "0x402000", + source_procedure: ghidraFunctionIdentity(), + target_procedure: null, + kind: ghidraReferenceKind(), +}); + +export const ghidraBounded = (items: readonly JsonValue[]) => ({ + items: [...items], + total: items.length, + returned: items.length, + truncated: false, + next_offset: null, +}); + +export const ghidraFunctionDossier = (includeAssembly = true): JsonValue => { + const pseudocode = "int fixture_main(void) { return 42; }"; + return { + procedure: { + ...ghidraFunctionIdentity(), + signature: "int fixture_main(void)", + locals: [], + }, + pseudocode: { + text: pseudocode, + total_chars: [...pseudocode].length, + returned_chars: [...pseudocode].length, + truncated: false, + next_offset: null, + }, + assembly: ghidraBounded( + includeAssembly ? ["0x401000: CALL 0x401020", "0x401005: RET"] : [], + ), + comments: ghidraBounded([]), + callers: ghidraBounded([]), + callees: ghidraBounded([]), + incoming_references: ghidraBounded([]), + outgoing_references: ghidraBounded([ghidraReferenceEdge()]), + referenced_strings: ghidraBounded([ + { + address: "0x402000", + value: "inventory fixture", + source_address: "0x401001", + }, + ]), + referenced_names: ghidraBounded([]), + basic_blocks: ghidraBounded([ + { start: "0x401000", end: "0x401006", successors: [] }, + ]), + instruction_scan: { scanned: 2, truncated: false }, + limitations: [ + "Unresolved computed or indirect flows without target addresses are not represented as reference edges.", + "Thunk and external classifications are Ghidra FunctionManager observations; they do not resolve targetless calls.", + "Pseudocode and assembly are Ghidra-specific representations, not original source or Hopper-equivalent text.", + ], + }; +}; diff --git a/tests/functionComparison.test.ts b/tests/functionComparison.test.ts index 0864bbae5..9f24d1b31 100644 --- a/tests/functionComparison.test.ts +++ b/tests/functionComparison.test.ts @@ -55,6 +55,45 @@ const dossier = ( instruction_scan: { scanned: 1, truncated: false }, }); +const dossierWithReference = ( + base: "0x1000" | "0x2000", + kind: "call" | "data" | "unavailable", +) => { + const target = base === "0x1000" ? "0x1010" : "0x2010"; + return functionDossierSchema.parse({ + ...dossier("return helper();", base), + outgoing_references: bounded([ + { + source_address: base, + target_address: target, + source_procedure: { address: base, name: "main" }, + target_procedure: { address: target, name: "helper" }, + kind: + kind === "unavailable" + ? { available: false, reason: "provider has no kind authority" } + : { + available: true, + provenance: "ghidra-reference-manager", + type: kind === "call" ? "UNCONDITIONAL_CALL" : "READ", + flow: kind === "call", + call: kind === "call", + jump: false, + data: kind === "data", + read: kind === "data", + write: false, + indirect: false, + computed: false, + conditional: false, + terminal: false, + primary: true, + operand_index: 0, + external: false, + }, + }, + ]), + }); +}; + const observe = ( digit: string, value: ReturnType, @@ -154,6 +193,36 @@ describe("function comparison", () => { ).toBe(true); }); + it("compares exact reference kinds only when both providers expose them", () => { + const left = observe("d", dossierWithReference("0x1000", "call")); + const same = observe("e", dossierWithReference("0x2000", "call")); + expect( + compareFunctions(left, same, 0, 100).dimensions.find( + ({ dimension }) => dimension === "references", + ), + ).toMatchObject({ status: "unchanged" }); + + const changed = observe("f", dossierWithReference("0x2000", "data")); + expect( + compareFunctions(left, changed, 0, 100).dimensions.find( + ({ dimension }) => dimension === "references", + ), + ).toMatchObject({ status: "changed" }); + + const unavailable = observe( + "1", + dossierWithReference("0x2000", "unavailable"), + ); + expect( + compareFunctions(left, unavailable, 0, 100).dimensions.find( + ({ dimension }) => dimension === "references", + ), + ).toMatchObject({ + status: "unknown", + limitations: [expect.stringContaining("did not expose reference kinds")], + }); + }); + it("does not promote address-derived names through equal signatures", () => { const autoDossier = (base: "0x1000" | "0x2000") => functionDossierSchema.parse({ diff --git a/tests/ghidraBridgeTruthfulness.test.ts b/tests/ghidraBridgeTruthfulness.test.ts new file mode 100644 index 000000000..fa13313d4 --- /dev/null +++ b/tests/ghidraBridgeTruthfulness.test.ts @@ -0,0 +1,91 @@ +import { readFile } from "node:fs/promises"; +import { fileURLToPath } from "node:url"; + +import { beforeAll, describe, expect, it } from "vitest"; + +let bridgeSource = ""; +let queueSource = ""; + +beforeAll(async () => { + [bridgeSource, queueSource] = await Promise.all([ + readFile( + fileURLToPath( + new URL("../bridge/ghidra/ReaGhidraBridge.java", import.meta.url), + ), + "utf8", + ), + readFile( + fileURLToPath( + new URL("../src/ghidra/GhidraRequestQueue.ts", import.meta.url), + ), + "utf8", + ), + ]); +}); + +describe("Ghidra bridge truthfulness", () => { + it("owns one persistent decompiler interface for the Program lifetime", () => { + expect(bridgeSource).toContain("private DecompInterface decompiler;"); + expect(bridgeSource.match(/new DecompInterface\(\)/gu)).toHaveLength(1); + expect( + bridgeSource.match(/decompiler\.openProgram\(currentProgram\)/gu), + ).toHaveLength(1); + expect(bridgeSource).toContain("decompiler.dispose()"); + expect(bridgeSource).toContain("DECOMPILE_TIMEOUT_SECONDS = 30"); + expect(bridgeSource).toContain( + "decompileFunction(\n function,\n DECOMPILE_TIMEOUT_SECONDS", + ); + }); + + it("projects references and CFG from public Ghidra models", () => { + expect(bridgeSource).toContain("getReferenceManager().getReferencesTo"); + expect(bridgeSource).toContain( + "getReferencesFrom(instruction.getAddress())", + ); + expect(bridgeSource).toContain( + "new BasicBlockModel(currentProgram, false)", + ); + expect(bridgeSource).toContain("block.getDestinations(monitor)"); + expect(bridgeSource).toContain( + 'result.addProperty("computed", type.isComputed())', + ); + expect(bridgeSource).toContain( + 'result.addProperty("indirect", type.isIndirect())', + ); + expect(bridgeSource).toContain( + 'result.addProperty("external", reference.isExternalReference())', + ); + expect(bridgeSource).toContain("reference.isEntryPointReference()"); + }); + + it("keeps function classification and targetless-flow uncertainty explicit", () => { + expect(bridgeSource).toContain("function.isThunk()"); + expect(bridgeSource).toContain("function.isExternal()"); + expect(bridgeSource).toContain('"ghidra-function-manager"'); + expect(bridgeSource).toContain( + "Unresolved computed or indirect flows without target addresses", + ); + expect(bridgeSource).toContain( + "not original source or Hopper-equivalent text", + ); + }); + + it("serializes a bounded request queue before crossing the socket", () => { + expect(queueSource).toContain("class GhidraRequestQueue"); + expect(queueSource).toContain("if (this.#size >= this.maximum)"); + expect(queueSource).toContain("if (this.#active) return"); + expect(queueSource).toContain( + "remaining = entry.deadline - performance.now()", + ); + }); + + it("does not admit mutation methods into the Java dispatch", () => { + for (const method of [ + 'case "set_comment"', + 'case "set_address_name"', + 'case "set_inline_comment"', + 'case "set_bookmark"', + ]) + expect(bridgeSource).not.toContain(method); + }); +}); diff --git a/tests/ghidraClient.test.ts b/tests/ghidraClient.test.ts index 36d3075b7..c90c8325e 100644 --- a/tests/ghidraClient.test.ts +++ b/tests/ghidraClient.test.ts @@ -34,6 +34,8 @@ type FixtureMode = | "analysis_timeout" | "remote_error" | "hang_after_start" + | "hang_tools" + | "exit_tools" | "silent" | "exit"; @@ -230,6 +232,104 @@ describe("GhidraClient", () => { }); }); + it("fails an established function request when the provider process exits", async () => { + const client = clientFor(new FixtureLauncher("exit_tools")); + await expect(client.start()).resolves.toMatchObject({ ok: true }); + + await expect( + client.callTool("procedure_pseudo_code", { + document: null, + procedure: "fixture_main", + }), + ).resolves.toMatchObject({ ok: false, error: { kind: "process" } }); + }); + + it("cancels an established queued operation promptly", async () => { + const client = clientFor(new FixtureLauncher("hang_tools"), { + requestTimeoutMs: 10_000, + }); + await expect(client.start()).resolves.toMatchObject({ ok: true }); + const activeController = new AbortController(); + const active = client.callTool( + "procedure_pseudo_code", + { document: null, procedure: "fixture_main" }, + { signal: activeController.signal }, + ); + await wait(5); + const queuedController = new AbortController(); + const queued = client.callTool( + "procedure_info", + { document: null, procedure: "fixture_main" }, + { signal: queuedController.signal }, + ); + queuedController.abort(); + + await expect(queued).resolves.toMatchObject({ + ok: false, + error: { kind: "cancelled" }, + }); + activeController.abort(); + await active; + }); + + it("counts serial queue wait against the request deadline", async () => { + const client = clientFor(new FixtureLauncher("hang_tools"), { + requestTimeoutMs: 10_000, + }); + await expect(client.start()).resolves.toMatchObject({ ok: true }); + const activeController = new AbortController(); + const active = client.callTool( + "procedure_pseudo_code", + { document: null, procedure: "fixture_main" }, + { signal: activeController.signal }, + ); + await wait(5); + + await expect( + client.callTool( + "procedure_info", + { document: null, procedure: "fixture_main" }, + { timeoutMs: 5 }, + ), + ).resolves.toMatchObject({ + ok: false, + error: { + kind: "timeout", + timeoutMs: 5, + message: expect.stringContaining("serial queue"), + }, + }); + activeController.abort(); + await active; + }); + + it("bounds the serial per-Program request queue", async () => { + const client = clientFor(new FixtureLauncher("hang_tools"), { + requestTimeoutMs: 10_000, + }); + await expect(client.start()).resolves.toMatchObject({ ok: true }); + const controller = new AbortController(); + const requests = Array.from({ length: 33 }, () => + client.callTool( + "procedure_pseudo_code", + { document: null, procedure: "fixture_main" }, + { signal: controller.signal }, + ), + ); + const overflow = requests[32]; + if (overflow === undefined) throw new Error("Queue probe was not created"); + + await expect(overflow).resolves.toMatchObject({ + ok: false, + error: { + kind: "protocol", + message: expect.stringContaining("32-request limit"), + }, + }); + controller.abort(); + await Promise.all(requests.slice(0, 32)); + }); + it("makes double close idempotent and detaches process listeners", async () => { const launcher = new FixtureLauncher(); const client = clientFor(launcher); @@ -294,3 +394,6 @@ describe("GhidraClient", () => { const exited = (process_: ChildProcess | undefined): boolean => process_ !== undefined && (process_.exitCode !== null || process_.signalCode !== null); + +const wait = (milliseconds: number): Promise => + new Promise((resolve) => setTimeout(resolve, milliseconds)); diff --git a/tests/ghidraFunctionValues.test.ts b/tests/ghidraFunctionValues.test.ts new file mode 100644 index 000000000..cf1157db7 --- /dev/null +++ b/tests/ghidraFunctionValues.test.ts @@ -0,0 +1,200 @@ +import { describe, expect, it } from "vitest"; + +import type { JsonValue } from "../src/domain/jsonValue.js"; +import { + GHIDRA_FUNCTION_OPERATIONS, + isGhidraFunctionOperation, + parseGhidraFunctionInput, + parseGhidraFunctionResult, + type GhidraFunctionOperation, +} from "../src/ghidra/GhidraFunctionValues.js"; +import { + ghidraBounded, + ghidraFunctionClassification, + ghidraFunctionDossier, + ghidraFunctionIdentity, + ghidraReferenceEdge, +} from "./fixtures/ghidraFunction.js"; + +describe("Ghidra function-analysis boundary values", () => { + it("defaults bounded inputs and rejects undeclared or implicit addresses", () => { + expect( + parseGhidraFunctionInput("procedure_info", { procedure: "main" }), + ).toEqual({ + ok: true, + value: { document: null, procedure: "main" }, + }); + expect( + parseGhidraFunctionInput("procedure_references", { procedure: "main" }), + ).toEqual({ + ok: true, + value: { + document: null, + procedure: "main", + direction: "outgoing", + offset: 0, + limit: 100, + max_instructions: 500, + }, + }); + expect( + parseGhidraFunctionInput("analyze_function", { procedure: "main" }), + ).toMatchObject({ + ok: true, + value: { + procedure: "main", + include_assembly: false, + limit: 100, + max_pseudocode_chars: 20_000, + max_instructions: 500, + pseudocode_offset: 0, + assembly_offset: 0, + collection_offset: { basic_blocks: 0, outgoing_references: 0 }, + }, + }); + expect(parseGhidraFunctionInput("xrefs", {})).toMatchObject({ + ok: false, + error: { _tag: "AnalysisInputError" }, + }); + expect( + parseGhidraFunctionInput("procedure_info", { + procedure: "main", + extra: true, + }), + ).toMatchObject({ ok: false, error: { _tag: "AnalysisInputError" } }); + }); + + it("keeps the admitted operation set closed", () => { + expect(GHIDRA_FUNCTION_OPERATIONS).toHaveLength(8); + expect(isGhidraFunctionOperation("analyze_function")).toBe(true); + expect(isGhidraFunctionOperation("procedure_pseudo_code")).toBe(true); + expect(isGhidraFunctionOperation("list_procedures")).toBe(false); + expect(isGhidraFunctionOperation("set_comment")).toBe(false); + }); + + it("parses provider-classified function facts and reference kinds", () => { + expect( + parseGhidraFunctionResult("procedure_info", { + name: "fixture_main", + entrypoint: "0x401000", + basicblock_count: 1, + length: 6, + signature: "int fixture_main(void)", + locals: [ + { + description: "int local @ Stack[-0x4]:4", + provenance: "ghidra-function-database", + }, + ], + classification: ghidraFunctionClassification(), + }), + ).toMatchObject({ ok: true }); + expect( + parseGhidraFunctionResult("procedure_references", { + procedure: ghidraFunctionIdentity(), + direction: "outgoing", + references: ghidraBounded([ghidraReferenceEdge()]), + instructions_scanned: 2, + instruction_scan_truncated: false, + }), + ).toMatchObject({ + ok: true, + value: { + references: { + items: [ + { + kind: { + available: true, + provenance: "ghidra-reference-manager", + data: true, + }, + }, + ], + }, + }, + }); + expect( + parseGhidraFunctionResult("analyze_function", ghidraFunctionDossier()), + ).toMatchObject({ ok: true }); + }); + + it.each(malformedOutputs())( + "rejects malformed %s output", + (_name, operation, value) => { + expect(parseGhidraFunctionResult(operation, value)).toMatchObject({ + ok: false, + error: { _tag: "AnalysisOutputError" }, + }); + }, + ); +}); + +const malformedOutputs = (): Array< + [string, GhidraFunctionOperation, JsonValue] +> => { + const dossier = ghidraFunctionDossier(); + if (typeof dossier !== "object" || dossier === null || Array.isArray(dossier)) + throw new TypeError("Ghidra dossier fixture is invalid"); + const edge = ghidraReferenceEdge(); + return [ + ["non-canonical address", "procedure_callers", ["401000"]], + [ + "missing classification", + "procedure_info", + { + name: "main", + entrypoint: "0x401000", + basicblock_count: 1, + length: 1, + signature: null, + locals: [], + }, + ], + [ + "unavailable Ghidra reference kind", + "procedure_references", + { + procedure: ghidraFunctionIdentity(), + direction: "outgoing", + references: ghidraBounded([ + { ...edge, kind: { available: false, reason: "unknown" } }, + ]), + instructions_scanned: 1, + instruction_scan_truncated: false, + }, + ], + [ + "Hopper local provenance", + "analyze_function", + { + ...dossier, + procedure: { + ...ghidraFunctionIdentity(), + signature: null, + locals: [ + { + description: "opaque", + provenance: "hopper-public-python-api", + }, + ], + }, + }, + ], + [ + "inconsistent dossier bound", + "analyze_function", + { + ...dossier, + instruction_scan: { scanned: -1, truncated: false }, + }, + ], + [ + "missing uncertainty limitations", + "analyze_function", + { + ...dossier, + limitations: [], + }, + ], + ]; +}; diff --git a/tests/ghidraMcp.test.ts b/tests/ghidraMcp.test.ts index 12437fdfd..a825640ea 100644 --- a/tests/ghidraMcp.test.ts +++ b/tests/ghidraMcp.test.ts @@ -10,7 +10,7 @@ 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 type { GhidraOperation } from "../src/ghidra/GhidraClient.js"; import { GhidraProvider, type GhidraProviderClientFactory, @@ -18,12 +18,19 @@ import { import { GHIDRA_SESSION_CAPABILITIES } from "../src/ghidra/GhidraSessionValues.js"; import { silentLogger } from "../src/logger.js"; import { createServer } from "../src/server/createServer.js"; +import { + ghidraBounded, + ghidraFunctionClassification, + ghidraFunctionDossier, + ghidraFunctionIdentity, + ghidraReferenceEdge, +} from "./fixtures/ghidraFunction.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 calls: GhidraOperation[] = []; const factory: GhidraProviderClientFactory = (options) => ({ start: () => Promise.resolve(ok(sessionInfo(options.profileDigest))), callTool: (operation, input) => { @@ -124,6 +131,88 @@ describe("Ghidra MCP and shared CLI composition", () => { }, }); + const pseudocode = parseEvidence( + ( + await mcp.callTool({ + name: "procedure_pseudo_code", + arguments: { procedure: "fixture_main" }, + }) + ).structuredContent, + ); + expect(pseudocode).toMatchObject({ + operation: "procedure_pseudo_code", + provider: { id: "ghidra", version: "12.1.2" }, + normalized_result: expect.stringContaining("return 42"), + limitations: expect.arrayContaining([ + expect.stringContaining("not text-equivalent to Hopper"), + expect.stringContaining("30-second native deadline"), + ]), + }); + + const analyzed = parseEvidence( + ( + await mcp.callTool({ + name: "analyze_function", + arguments: { procedure: "fixture_main", include_assembly: true }, + }) + ).structuredContent, + ); + expect(analyzed).toMatchObject({ + operation: "analyze_function", + provider: { id: "rea-workflow", version: "1" }, + normalized_result: { + procedure: { + address: "0x401000", + name: "fixture_main", + classification: { + external: false, + thunk: false, + provenance: "ghidra-function-manager", + }, + }, + pseudocode: { truncated: false }, + outgoing_references: { + items: [ + { + kind: { + available: true, + provenance: "ghidra-reference-manager", + }, + }, + ], + }, + limitations: expect.arrayContaining([ + expect.stringContaining("indirect flows without target addresses"), + expect.stringContaining( + "not original source or Hopper-equivalent text", + ), + ]), + }, + limitations: [ + "Derived by an REA workflow from one or more provider observations.", + ], + }); + const directAnalyzed = await new EnhancedTools(session).execute( + "analyze_function", + { procedure: "fixture_main", include_assembly: true }, + ); + expect(directAnalyzed.ok).toBe(true); + if (!directAnalyzed.ok) return; + expect(analyzed.normalized_result).toEqual(directAnalyzed.value); + + const batch = await mcp.callTool({ + name: "batch_decompile", + arguments: { addresses: ["fixture_main"] }, + }); + expect(batch.isError).not.toBe(true); + expect(batch.structuredContent).toMatchObject({ + normalized_result: { + succeeded: 1, + failed: 0, + items: [{ status: "ok" }], + }, + }); + const unsupported = await mcp.callTool({ name: "set_comment", arguments: { address: "0x401000", comment: "not allowed" }, @@ -156,13 +245,19 @@ describe("Ghidra MCP and shared CLI composition", () => { }), expect.objectContaining({ name: "batch_decompile", - available: false, - reason: "provider_missing", + available: true, }), expect.objectContaining({ name: "trace_feature", - available: false, - reason: "provider_missing", + available: true, + }), + expect.objectContaining({ + name: "get_call_graph", + available: true, + }), + expect.objectContaining({ + name: "find_xrefs_to_name", + available: true, }), ]), }, @@ -188,7 +283,7 @@ const installationHost = (): GhidraInstallationHost => ({ const sessionInfo = (profileDigest: string) => ({ name: "REA Ghidra bridge" as const, - bridge_version: 2 as const, + bridge_version: 3 as const, run_id: "11111111-1111-4111-8111-111111111111", profile_digest: profileDigest, provider: { id: "ghidra" as const, version: "12.1.2" }, @@ -206,7 +301,7 @@ const sessionInfo = (profileDigest: string) => ({ }); const resultFor = ( - operation: GhidraInventoryOperation, + operation: GhidraOperation, input: Readonly>, ): JsonValue => { const limit = typeof input.limit === "number" ? input.limit : 100; @@ -256,6 +351,23 @@ const resultFor = ( }, ]; case "list_names": + return page( + [ + { + address: "0x401000", + value: "fixture_main", + value_truncated: false, + symbol: { + primary: true, + dynamic: false, + external: false, + type: "function", + source: "user_defined", + }, + }, + ], + limit, + ); case "search_procedures": case "search_strings": return page([], limit); @@ -267,8 +379,37 @@ const resultFor = ( return { query_address: "0x401001", found: true, - procedure: { address: "0x401000", name: "fixture_main" }, + procedure: ghidraFunctionIdentity(), }; + case "procedure_assembly": + return "0x401000: CALL 0x401020\n0x401005: RET"; + case "procedure_callees": + case "procedure_callers": + return []; + case "procedure_info": + return { + name: "fixture_main", + entrypoint: "0x401000", + basicblock_count: 1, + length: 6, + signature: "int fixture_main(void)", + locals: [], + classification: ghidraFunctionClassification(), + }; + case "procedure_pseudo_code": + return "int fixture_main(void) { return 42; }"; + case "procedure_references": + return { + procedure: ghidraFunctionIdentity(), + direction: input.direction ?? "outgoing", + references: ghidraBounded([ghidraReferenceEdge()]), + instructions_scanned: 2, + instruction_scan_truncated: false, + }; + case "xrefs": + return ["0x401001"]; + case "analyze_function": + return ghidraFunctionDossier(input.include_assembly === true); } }; diff --git a/tests/ghidraProvider.test.ts b/tests/ghidraProvider.test.ts index 2e0bf9795..4e81fcb9f 100644 --- a/tests/ghidraProvider.test.ts +++ b/tests/ghidraProvider.test.ts @@ -46,7 +46,7 @@ describe("Ghidra provider", () => { expect(ghidra.capabilities().map(({ operation }) => operation)).toEqual( GHIDRA_PROVIDER_TOOL_CONTRACTS.map(({ name }) => name), ); - expect(GHIDRA_PROVIDER_TOOL_CONTRACTS).toHaveLength(10); + expect(GHIDRA_PROVIDER_TOOL_CONTRACTS).toHaveLength(18); expect(Object.isFrozen(ghidra.capabilities())).toBe(true); expect(ghidra.capabilities()).toEqual( expect.arrayContaining([ @@ -64,6 +64,20 @@ describe("Ghidra provider", () => { timeoutMs: 10_000, }, }), + expect.objectContaining({ + operation: "analyze_function", + pagination: "offset", + limits: { + maxResults: 500, + maxPayloadBytes: 1024 * 1024, + timeoutMs: 35_000, + }, + limitations: expect.arrayContaining([ + expect.stringContaining( + "unresolved targetless flows remain unknown", + ), + ]), + }), ]), ); expect(ghidra.inspectAvailability()).toMatchObject({ @@ -251,6 +265,45 @@ describe("Ghidra provider", () => { }, ); + it.each([ + ["decompile_timeout", "AnalysisTimeoutError", 30_000], + ["decompile_cancelled", "AnalysisCancelledError", undefined], + ] as const)( + "projects remote %s as a provider-neutral interruption", + async (code, tag, timeoutMs) => { + const ghidra = provider(installationHost(), () => ({ + start: () => Promise.resolve(ok(sessionInfo())), + callTool: () => + Promise.resolve( + err( + new GhidraSessionError( + "remote", + "Fixture decompiler interruption", + { 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; + + const result = await ghidra + .createClient(executableTarget("elf", "x86_64"), resolved.value.profile) + .execute("procedure_pseudo_code", { procedure: "main" }); + expect(result).toMatchObject({ + ok: false, + error: { + _tag: tag, + ...(timeoutMs === undefined ? {} : { timeoutMs }), + }, + }); + }, + ); + it("returns cancellation before profile work", async () => { const controller = new AbortController(); controller.abort(); @@ -267,7 +320,7 @@ describe("Ghidra provider", () => { const sessionInfo = () => ({ name: "REA Ghidra bridge" as const, - bridge_version: 2 as const, + bridge_version: 3 as const, run_id: "11111111-1111-4111-8111-111111111111", profile_digest: "a".repeat(64), provider: { id: "ghidra" as const, version: "12.1.2" }, diff --git a/tests/providerArchitecture.test.ts b/tests/providerArchitecture.test.ts index df6cddb3d..5f269ed1f 100644 --- a/tests/providerArchitecture.test.ts +++ b/tests/providerArchitecture.test.ts @@ -8,6 +8,7 @@ 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 { GHIDRA_FUNCTION_OPERATIONS } from "../src/ghidra/GhidraFunctionValues.js"; import { silentLogger } from "../src/logger.js"; const sourceRoot = new URL("../src/", import.meta.url); @@ -38,7 +39,7 @@ describe("provider-neutral architecture", () => { expect(violations).toEqual([]); }); - it("publishes only admitted immutable Ghidra inventory capabilities", () => { + it("publishes only admitted immutable Ghidra read-only capabilities", () => { const config = parseConfig({}); expect(config.ok).toBe(true); if (!config.ok) return; @@ -49,7 +50,7 @@ describe("provider-neutral architecture", () => { }); const capabilities = provider.capabilities(); expect(capabilities.map(({ operation }) => operation).sort()).toEqual( - [...GHIDRA_INVENTORY_OPERATIONS].sort(), + [...GHIDRA_INVENTORY_OPERATIONS, ...GHIDRA_FUNCTION_OPERATIONS].sort(), ); expect(Object.isFrozen(capabilities)).toBe(true); for (const descriptor of capabilities) {