Skip to content
Back to search

rea

The reverse-engineering framework you can run anywhere, with nothing installed, and actually trust.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mytechnotalent--rea/badge.svg)](/listings/mytechnotalent--rea)

HTML

<a href="/listings/mytechnotalent--rea"><img src="/api/listings/mytechnotalent--rea/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 292 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ![image](Reverse-Engineering-Assistant.png)
  2. ## FREE Reverse Engineering Self-Study Course [HERE](https://github.com/mytechnotalent/Reverse-Engineering-Tutorial)
  3. <br>
  4. # Reverse Engineering Assistant (REA) v7.1.0
  5. **The reverse-engineering framework you can run anywhere, with nothing installed, and actually trust.**
  6. ```bash
  7. rea suspect
  8. ```
  9. Writes `re-suspect.md`, `re-suspect.pdf`, and `re-suspect.json` next to the target. That's the whole workflow.
  10. **Targets in. Answers out.** One command. Hybrid autonomous multi-agent reasoning and a deterministic engine. Built in 100% pure Rust — run anywhere, install nothing, and every claim verified.
  11. <br>
  12. # New in v7.1.0
  13. REA v7.1.0 adds more artifacts and deeper provenance — still pure Rust, offline, and evidence-backed.
  14. - **Model artifacts.** GGUF and `safetensors` files are parsed for version, architecture/name, tensor declarations, data types, and total parameter counts, with a new `rea model <file>` command and MCP `inspect_model_artifact` tool.
  15. - **Godot PCK.** Standalone and embedded Godot resource packs (formats v1–v3, including the trailing locator) are inventoried with paths, sizes, and encryption flags, with a new `rea godot <file>` command and MCP `inspect_godot` tool.
  16. - **Deeper provenance.** Rust `cargo-auditable` metadata now includes each crate's `source` and resolved dependency edges, surfaced in the SBOM as component properties.
  17. # Features
  18. - **One command.** `rea <file>` produces a Markdown report, an executive typeset PDF report, and a machine-readable JSON report beside the target.
  19. - **Any file.** Format is detected from contents, not the file extension.
  20. - **Autonomous AI Security Assessment.** When configured with an API key, REA runs an autonomous, 90-turn tool-calling analyst loop with native function calling. The model is the report's author and inspects the target itself (decompile, emulate, decrypt, audit, rules, regions, 8051, and more), writing an Executive Overview, Target Summary, Architecture Analysis, Recovered Secrets, Indicators of Compromise, and Recommendations. A grounding validator flags any quotation not backed by engine evidence.
  21. - **Deterministic Offline Fallback.** With no AI API key, REA runs completely offline, generating comprehensive deterministic technical reports with zero network requests.
  22. - **Firmware & Filesystems.** U-Boot legacy images (`uImage`), SquashFS 4.0 root filesystems, embedded Linux partitions, and raw microcontroller firmware.
  23. - **Formats.** PE (EXE/DLL/SYS), ELF, Mach-O, universal binaries, firmware bundles, and raw ARM Cortex-M images.
  24. - **Static Analysis.** Cryptographic hashes (MD5, SHA-1, SHA-256), import hashes (imphash), Shannon entropy, sections, memory layouts, imports, exports, and mitigations (ASLR, DEP/NX, CFG, PIE, RELRO, stack canaries).
  25. - **SBOM & Provenance.** `rea sbom <file>` emits `CycloneDX` and `SPDX` JSON; toolchain, libraries, managed assembly references, Rust `cargo-auditable` crates, and build paths (PDB/DWARF) are recovered offline and tied into the evidence bundle.
  26. - **Disassembly.** Recursive-descent function and call-graph recovery with inline symbol and string resolution and per-instruction semantics.
  27. - **P-Code Emulation.** Sandboxed software emulator executes target code without native host execution, unmasking runtime strings, keys, and decrypted payloads.
  28. - **Protectors & Packing.** High-entropy mapping, abnormal memory layouts, W^X violations, and signature matching for commercial protectors.
  29. - **Indicators.** Structured extraction of URLs, IPs, emails, registry keys, file paths, commands, and user agents.
  30. - **Artifact Formats.** WebAssembly, SQLite, ELF core dumps, EVM bytecode, Apple property lists, Flutter APKs, PCAP/HAR captures, JavaScript source maps, MS-DOS MZ executables, GGUF/safetensors model artifacts, and Godot PCK archives.
  31. - **Strict Safety.** `#![forbid(unsafe_code)]` enforced across the entire codebase. Malformed or hostile inputs can never compromise the host.
  32. <br>
  33. # Supported Targets
  34. | Format | Parsing | Analysis & Triage |
  35. | --- | --- | --- |
  36. | PE (EXE, DLL, SYS) | Full | x86, x86-64, imports, mitigations, imphash |
  37. | ELF (Linux, BSD, Android) | Full | x86/x86-64 + every SLEIGH architecture |
  38. | Mach-O and universal | Full | x86/x86-64 + every SLEIGH architecture |
  39. | Go Executables (ELF/PE/Mach-O) | Full | `pclntab` functions, `modinfo` dependencies, toolchain version |
  40. | .NET CIL Assemblies (EXE/DLL) | Full | ECMA-335 CLI metadata, `BSJB` streams, CIL disassembly, token→name |
  41. | Android APK & DEX Packages | In-memory | `AndroidManifest.xml` binary XML, permissions, `classes.dex` |
  42. | Electron Applications (`.asar`) | In-memory | Archive unpacking, IPC channel extraction, hardcoded secrets |
  43. | U-Boot images (`uImage`) | Full | Kernel identification, compression, rootfs offsets |
  44. | SquashFS 4.0 Filesystems | In-memory | Unpacking, credential discovery, sub-target triage |
  45. | Raw ARM Cortex-M firmware | Vector table, flash base | ARM Thumb disassembly and handler mapping |
  46. | ARM Cortex-A (Linux, Android, iOS) | Full (ELF/Mach-O) | ARMv7-A and ARMv8-A/AArch64 disassembly, call graphs |
  47. | WebAssembly modules (`.wasm`) | Full | Sections, imports, exports, function counts |
  48. | SQLite databases (`.db`/`.sqlite`) | Full | Header, tables, columns, views, triggers, sampled rows |
  49. | ELF core dumps | Full | Signal, registers, loadable mappings, mapped files |
  50. | EVM bytecode (raw or hex) | Full | Selectors, jump targets, notable opcodes, mutability |
  51. | Apple property lists & bundles | Full | Binary/XML plist, bundle identifier and version |
  52. | Flutter APKs & zip archives | Full | Per-ABI native libraries, digests, Flutter assets |
  53. | PCAP and HAR captures | Full | Packets, HTTP requests, hosts, HAR entries |
  54. | JavaScript source maps | Full | Sources, mapping statistics, `sourceMappingURL` |
  55. | MS-DOS `MZ` executables | Full | Header, relocations, 16-bit entry disassembly |
  56. | Java class files (`.class`) | Full | Constant pool, this/super, methods, fields |
  57. | Android `resources.arsc` | Full | Packages, string pool, configuration locales |
  58. | DWARF debug info (ELF) | Full | Compile units, directories, function symbols |
  59. | Windows PDB (`.pdb`) | Full | MSF container, info-stream version, age, GUID |
  60. | YARA-subset rules | Matching | Literal/wide/nocase/hex patterns with boolean conditions |
  61. | Any raw or unknown file | Identity, hashes, entropy | String extraction, indicators, entropy mapping |
  62. Non-x86 disassembly and emulation are powered by embedded SLEIGH processor specifications compiled directly by a pure-Rust engine. No Ghidra, Java, Python, or external command-line tools are required.
  63. <br>
  64. # One-Shot Usage
  65. The one-shot is the primary workflow: point REA at a target and read the report.
  66. ```bash
  67. rea <path-to-target>
  68. ```
  69. REA writes three files beside the target:
  70. - `re-<name>.md` — GitHub-flavored Markdown report.
  71. - `re-<name>.pdf` — executive typeset PDF report.
  72. - `re-<name>.json` — machine-readable summary (format, architecture, hashes, mitigations, imports, capabilities, rules, vulnerabilities, crypto).
  73. **Windows x64 (PowerShell)**
  74. ```powershell
  75. .\rea.exe .\sample.exe
  76. ```
  77. **macOS Apple Silicon**
  78. ```bash
  79. ./rea ./sample
  80. ```
  81. **Linux x64**
  82. ```bash
  83. ./rea ./sample
  84. ```
  85. Focused subcommands are also available:
  86. ```bash
  87. rea decompile <target> [symbol|0xaddr] # recovered pseudo-C
  88. rea strings <target> # extracted strings
  89. rea decrypt <target> # strings hidden by single-byte ciphers
  90. rea crypto <target> # cryptographic constants
  91. rea rules <target> # capability rules (ATT&CK/MBC)
  92. rea audit <target> [--sarif] # vulnerability sinks + SARIF
  93. rea unpack <target> [0xaddr] # emulation-driven unpacking
  94. rea emulate <target> [0xaddr] # sandboxed emulation
  95. rea dotnet <assembly> # .NET CIL disassembly
  96. rea wasm <module.wasm> # WebAssembly sections and links
  97. rea sqlite <database> # SQLite schema and rows
  98. rea coredump <core> # ELF core signal, registers, mappings
  99. rea evm <bytecode> # EVM selectors and mutability
  100. rea plist <Info.plist> # property list and bundle metadata
  101. rea sourcemap <app.js.map> # source map sources and statistics
  102. rea pcap <capture.pcap> # packets, HTTP requests, hosts
  103. rea flutter <app.apk> # per-ABI native libraries and assets
  104. rea dos <program.exe> # MZ header and 16-bit entry code
  105. rea java <App.class> # Java class pool, methods, fields
  106. rea arsc <resources.arsc> # Android packages, strings, locales
  107. rea dwarf <app.elf> # DWARF compile units and functions
  108. rea pdb <app.pdb> # Windows PDB version, age, GUID
  109. rea yara <target> <rules.yar> # YARA-subset signature matching
  110. rea analyze <target> # alias for the one-shot
  111. ```
  112. <br>
  113. # MCP Server Usage (Second Option)
  114. The MCP server exposes the same engine as tools so AI coding agents can drive the analysis interactively. It runs over stdio (JSON-RPC 2.0) via:
  115. ```bash
  116. rea serve
  117. ```
  118. One-step setup writes the agent configuration for the current binary:
  119. ```bash
  120. rea mcp --setup # writes mcp_config.json and opencode.jsonc for this binary
  121. rea mcp --config # prints ready-to-paste snippets for every supported agent
  122. ```
  123. ### Claude Code
  124. ```bash
  125. claude mcp add rea rea serve
  126. ```
  127. Then ask, for example:
  128. ```text
  129. Open ./sample.exe with rea, decompile the entry point, run the capability rules,
  130. and explain what it does.
  131. ```
  132. ### OpenCode
  133. Add REA to `opencode.json` (project) or `~/.config/opencode/opencode.jsonc` (global):
  134. ```json
  135. {
  136. "$schema": "https://opencode.ai/config.json",
  137. "mcp": {
  138. "rea": {
  139. "type": "local",
  140. "command": ["/absolute/path/to/rea", "serve"],
  141. "enabled": true
  142. }
  143. }
  144. }
  145. ```
  146. `rea mcp --setup` writes this for you with the correct absolute path. Restart OpenCode, then ask:
  147. ```text
  148. Use rea to open ./sample.exe, list the key functions, and decompile the entry point.
  149. ```
  150. ### Per-Platform MCP Setup
  151. **Windows x64 (PowerShell)**
  152. ```powershell
  153. .\rea.exe mcp --setup
  154. # Claude Code:
  155. claude mcp add rea "$PWD\rea.exe" serve
  156. ```
  157. **macOS Apple Silicon**
  158. ```bash
  159. ./rea mcp --setup
  160. # Claude Code:
  161. claude mcp add rea "$PWD/rea" serve
  162. ```
  163. **Linux x64**
  164. ```bash
  165. ./rea mcp --setup
  166. # Claude Code:
  167. claude mcp add rea "$PWD/rea" serve
  168. ```
  169. The server exposes 31 tools: `open_binary`, `binary_session`, `list_functions`, `decompile_function`, `find_xrefs`, `search_strings`, `analyze_firmware`, `analyze_javascript`, `generate_dossier`, `inspect_go`, `inspect_dotnet`, `inspect_android`, `run_rules`, `audit`, `inspect_crypto`, `decrypt_strings`, `emulate`, `unpack`, `inspect_wasm`, `inspect_sqlite`, `inspect_coredump`, `inspect_evm`, `inspect_plist`, `inspect_sourcemap`, `inspect_capture`, `inspect_flutter`, `inspect_dos`, `inspect_dwarf`, `inspect_java`, `inspect_arsc`, `inspect_pdb`.
  170. <br>
  171. # AI Analyst Configuration
  172. To enable the autonomous tool-calling analyst loop, provide an [OpenRouter](https://openrouter.ai) API key. REA locates the key from environment variables or a `.env` file in the current or ancestor directories:
  173. ```bash
  174. # In .env or shell environment:
  175. OPENROUTER_API_KEY="sk-or-v1-..."
  176. # Optional model selection (defaults to high-throughput free tier):
  177. OPENROUTER_MODEL="nvidia/nemotron-3.5-lightning:free"
  178. ```
  179. If no key is configured, REA operates in purely deterministic offline mode.
  180. <br>
  181. # Build from Source
  182. Install the [stable Rust toolchain](https://rustup.rs), clone the repository, and build on your operating system:
  183. ```bash
  184. git clone https://github.com/mytechnotalent/rea.git
  185. cd rea
  186. ```
  187. **Windows x64 (PowerShell)**
  188. ```powershell
  189. rustup target add x86_64-pc-windows-msvc
  190. cargo build --release -p rea --target x86_64-pc-windows-msvc
  191. ```
  192. Output: `target\x86_64-pc-windows-msvc\release\rea.exe`
  193. **macOS Apple Silicon**
  194. ```bash
  195. rustup target add aarch64-apple-darwin
  196. cargo build --release -p rea --target aarch64-apple-darwin
  197. ```
  198. Output: `target/aarch64-apple-darwin/release/rea`
  199. **Linux x64**
  200. ```bash
  201. rustup target add x86_64-unknown-linux-gnu
  202. cargo build --release -p rea --target x86_64-unknown-linux-gnu
  203. ```
  204. Output: `target/x86_64-unknown-linux-gnu/release/rea`
  205. Install a native build on your `PATH` with:
  206. ```bash
  207. cargo install --path crates/rea
  208. ```
  209. Prebuilt binaries for macOS Apple Silicon (`aarch64-apple-darwin`) are located in [`releases/`](releases). To build for Windows or Linux, follow the commands above.
  210. <br>
  211. # Quality & Verification
  212. ```bash
  213. cargo xtask check
  214. ```
  215. Enforces strict zero-violation coding standards (`CONVENTIONS.md`), runs `cargo fmt --check`, denies all Clippy warnings (`cargo clippy --workspace --all-targets -- -D warnings`), and executes the complete workspace test suite.
  216. <br>
  217. # License
  218. [MIT License](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.