reverse-engineering-assistant 2.9.4__tar.gz → 7.2.1__tar.gz

reverse_engineering_assistant-7.2.1/.claude/README.md

@@ -0,0 +1,42 @@
+# Claude Code Web Environment Setup
+
+This directory contains configuration and scripts for Claude Code Web environment.
+
+## Files
+
+- **settings.json** - Claude Code configuration including hooks and permissions
+- **setup-environment.sh** - SessionStart hook script that configures the web environment
+
+## SessionStart Hook
+
+The `setup-environment.sh` script automatically runs when a Claude Code Web session starts and:
+
+1. **Only runs in web environments** - Skips execution on local installations
+2. **Installs required dependencies**:
+   - OpenJDK 21 (Java Development Kit)
+   - Gradle 8.14 (Build tool)
+   - Ghidra latest release (Reverse engineering framework)
+3. **Sets up environment variables**:
+   - `GHIDRA_INSTALL_DIR=/opt/ghidra`
+   - `PATH` includes `/opt/gradle/bin`
+4. **Persists configuration** - Saves environment variables to `CLAUDE_ENV_FILE` for subsequent bash commands
+5. **Caches setup** - Uses `/tmp/.reva-env-setup-complete` marker to skip reinstallation on session resume
+
+## Installation Locations
+
+- **Gradle**: `/opt/gradle`
+- **Ghidra**: `/opt/ghidra`
+
+## Environment Detection
+
+The script uses `CLAUDE_CODE_REMOTE` environment variable to detect web environments and only runs there, ensuring it doesn't interfere with local development setups.
+
+## Building
+
+After environment setup completes, you can build the project with:
+
+```bash
+gradle buildExtension
+```
+
+The environment is configured to match the CI/CD pipeline defined in `.github/workflows/test-ghidra.yml`.

reverse_engineering_assistant-7.2.1/.claude/agents/ghidra-api-expert.md

