REA (Reverse Engineer Anything) is a Docker-based reverse engineering toolkit that helps AI agents analyze applications, executables, and software behavior without needing access to the source code. It includes built-in Android APK analysis tools like JADX, Apktool, and ADB; Ghidra is also available if required.
The Docker image also provides a token-protected, broadcast-capable HTTP MCP endpoint, as well as support for stdio-based MCP communication and a command-line interface (CLI).
Developed by morluto, REA allows developers to inspect Android applications, Electron software, .NET assemblies, Go and Rust binaries, and other supported platforms. The npm package `rea-agents` provides the core functionality, but users typically need to install dependencies like JDK, JADX, and Apktool separately. This Docker image simplifies setup by bundling the necessary tools into a single environment.
With REA, an AI agent can examine program logic, find critical code, trace references, inspect resources, and analyze runtime behavior to better understand how specific features work.
Key Features of REA
1. Android APK Analysis
- Decompiles Android APK files with JADX.
- Decodes application resources and manifests with Apktool.
- Examines Java code and associated decompiled code.
- Interacts with connected Android devices using ADB.
- Examines application components and their references.
2. Native Binary Analysis
- Analyzes executables and shared libraries.
- Examines functions, strings, and cross-references.
- Examines relationships between functions and code snippets.
- Uses Ghidra for detailed binary analysis when needed.
3. JavaScript and Electron Applications
- Examines JavaScript-based application packages.
- Analyzes Electron applications and ASAR files.
- Examine modules, application paths, and inter-process communication (IPC).
- Identify connections for native dependencies.
4. MCP Integration for AI Agents
- Connect AI coding agents using the Model Context Protocol (MCP).
- Use HTTP for remote tool access.
- Secure HTTP endpoints with token-based authentication.
- Support stdio communication for compatible local MCP clients.
- Access reverse engineering capabilities via the CLI.
5. Runtime Behavior Analysis
- Capture browser or compatible process activity.
- Compare observations from multiple runs.
- Investigate how application behavior changes under different conditions.
- Combine runtime observations with static code analysis.
6. Docker-Based Environment
- Run the toolkit in a container environment.
- Reduce the need to manually install Android analysis dependencies.
- Group reverse engineering tools into a single configuration.
- Simplify integration with compatible AI agents and development workflows.
How REA Works?
REA helps an AI agent move from asking a question about software behavior to obtaining an explanation based on code and observations.
Step 1: Select the Target
Specify the application, binary, APK, software directory, or other compatible target you want to investigate. Describe the function or behavior you want to understand.
Step 2: Investigate the Software
REA provides the agent with the appropriate investigation tools. The agent can trace code, inspect resources, trace references, investigate functions, or collect compatible runtime observations.
Step 3: Identify Relevant Logic
The agent uses the collected information to find the code and rules responsible for the function. It can then explain how the behavior works and identify helpful implementation details.
Step 4: Recreate or Modify the Function
Based on the results, the agent can help you develop a small demo, implement similar functions, or suggest changes to the project that you have permission to modify.
Example 1: Understanding the Speed of a Dinosaur Game
Imagine a dinosaur game where the speed gradually increases as the player runs. REA can help you investigate the code responsible for this behavior.
1. Formulate a Question
Ask your AI programming agent to investigate the game and identify the rule that controls the speed.
2. Understand the Speed Calculation
The agent can search the relevant code and understand how the initial speed changes.
Example 2: Simulating the Percent Key on a Calculator
The percentage keys on calculators can behave differently depending on the operation being performed. REA can help an agent verify the associated logic in supported calculator implementations.
1. Verifying the Percent Operation
Ask the agent how the calculator handles the % key after addition and multiplication.
2. Defining Calculation Rules
For example, a simple calculator might implement the following rules:
- After addition: Calculate the percentage of the first number. Example: 10% of 200 is 20, so 200 + 20 = 220.
- After multiplication: Convert 10% to its decimal form (0.1). Therefore, 200 × 0.1 = 20.
These examples illustrate possible calculator rules; the actual behavior depends on the calculator being tested.
3. Creating a Working Version
The agent can create a small demo of the calculator using the discovered logic. Users can select an operation, enter a value, press a percentage button, and compare the results.
REA Guide for Various Software Types
Native Binaries
Examine executables and libraries by analyzing the relationships between functions, strings, references, and code components.
JavaScript and Electron
Explore application modules, routing logic, IPC communication, native dependencies, and Electron ASAR archive files.
Browser and Runtime Analysis
Capture the activity of supported browsers or processes and compare the results of multiple passes to understand changes in software behavior.
Android Applications
Use JADX, Apktool, and ADB to examine APK code, application resources, manifests, and interactions with supported devices.