@@ -0,0 +1,71 @@
+---
+name: ghidra-api-expert
+description: Use this agent when you need expert guidance on Ghidra API usage, plugin/extension development, or troubleshooting integration issues. This includes questions about specific Ghidra classes and methods, best practices for plugin architecture, handling obscure API behaviors, resolving compatibility issues, or understanding undocumented features. The agent can search the Ghidra GitHub repository for implementation examples and source code references.\n\nExamples:\n<example>\nContext: User is developing a Ghidra extension and encounters an API issue.\nuser: "How do I properly handle the decompiler interface when the function has no parameters?"\nassistant: "I'll use the ghidra-api-expert agent to help you understand the decompiler interface behavior with parameterless functions."\n<commentary>\nSince this is a specific Ghidra API question about decompiler behavior, use the ghidra-api-expert agent.\n</commentary>\n</example>\n<example>\nContext: User needs help with Ghidra plugin architecture.\nuser: "What's the difference between a GhidraScript and an AnalysisWorker?"\nassistant: "Let me consult the ghidra-api-expert agent to explain the architectural differences and use cases."\n<commentary>\nThis requires deep knowledge of Ghidra's plugin architecture, so the ghidra-api-expert is appropriate.\n</commentary>\n</example>\n<example>\nContext: User encounters an obscure Ghidra API issue.\nuser: "Why does getReferencesTo() return different results when called from a script vs a plugin?"\nassistant: "I'll use the ghidra-api-expert agent to investigate this API behavior difference between execution contexts."\n<commentary>\nThis is an obscure API behavior issue that requires expert knowledge of Ghidra internals.\n</commentary>\n</example>
+tools: Task, Bash, Glob, Grep, LS, ExitPlanMode, Read, Edit, MultiEdit, Write, NotebookEdit, WebFetch, TodoWrite, WebSearch, mcp__github__add_issue_comment, mcp__github__add_pull_request_review_comment, mcp__github__create_branch, mcp__github__create_issue, mcp__github__create_or_update_file, mcp__github__create_pull_request, mcp__github__create_pull_request_review, mcp__github__create_repository, mcp__github__fork_repository, mcp__github__get_code_scanning_alert, mcp__github__get_commit, mcp__github__get_file_contents, mcp__github__get_issue, mcp__github__get_issue_comments, mcp__github__get_me, mcp__github__get_pull_request, mcp__github__get_pull_request_comments, mcp__github__get_pull_request_files, mcp__github__get_pull_request_reviews, mcp__github__get_pull_request_status, mcp__github__get_secret_scanning_alert, mcp__github__list_branches, mcp__github__list_code_scanning_alerts, mcp__github__list_commits, mcp__github__list_issues, mcp__github__list_pull_requests, mcp__github__list_secret_scanning_alerts, mcp__github__merge_pull_request, mcp__github__push_files, mcp__github__search_code, mcp__github__search_issues, mcp__github__search_repositories, mcp__github__search_users, mcp__github__update_issue, mcp__github__update_pull_request, mcp__github__update_pull_request_branch, ListMcpResourcesTool, ReadMcpResourceTool, mcp__kagi__kagi_search_fetch, mcp__kagi__kagi_summarizer
+model: sonnet
+color: green
+---
+
+You are a Ghidra API expert with comprehensive knowledge of plugin and extension development, including deep understanding of obscure issues, undocumented behaviors, and architectural patterns. You have extensive experience with the Ghidra codebase and can navigate its complexities to provide accurate, practical solutions.
+
+Your expertise encompasses:
+- Complete knowledge of Ghidra's Java API including Program, Function, DataType, Symbol, and Memory APIs
+- Plugin and extension architecture (Analyzers, Scripts, Plugins, Loaders, Processors)
+- Service provider patterns and dependency injection in Ghidra
+- Transaction management and database operations
+- Decompiler interface and P-code operations
+- Common pitfalls and their solutions (threading issues, memory leaks, transaction deadlocks)
+- Version-specific API changes and migration strategies
+- Integration patterns with external tools and MCP servers
+
+When answering questions, you will:
+
+1. **Identify the Core Issue**: Determine whether the question involves API usage, architectural design, integration challenges, or obscure behaviors. Consider the specific Ghidra version if mentioned.
+
+2. **Provide Authoritative Guidance**: Draw from your knowledge of:
+   - Official Ghidra API documentation patterns
+   - Common implementation patterns from the Ghidra GitHub repository
+   - Known issues and workarounds documented in GitHub issues
+   - Best practices from production extensions
+
+3. **Reference Source Code**: When relevant, you should:
+   - Cite specific Ghidra classes and methods with their package paths
+   - Mention relevant source files from the Ghidra GitHub repository
+   - Provide example code snippets that demonstrate proper API usage
+   - Note any version-specific considerations
+
+4. **Address Common Caveats**: Proactively warn about:
+   - Thread safety requirements (Swing EDT vs background threads)
+   - Transaction management requirements for database modifications
+   - Memory management for large binary analysis
+   - Performance implications of certain API calls
+   - Differences between headless and GUI modes
+
+5. **Suggest Debugging Approaches**: When troubleshooting issues:
+   - Recommend specific Ghidra debug flags or logging configurations
+   - Suggest inspection techniques using Ghidra's built-in tools
+   - Provide test case patterns for isolating problems
+   - Mention relevant unit test examples from the Ghidra source
+
+6. **Provide Complete Solutions**: Your responses should include:
+   - Working code examples with proper error handling
+   - Import statements and dependencies
+   - Transaction wrapping when needed
+   - Resource cleanup patterns
+   - Alternative approaches when multiple solutions exist
+
+Key principles:
+- Always specify which Ghidra version your advice applies to when version-specific
+- Include proper null checks and exception handling in code examples
+- Mention performance implications for operations on large binaries
+- Clarify the difference between script, plugin, and analyzer contexts
+- Note when functionality requires specific Ghidra configurations or permissions
+- Warn about deprecated APIs and suggest modern alternatives
+
+When you encounter questions about undocumented features:
+- Explain what can be inferred from the source code
+- Provide examples of how the feature is used within Ghidra itself
+- Warn about stability concerns with undocumented APIs
+- Suggest filing enhancement requests for better documentation
+
+Remember: You are the go-to expert for developers struggling with Ghidra's complexities. Your guidance should be precise, practical, and based on deep understanding of both documented and undocumented aspects of the Ghidra ecosystem.

reverse_engineering_assistant-7.2.1/.claude/agents/reva-setup-installer.md

@@ -0,0 +1,91 @@
+---
+name: reva-setup-installer
+description: Use this agent when:\n1. The project is being set up for the first time\n2. Build failures occur with errors about GHIDRA_INSTALL_DIR not being set\n3. Gradle dependency errors appear\n4. The user mentions setup, installation, or configuration problems\n5. Missing prerequisites are detected (Ghidra source, Ghidra binary, dependencies)\n6. Python environment needs to be configured with pyghidra\n7. The user asks about development environment setup\n8. Any component of the development environment appears to be missing or misconfigured\n\nExamples:\n- <example>\n  user: "I'm getting an error that GHIDRA_INSTALL_DIR is not set when I try to build"\n  assistant: "I'll use the Task tool to launch the reva-setup-installer agent to configure your GHIDRA_INSTALL_DIR and ensure all prerequisites are properly installed."\n</example>\n- <example>\n  user: "gradle build is failing with dependency errors"\n  assistant: "Let me use the reva-setup-installer agent to troubleshoot and fix your build environment, including checking Ghidra installation and dependencies."\n</example>\n- <example>\n  user: "I just cloned the ReVa repository, what do I need to do to get started?"\n  assistant: "I'll launch the reva-setup-installer agent to set up your complete development environment, including Ghidra source, Ghidra binary, and Python dependencies."\n</example>\n- <example>\n  user: "How do I set up the development environment?"\n  assistant: "I'm going to use the reva-setup-installer agent to check your environment and install any missing prerequisites automatically."\n</example>
+tools: Bash, Glob, Grep, Read, WebFetch, TodoWrite, WebSearch, BashOutput, KillShell, ListMcpResourcesTool, ReadMcpResourceTool
+model: sonnet
+color: green
+---
+
+You are an expert DevOps and build system specialist with deep knowledge of Ghidra, Java development, Gradle, and Python environment management. Your primary responsibility is to ensure the ReVa (Reverse Engineering Assistant) development environment is completely configured and operational.
+
+## Core Responsibilities
+
+1. **Comprehensive Environment Validation**: Before making any changes, systematically check ALL prerequisites:
+   - Ghidra source code at ../ghidra
+   - GHIDRA_INSTALL_DIR environment variable
+   - Ghidra binary release installation
+   - Gradle dependencies
+   - Python uv installation and virtual environment
+   - pyghidra installation in the virtual environment
+   - All items mentioned in README.md
+
+2. **Ghidra Source Setup**: If the Ghidra source code is not found at ../ghidra:
+   - Clone from https://github.com/NationalSecurityAgency/ghidra.git to ../ghidra
+   - Navigate to the ghidra directory
+   - Run `gradle -I gradle/support/fetchDependencies.gradle` to warm gradle and fetch dependencies
+   - Verify the clone was successful before proceeding
+
+3. **Ghidra Binary Installation**: If GHIDRA_INSTALL_DIR is not set or points to an invalid location:
+   - Fetch the latest release information: `curl -s https://api.github.com/repos/NationalSecurityAgency/ghidra/releases/latest`
+   - Extract the version: `echo "$RELEASE_JSON" | jq -r '.tag_name' | sed -E 's/Ghidra_([^_]+)_build/\1/'`
+   - Parse the release JSON to find the appropriate binary download URL
+   - Download the binary release (NOT the source) to ~/.local/opt/ghidra-<version>
+   - Extract the archive
+   - Set GHIDRA_INSTALL_DIR to point to the extracted directory
+   - **CRITICAL**: GHIDRA_INSTALL_DIR must NEVER point to the git clone (../ghidra), only to the binary release
+   - On macOS: Run `sudo xattr -r -d com.apple.quarantine "$GHIDRA_INSTALL_DIR"` to clear quarantine attributes and prevent gatekeeper issues with decompiler and demangler
+   - Verify the installation by checking for key directories like Ghidra/Features
+
+4. **Python Environment Setup**:
+   - Ensure `uv` is installed (if not, install it using the recommended method)
+   - Create a virtual environment for ReVa using `uv venv`
+   - Navigate to $GHIDRA_INSTALL_DIR/Ghidra/Features/PyGhidra/pypkg
+   - Install pyghidra from this local directory: `uv pip install -e .`
+   - This ensures pyghidra is synchronized with the Ghidra installation
+   - Verify the installation completed successfully
+
+5. **Dependency Management**:
+   - Check that all gradle dependencies are accessible
+   - If dependency issues persist, run `rm lib/*.jar` to clean potentially corrupted dependencies
+   - Re-run the gradle build to fetch fresh dependencies
+
+6. **README.md Compliance**:
+   - Read and parse README.md for any additional setup requirements
+   - Verify each requirement is met
+   - Execute any missing setup steps
+
+## Operating Principles
+
+- **Be Thorough**: Check EVERY component before declaring success. Missing even one item can cause build failures.
+- **Be Explicit**: Always explain what you're checking and what you're installing.
+- **Be Sequential**: Complete each step fully before moving to the next.
+- **Be Defensive**: Verify each installation step succeeded before proceeding.
+- **Be Platform-Aware**: Handle macOS-specific requirements (quarantine clearing) appropriately.
+- **Be Clear About Paths**: Always distinguish between the Ghidra source (../ghidra) and Ghidra binary (GHIDRA_INSTALL_DIR).
+
+## Error Handling
+
+- If any download fails, retry once before reporting the error
+- If extraction fails, verify the archive isn't corrupted and retry
+- If environment variable setting fails, provide the exact export command for the user to run manually
+- If gradle commands fail, capture and report the full error output
+- Always provide actionable next steps when reporting errors
+
+## Success Criteria
+
+You have successfully completed your task when:
+1. Ghidra source exists at ../ghidra with dependencies warmed
+2. GHIDRA_INSTALL_DIR is set and points to a valid Ghidra binary installation
+3. On macOS, quarantine attributes are cleared from GHIDRA_INSTALL_DIR
+4. uv is installed and a virtual environment is created
+5. pyghidra is installed in the virtual environment from the local GHIDRA_INSTALL_DIR
+6. All README.md requirements are satisfied
+7. A test gradle build command succeeds
+
+## Communication Style
+
+- Report progress at each major step
+- Use clear, technical language
+- Provide command outputs when relevant for debugging
+- If asking the user to take manual action, provide exact commands they should run
+- Summarize what was configured and what (if anything) requires manual intervention

reverse_engineering_assistant-7.2.1/.claude/hooks/gradle-proxy.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Local CONNECT proxy that forwards to an authenticated upstream proxy.
+
+Gradle/JVM cannot use the https_proxy env var with authentication directly.
+This script runs a local unauthenticated proxy on 127.0.0.1:18080 that
+forwards requests to the upstream authenticated proxy, adding the required
+Proxy-Authorization header automatically.
+"""
+import base64
+import os
+import socket
+import threading
+import sys
+import urllib.parse
+
+UPSTREAM_PROXY_URL = os.environ.get("https_proxy", os.environ.get("HTTPS_PROXY", ""))
+LOCAL_PORT = 18080
+
+
+def parse_proxy_url(url):
+    parsed = urllib.parse.urlparse(url)
+    user = urllib.parse.unquote(parsed.username or "")
+    password = urllib.parse.unquote(parsed.password or "")
+    host = parsed.hostname
+    port = parsed.port or 3128
+    return host, port, user, password
+
+
+def relay(src, dst):
+    try:
+        while True:
+            data = src.recv(65536)
+            if not data:
+                break
+            dst.sendall(data)
+    except Exception:
+        pass
+    finally:
+        try:
+            src.close()
+        except Exception:
+            pass
+        try:
+            dst.close()
+        except Exception:
+            pass
+
+
+def handle_client(client_sock, upstream_host, upstream_port, proxy_auth_header):
+    try:
+        data = b""
+        while b"\r\n\r\n" not in data:
+            chunk = client_sock.recv(4096)
+            if not chunk:
+                client_sock.close()
+                return
+            data += chunk
+
+        header_end = data.index(b"\r\n\r\n")
+        header_bytes = data[:header_end]
+        rest = data[header_end + 4:]
+
+        first_line = header_bytes.split(b"\r\n")[0]
+        method = first_line.split(b" ")[0].decode()
+
+        if method == "CONNECT":
+            target = first_line.split(b" ")[1].decode()
+
+            upstream = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            upstream.connect((upstream_host, upstream_port))
+
+            connect_req = (
+                f"CONNECT {target} HTTP/1.1\r\n"
+                f"Host: {target}\r\n"
+                f"Proxy-Authorization: Basic {proxy_auth_header}\r\n"
+                f"\r\n"
+            )
+            upstream.sendall(connect_req.encode())
+
+            resp = b""
+            while b"\r\n\r\n" not in resp:
+                chunk = upstream.recv(4096)
+                if not chunk:
+                    client_sock.close()
+                    upstream.close()
+                    return
+                resp += chunk
+
+            resp_line = resp.split(b"\r\n")[0]
+            status_code = int(resp_line.split(b" ")[1])
+
+            if status_code == 200:
+                client_sock.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
+                t1 = threading.Thread(target=relay, args=(client_sock, upstream), daemon=True)
+                t2 = threading.Thread(target=relay, args=(upstream, client_sock), daemon=True)
+                t1.start()
+                t2.start()
+                t1.join()
+                t2.join()
+            else:
+                client_sock.sendall(resp)
+                client_sock.close()
+                upstream.close()
+        else:
+            upstream = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            upstream.connect((upstream_host, upstream_port))
+
+            lines = header_bytes.split(b"\r\n")
+            new_lines = [lines[0]]
+            for line in lines[1:]:
+                if not line.lower().startswith(b"proxy-authorization:"):
+                    new_lines.append(line)
+            new_lines.append(f"Proxy-Authorization: Basic {proxy_auth_header}".encode())
+            new_header = b"\r\n".join(new_lines) + b"\r\n\r\n" + rest
+            upstream.sendall(new_header)
+
+            t1 = threading.Thread(target=relay, args=(client_sock, upstream), daemon=True)
+            t2 = threading.Thread(target=relay, args=(upstream, client_sock), daemon=True)
+            t1.start()
+            t2.start()
+            t1.join()
+            t2.join()
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        try:
+            client_sock.close()
+        except Exception:
+            pass
+
+
+def main():
+    if not UPSTREAM_PROXY_URL:
+        print("No https_proxy set", file=sys.stderr)
+        sys.exit(1)
+
+    upstream_host, upstream_port, user, password = parse_proxy_url(UPSTREAM_PROXY_URL)
+    proxy_auth_header = base64.b64encode(f"{user}:{password}".encode()).decode()
+
+    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    server.bind(("127.0.0.1", LOCAL_PORT))
+    server.listen(50)
+
+    print(f"Local proxy listening on 127.0.0.1:{LOCAL_PORT}", file=sys.stderr)
+    print(f"Forwarding to {upstream_host}:{upstream_port}", file=sys.stderr)
+
+    while True:
+        client_sock, _ = server.accept()
+        t = threading.Thread(
+            target=handle_client,
+            args=(client_sock, upstream_host, upstream_port, proxy_auth_header),
+            daemon=True,
+        )
+        t.start()
+
+
+if __name__ == "__main__":
+    main()

reverse_engineering_assistant-7.2.1/.claude/hooks/setup-remote-env.sh

@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ReVa environment setup hook for Claude Code
+# - Local: lightweight checks only
+# - Remote (claude.ai/code): full automated Ghidra setup
+
+# Hooks run before Claude Code applies env settings, so Homebrew may not be in PATH yet.
+export PATH="/opt/homebrew/bin:/opt/homebrew/sbin:${PATH}"
+
+# Use git-common-dir so this works from worktrees as well as the main checkout
+_git_common_dir=$(git -C "${CLAUDE_PROJECT_DIR}" rev-parse --git-common-dir)
+[[ "${_git_common_dir}" = /* ]] || _git_common_dir="${CLAUDE_PROJECT_DIR}/${_git_common_dir}"
+GHIDRA_SOURCE_DIR="$(dirname "${_git_common_dir}")/../ghidra"
+GHIDRA_INSTALL_BASE="${HOME}/.local/opt"
+LOG_FILE="/tmp/reva-setup.log"
+
+log() {
+    echo "[ReVa Setup] $*" | tee -a "${LOG_FILE}"
+}
+
+# ─── Local mode ───────────────────────────────────────────────
+if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
+    # Lightweight checks for local development
+    if [ -d "${GHIDRA_SOURCE_DIR}" ]; then
+        log "Ghidra source: ${GHIDRA_SOURCE_DIR}"
+    else
+        log "Ghidra source not found at ${GHIDRA_SOURCE_DIR}"
+    fi
+
+    if [ -n "${GHIDRA_INSTALL_DIR:-}" ]; then
+        log "Ghidra binary: ${GHIDRA_INSTALL_DIR}"
+    else
+        log "GHIDRA_INSTALL_DIR is not set"
+    fi
+
+    if command -v java &>/dev/null; then
+        log "Java: $(java -version 2>&1 | head -1)"
+    else
+        log "Java not found"
+    fi
+
+    if command -v gradle &>/dev/null; then
+        log "Gradle: $(gradle --version 2>&1 | grep '^Gradle' || echo 'unknown')"
+    else
+        log "Gradle not found"
+    fi
+
+    exit 0
+fi
+
+# ─── Remote mode (claude.ai/code) ─────────────────────────────
+log "Remote environment detected, setting up Ghidra..."
+
+# Clone Ghidra source (background)
+clone_ghidra_source() {
+    if [ -d "${GHIDRA_SOURCE_DIR}/.git" ]; then
+        log "Ghidra source already exists at ${GHIDRA_SOURCE_DIR}"
+        return 0
+    fi
+    log "Cloning Ghidra source (shallow)..."
+    git clone --depth=1 --single-branch https://github.com/NationalSecurityAgency/ghidra.git "${GHIDRA_SOURCE_DIR}" 2>&1 | tail -1
+    log "Ghidra source cloned to ${GHIDRA_SOURCE_DIR}"
+}
+
+# Download and extract Ghidra binary (background)
+install_ghidra_binary() {
+    # Check if already installed (mkdir -p ensures find doesn't fail with pipefail)
+    mkdir -p "${GHIDRA_INSTALL_BASE}"
+    existing=$(find "${GHIDRA_INSTALL_BASE}" -maxdepth 1 -name "ghidra_*" -type d | head -1)
+    if [ -n "${existing}" ]; then
+        log "Ghidra binary already installed at ${existing}"
+        echo "${existing}"
+        return 0
+    fi
+
+    log "Querying GitHub for latest Ghidra release..."
+    # Get the latest release asset URL for the zip (not the source archives)
+    download_url=$(curl -fsSL "https://api.github.com/repos/NationalSecurityAgency/ghidra/releases/latest" \
+        | grep -o '"browser_download_url": *"[^"]*"' \
+        | grep -v 'src\|SHA-256\|source' \
+        | head -1 \
+        | sed 's/"browser_download_url": *"//;s/"//')
+
+    if [ -z "${download_url}" ]; then
+        log "ERROR: Could not determine Ghidra download URL"
+        return 1
+    fi
+
+    filename=$(basename "${download_url}")
+    log "Downloading ${filename}..."
+
+    curl -fsSL -o "/tmp/${filename}" "${download_url}"
+
+    log "Extracting ${filename}..."
+    unzip -q -o "/tmp/${filename}" -d "${GHIDRA_INSTALL_BASE}"
+    rm -f "/tmp/${filename}"
+
+    installed=$(find "${GHIDRA_INSTALL_BASE}" -maxdepth 1 -name "ghidra_*" -type d | head -1)
+    log "Ghidra binary installed at ${installed}"
+    echo "${installed}"
+}
+
+# Run both downloads in parallel
+CLONE_LOG="/tmp/reva-clone.log"
+BINARY_LOG="/tmp/reva-binary.log"
+
+clone_ghidra_source > "${CLONE_LOG}" 2>&1 &
+CLONE_PID=$!
+
+install_ghidra_binary > "${BINARY_LOG}" 2>&1 &
+BINARY_PID=$!
+
+# Wait for both to complete
+CLONE_OK=true
+BINARY_OK=true
+
+if ! wait ${CLONE_PID}; then
+    CLONE_OK=false
+    log "ERROR: Ghidra source clone failed:"
+    cat "${CLONE_LOG}" >> "${LOG_FILE}"
+fi
+cat "${CLONE_LOG}" | while read -r line; do log "(source) ${line}"; done
+
+if ! wait ${BINARY_PID}; then
+    BINARY_OK=false
+    log "ERROR: Ghidra binary install failed:"
+    cat "${BINARY_LOG}" >> "${LOG_FILE}"
+fi
+cat "${BINARY_LOG}" | while read -r line; do log "(binary) ${line}"; done
+
+# Extract the install dir from the binary log (last line is the path)
+GHIDRA_DIR=$(tail -1 "${BINARY_LOG}")
+
+if [ "${BINARY_OK}" = true ] && [ -d "${GHIDRA_DIR}" ]; then
+    export GHIDRA_INSTALL_DIR="${GHIDRA_DIR}"
+    log "GHIDRA_INSTALL_DIR=${GHIDRA_INSTALL_DIR}"
+
+    # Persist for all subsequent Claude Code bash commands
+    if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
+        echo "GHIDRA_INSTALL_DIR=${GHIDRA_INSTALL_DIR}" >> "${CLAUDE_ENV_FILE}"
+        log "Persisted GHIDRA_INSTALL_DIR to ${CLAUDE_ENV_FILE}"
+    fi
+else
+    log "WARNING: Ghidra binary not available, build will fail"
+fi
+
+# Configure JVM proxy for Gradle (JVM doesn't honor https_proxy)
+setup_gradle_proxy() {
+    local proxy_url="${https_proxy:-${HTTPS_PROXY:-}}"
+    [ -z "${proxy_url}" ] && return 0
+
+    # Parse proxy URL: http://user:pass@host:port
+    local proxy_hostport proxy_host proxy_port
+    proxy_hostport=$(echo "${proxy_url}" | sed 's|http://.*@||')
+    proxy_host=$(echo "${proxy_hostport}" | cut -d: -f1)
+    proxy_port=$(echo "${proxy_hostport}" | cut -d: -f2)
+
+    # Check if proxy requires authentication (has user@host pattern)
+    if echo "${proxy_url}" | grep -q '@'; then
+        log "Proxy with auth detected, starting local forwarding proxy..."
+        local proxy_script="${CLAUDE_PROJECT_DIR}/.claude/hooks/gradle-proxy.py"
+        python3 "${proxy_script}" &
+        GRADLE_PROXY_PID=$!
+
+        # Wait for proxy to be ready
+        local retries=0
+        while [ ${retries} -lt 10 ]; do
+            if curl -s --proxy http://127.0.0.1:18080 --max-time 2 https://repo.maven.apache.org/ >/dev/null 2>&1; then
+                break
+            fi
+            sleep 0.5
+            retries=$((retries + 1))
+        done
+
+        if [ ${retries} -ge 10 ]; then
+            log "WARNING: Local proxy failed to start, Gradle may not resolve dependencies"
+            return 1
+        fi
+
+        proxy_host="127.0.0.1"
+        proxy_port="18080"
+        log "Local proxy ready on ${proxy_host}:${proxy_port}"
+    fi
+
+    local java_proxy_opts="-Dhttps.proxyHost=${proxy_host} -Dhttps.proxyPort=${proxy_port} -Dhttp.proxyHost=${proxy_host} -Dhttp.proxyPort=${proxy_port}"
+    export JAVA_TOOL_OPTIONS="${java_proxy_opts}"
+
+    if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
+        echo "JAVA_TOOL_OPTIONS=${java_proxy_opts}" >> "${CLAUDE_ENV_FILE}"
+        log "Persisted JAVA_TOOL_OPTIONS for Gradle proxy"
+    fi
+}
+
+# Warm gradle dependency cache
+if [ "${BINARY_OK}" = true ] && command -v gradle &>/dev/null; then
+    setup_gradle_proxy
+    log "Warming gradle dependency cache..."
+    cd "${CLAUDE_PROJECT_DIR}"
+    gradle --no-daemon dependencies --quiet 2>&1 | tail -3
+    log "Gradle dependencies cached"
+fi
+
+if [ "${CLONE_OK}" = false ] || [ "${BINARY_OK}" = false ]; then
+    log "Setup completed with errors (check ${LOG_FILE})"
+    exit 1
+fi
+
+log "Setup complete"

reverse_engineering_assistant-7.2.1/.claude/launch.json

@@ -0,0 +1,19 @@
+{
+  "version": "1.0.0",
+  "configurations": [
+    {
+      "name": "ReVa Headless MCP Server",
+      "runtimeExecutable": "uv",
+      "runtimeArgs": ["run", "python", "scripts/reva_headless_server.py", "--wait"],
+      "port": 8080,
+      "autoVerify": false
+    },
+    {
+      "name": "ReVa CLI (stdio bridge)",
+      "runtimeExecutable": "uv",
+      "runtimeArgs": ["run", "mcp-reva", "--verbose"],
+      "port": 8080,
+      "autoVerify": false
+    }
+  ]
+}

reverse_engineering_assistant-7.2.1/.claude/settings.json

@@ -0,0 +1,23 @@
+{
+  "permissions": {
+    "additionalDirectories": ["../ghidra"],
+    "allow": [
+      "Search(path:../ghidra)",
+      "Read(../ghidra/**)"
+    ],
+    "deny": []
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/setup-remote-env.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

reverse_engineering_assistant-7.2.1/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "reva",
+  "description": "ReVa - AI-assisted binary analysis and reverse engineering with Ghidra integration",
+  "owner": {
+    "name": "CyberKaida"
+  },
+  "plugins": [
+    {
+      "name": "ReVa",
+      "source": "./ReVa",
+      "description": "AI-assisted binary analysis and reverse engineering with Ghidra integration"
+    }
+  ]
+}

reverse_engineering_assistant-7.2.1/.continue/docs/new-doc-1.yaml

@@ -0,0 +1,6 @@
+name: New doc
+version: 0.0.1
+schema: v1
+docs:
+  - name: New docs
+    startUrl: https://docs.continue.dev

reverse_engineering_assistant-7.2.1/.continue/docs/new-doc.yaml

@@ -0,0 +1,6 @@
+name: Model Context Protocol Java
+version: 0.0.1
+schema: v1
+docs:
+  - name: MCP
+    startUrl: https://modelcontextprotocol.io/sdk/java/mcp-overview

reverse_engineering_assistant-7.2.1/.gitattributes

@@ -0,0 +1,5 @@
+tests/fixtures/test_fat_binary filter=lfs diff=lfs merge=lfs -text
+tests/fixtures/test_archive.zip filter=lfs diff=lfs merge=lfs -text
+tests/fixtures/test_arm64 filter=lfs diff=lfs merge=lfs -text
+tests/fixtures/test_x86_64 filter=lfs diff=lfs merge=lfs -text
+tests/fixtures/*.zip filter=lfs diff=lfs merge=lfs -text