Ablation is a self-contained reverse engineering framework.
It depends on neither legacy tools nor an MCP server, which removes the attack surface associated with MCP.
When used with Codex or Claude Code, it operates as an autonomous reverse engineering system.
Analysis: semantic search, binary lifting, hypothesis engine, C++ vtable reconstruction, cross-library tracing, DAG adapter
| Capability | |
|---|---|
| Semantic Code Search | Finds functions by describing what they do because stripped binaries have no symbols to search. Queries are scoped to the target binary so results return in under a second. |
| On-Demand Analysis | Loads in seconds because it only analyzes the code being examined. Traditional disassemblers parse the entire file into a database before you can do anything. |
| Binary Lifting | Translates machine code to readable pseudo-C across 19 architectures. ARM64 and x86-64 get register-level taint tracking so data flow is visible in the lifted output. |
| Hypothesis Engine | Tracks competing theories about what a function does and scores evidence against each one. Sessions persist across engagements so analysis resumes where it left off. |
| C++ Vtable Reconstruction | Recovers C++ virtual dispatch tables from stripped ELF binaries on any architecture and names each slot. A generated type-annotation script propagates slot names through every call site so the decompiler shows method names instead of function pointer offsets. |
| Cross-Library Analysis | Traces an argument across up to three shared library hops so taint paths that cross library boundaries reach their sink rather than stopping at the first call. |
| DAG Adapter Language | Describes instruction set encodings as directed acyclic graphs so every architecture shares the same analysis code path. Without it, each ISA requires its own exception handler and the analyzer count scales with the architecture count. |
Security Analysis: taint analysis, exposure mapping, finding validation, source code auditing, compiler defect detection, cryptographic analysis
| Capability | |
|---|---|
| Taint Analysis | Follows network input through the call graph to security-sensitive sinks across 14 architectures. Library call sites do not stop the trace because register-level tracking resolves shared library stubs. |
| Pre-Authentication Exposure | Finds every code path from the network entry point to a security-sensitive operation that runs before authentication. Manual review starts at the authentication boundary because the output is a reachability map, not a raw disassembly. |
| Finding Validation | Generates a working HTTP request that reproduces each confirmed finding at the protocol level. The request includes the expected response delta and CWE classification so a PSIRT submission arrives with working proof. |
| Source Code Auditing | Scores every source file by risk and batches the low-risk ones so manual review covers only the files most likely to contain vulnerabilities. |
| Compiler Defect Detection | Finds security defects that the compiler introduced through miscompilation. Optimizer defects that silently select the wrong comparison operand can produce hundreds of confirmed vulnerabilities across a single firmware image. |
| Cryptographic Analysis | Recovers cryptographic key material directly from compiled firmware and audits TLS and JWT configurations, so cryptographic findings do not require source access or a decryption oracle. |
Runtimes & Formats: LoongArch64, nanoMIPS, Windows PE, BYOVD drivers, Android, Erlang/BEAM, Go, game engines, firmware
| Capability | |
|---|---|
| LoongArch64 | The only public reverse engineering toolkit built specifically for LoongArch64. It covers the full analysis pipeline so no architecture-specific workarounds are needed. |
| nanoMIPS | Follows tainted data through nanoMIPS binaries interprocedurally, resolving branch targets and PLT stubs that no other public tool handles. |
| Windows PE Security Analysis | Audits a Windows PE binary for security weaknesses in a single pass. It checks CFG bypass exports, SafeSEH gaps, unauthenticated RPC endpoints, COM registration gaps, and kernel pool overflows so the full attack surface is visible before manual review begins. |
| Windows Kernel Driver & BYOVD | Classifies signed kernel drivers for BYOVD capability before they are deployed. Physical memory access, privilege token manipulation, and callback removal each trigger a finding. |
| Android / APK Analysis | Maps the APK attack surface and ranks native libraries by risk before manual analysis begins. |
| Erlang / BEAM Analysis | Decodes BEAM bytecode to readable pseudo-IR so Erlang and Elixir applications can be analyzed without source. High-risk import patterns and obfuscation indicators surface without executing the application. |
| Go Binary Reverse Engineering | Recovers function names from stripped Go binaries because the runtime embeds a metadata table that survives stripping. |
| Game & Legacy RE | Labels stripped game binary functions by engine so analysis starts at the game logic layer instead of the engine layer. Also handles PS3 Cell SPU and classic Mac OS PEF binaries. |
| Firmware Extraction | Decrypts vendor-encrypted firmware without a key because predictable patterns in inner partitions reveal it. Handles vendor-modified squashfs images including ARM64 BCJ-filtered variants. |
| Firmware Key Corpus | Classifies recovered firmware keys against a cross-image family table. An anomalous key count flags a potential finding before decryption begins. |
Workflow: version diffing, cross-target learning, module quality gate, coverage gate
| Capability | |
|---|---|
| Version Diffing | Checks whether the logic changed, not whether the file changed, so a cosmetic recompile cannot hide an unpatched vulnerability. |
| Cross-Target Learning | Every confirmed finding seeds future semantic searches, so the tool gets sharper with each engagement. |
| Module Quality Gate | FORGE audits every user-written module before it can be stored, so local extensions meet the same standard as the modules that ship with Ablation. |
| Coverage Gate | The taint engine requires 85% statement coverage on every commit, so a regression in taint logic fails the test suite before it reaches a firmware engagement. |
| ISA / Runtime | Variants |
|---|---|
| x86 | x86-32 · x86-64 |
| ARM | ARM-32 · ARM-64 |
| MIPS | MIPS-32 · nanoMIPS · MIPS-64 |
| PowerPC | PPC-32 · PPC-64 |
| RISC-V | RISC-V 32 · RISC-V 64 |
| ARC | ARC EM/HS |
| V850 | V850-32 |
| LoongArch | LoongArch64 |
| DEX | Dalvik · ART |
| ARK | ArkTS |
| BEAM | Erlang · Elixir |
Ablation has been used to analyze production firmware and kernel drivers from Cisco, Fortinet, TencentOS, Huawei, and more.
Following coordinated disclosure, the Cisco Product Security Incident Response Team (PSIRT) adopted Ablation for internal vulnerability triage and continues to use it to evaluate ongoing disclosure reports. Cisco Adaptive Security Appliance (ASA) LINA is among the artifacts analyzed, with findings submitted through CERT/CC VINCE.
| CVE | Product | Title | CVSS | Advisory |
|---|---|---|---|---|
| CVE-2026-76420 | Secure Firewall Management Center (FMC) | Peer Impersonation | 9.0 Critical | cisco-sa-fmc2-multivulns-HXgcqRG |
| CVE-2026-76412 | Secure Firewall Management Center (FMC) | Privilege Escalation to root | 8.5 High | cisco-sa-fmc2-multivulns-HXgcqRG |
| CVE-2026-76413 | Secure Firewall Management Center (FMC) | Single Sign-On Token Forgery | 8.5 High | cisco-sa-fmc2-multivulns-HXgcqRG |
| CVE-2026-76447 | Identity Services Engine (ISE) | OCSP Responder Authentication Bypass | 5.3 Medium | cisco-sa-ise-multiauth-bypass-sgD2HbL4 |
This project was greatly informed and inspired by several key literary works.
Research Papers
Books supplied by www.oreilly.com | github.com/oreillymedia
| Title | Authors |
|---|---|
| The Art of Software Security Assessment | Mark Dowd, John McDonald, Justin Schuh |
| Practical Binary Analysis | Dennis Andriesse |
| Practical Malware Analysis | Michael Sikorski, Andrew Honig |
| Practical Reverse Engineering | Bruce Dang, Alexandre Gazet, Elias Bachaalany |
| Hacking: The Art of Exploitation (2e) | Jon Erickson |
| Learning Linux Binary Analysis | Ryan O'Neill |
| Windows Internals Part 1 & 2 | Pavel Yosifovich, Mark Russinovich, David Solomon, Alex Ionescu, Andrea Allievi |
| Rootkits: Subverting the Windows Kernel | Greg Hoglund, Jamie Butler |
| Advanced Compiler Design and Implementation | Steven Muchnick |
| Engineering a Compiler | Keith Cooper, Linda Torczon |
| Practical IoT Hacking | Fotios Chantzis, Ioannis Stais, Paulino Calderon, Evangelos Deirmentzoglou, Beau Woods |
| Inside the Android OS: Building, Customizing, Managing and Operating Android System Services | G. Blake Meike |
| Malware Analysis and Detection Engineering | Abhijit Mohanta, Anoop Saldanha |
| Evasive Malware | Kyle Cucci |
| Hacking Cryptography | Kamran Khan, Bill Cox |
| Real-World Cryptography | David Wong |
Honorable Mention
Microsoft Excel (Data Analysis ToolPak) When analyzing closed infrastructure or securing black-box systems, this exact process is called timing analysis or telemetry reverse engineering. Without source code, the Data Analysis ToolPak mathematically deconstructs how an application works on the backend by strictly observing its inputs and outputs.
ELF · PE · firmware
┌────────┐ ┌───────────┐ ┌──────────┐
│ ELF │ │ PE/Driver │ │ firmware │
└───┬────┘ └─────┬─────┘ └────┬─────┘
└────────────────┴────────────────┘
│
load
▼
PLT · Strings · Call Graph · XRefs
╔══════════════════════════════════════╗
║ BinaryContext ║
╠══════════════════════════════════════╣
║ PLT · Strings · Call Graph ║
║ XRefs · CFG · Func boundaries ║
╚══════════════════════════════════════╝
│
context
▼
Central Orchestrator
╔══════════════════════════════════════╗
║ Claude Code (Orchestrator) ║
╚══════════════════════════════════════╝
│
┌─────────────┼─────────────┐
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Corpus
8000
│ │ Taint │ │ FmtStr │
│ Semantic │ │ Diffing │ │ Heap │
└─────────────┘ └─────────────┘ │ MultiArch │
│ Driver │
└─────────────┘
·· findings ··▶
Semantic · Taint · Diffing · FmtStr · Heap · MultiArch · Driver
┌──────────────────┐ ┌──────────────────┐
│ Corpus Builder │─▶│ Semantic Search │
│ embedding DB │ │ BERT · < 1 sec │
└──────────────────┘ └──────────────────┘
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Taint Engine │ │ Diffing │ │ Format String │
│ data flow │ │ DTW · delta │ │ specifiers │
└──────────────────┘ └──────────────────┘ └──────────────────┘
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Heap Scanner │ │ Multi-Arch │ │ Driver Engine │
│ chunk · UAF │ │ MIPS·PPC·RV·LA │ │ IOCTL · BYOVD │
└──────────────────┘ └──────────────────┘ └──────────────────┘
│
·· findings ··▶ Claude
cross-target corpus · seeds future sweeps
Claude ──▶ ╔══════════════════════════════╗
║ Finding Registry ║
╠══════════════════════════════╣
║ cross-target corpus ║
╚══════════════════════════════╝
│
seeds future sweeps
│
▼
Semantic Search
Every confirmed finding enters the registry and seeds semantic search embeddings for every subsequent target.
Stripped binaries from an RPM bundle, analyzed end-to-end. BinaryContext loads each one, string xrefs find the target functions, and capstone disassembles to confirmed findings.
third-party bundle · x86-64
┌──────────────────────────────┐
│ target-package.rpm │
│ third-party bundle x86-64 │
└──────────────────────────────┘
│
rpm2cpio / cpio
▼
platform/linux-x86_64/
inference_engine · controller · libcore.so · libruntime.so
platform/linux-x86_64/
├── bin/inference_engine stripped PIE · x86-64
├── bin/controller stripped PIE · x86-64
├── lib/libcore.so
└── lib/libruntime.so
│
┌──────────┼──────────┐
▼ ▼ ▼
┌──────────┐ ┌────────┐ ┌──────────┐
│inference │ │ libs │ │ ctrl │
└──────────┘ └────────┘ └──────────┘
BinaryContext · string xrefs · disasm
BinaryContext.load_or_build()
32 func starts · 551 strings · PLT built
│
▼
ctx.strings scan
├── api_op_read VA 0x51560
├── api_op_write VA 0x51570
└── license_key_flag VA 0x52e08
│
▼
ctx.string_xrefs()
├── both ops xref → 0x17499, 0x174af
└── ctx.func_containing() → init fn 0x10000
│
▼
capstone disasm 0x17450
├── lea rsi → api_op_read · call set::insert
└── lea rsi → api_op_write · call set::insert
CONFIRMED: exactly 2 blocklist entries
│
▼
capstone disasm 0x16511
├── cmp qword ptr [r9], 0
├── je → model loads
└── ne → handleFatal
empty set = bypass confirmed ──▶ F1
nm · disasm · op scan
nm -D libcore.so
├── spawn 0xfdb20
└── ctor 0xfcfd0
│
▼
capstone disasm libcore.so:0xfdbc7
├── cmp entry length == exe_path length
└── memcmp at 0xfdbdb
proper equality check · no prefix bypass ──▶ F2
re.findall api_op:: in libruntime.so
├── 2481 distinct ops found
└── 2 blocked · 2479 unblocked ──▶ F1
BinaryContext · spawn path · arg validation
BinaryContext.load_or_build()
18 func starts · PLT · strings
│
▼
ctx.string_xrefs() on 5 path strings
├── ./worker1 ./worker2 ./worker3
├── ./worker4 ./inference_engine
└── all xref at 0x9a04-0x9a5e
│
▼
capstone disasm 0x99e9
├── call CApp::progDir()
└── call OsUtils::chdir()
chdir to binary dir before spawn
│
▼
capstone disasm 0x11500
├── args vector from command pipe tokens
└── passed raw to spawn() at 0x11699
no validation ──▶ F2
F1 HIGH · F2 LOW · F3 INFO
┌─────────────────────────────────────────────────────┐
│ F1 · HIGH │
│ blocklist covers 2 of 2481 ops │
│ upload malicious model via API │
│ seccomp BPF not decoded — CIA open │
└─────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────┐
│ F2 · LOW │
│ controller spawn allowlist is sound │
│ but args vector unchecked │
│ requires service user pipe access │
└─────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────┐
│ F3 · INFO │
│ license gate = JSON field only │
│ no cryptographic verification │
└─────────────────────────────────────────────────────┘
ELF · PE · Firmware · .mpy · APK/DEX · BEAM/Erlang
┌───────┐ ┌───────────┐ ┌──────────┐ ┌───────┐ ┌─────────┐ ┌─────────────┐
│ ELF │ │ PE/Driver │ │ Firmware │ │ .mpy │ │ APK/DEX │ │ BEAM/Erlang │
└───────┘ └───────────┘ └──────────┘ └───────┘ └─────────┘ └─────────────┘
│
load
▼
Ablation loads native binaries, compiled bytecode, and firmware images. Each goes through the same loader before analysis begins.
PLT · Strings · XRef · Call Graph · CFG
╔══════════════════════════════╗
║ BinaryContext ║
╠══════════════════════════════╣
║ PLT · XRef · Call Graph ║
║ Strings · CFG · Funcs ║
╚══════════════════════════════╝
│
┌─────────────────┼─────────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Taint Engine │ │ Analysis │ │ Scanners │
└──────────────┘ └──────────────┘ └──────────────┘
Every analyzer receives a BinaryContext. It resolves PLT stubs, indexes strings with cross-references, maps function boundaries, and builds the call graph on demand rather than up front.
16 ISAs
╔═══════════════════════════════════════════════════╗
║ Taint Engine ║
╠═══════════════╦═══════════════╦═══════════════════╣
║ x86-32 ║ ARM32 ║ PPC32 ║
║ x86-64 ║ ARM64 ║ PPC64 ║
╠═══════════════╬═══════════════╬═══════════════════╣
║ MIPS32 ║ nanoMIPS ║ RISC-V 32/64 ║
╠═══════════════╬═══════════════╬═══════════════════╣
║ ARC EM/HS ║ Loong
8BD0
Arch64 ║ TriCore · RH850 ║
║ V850 ║ ║ ║
╚═══════════════╩═══════════════╩═══════════════════╝
│
▼
[ FORGE ]
The taint engine follows network input through the call graph to security-sensitive sinks. Library call sites do not stop the trace because register-level tracking resolves shared library stubs.
Semantic Search · Version Diffing · Hypothesis Engine · Vtable Recon
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Semantic Search │ │ Version Diffing │ │Hypothesis Engine│
│ BERT · <1s │ │ logic · not file│ │evidence scoring │
└─────────────────┘ └─────────────────┘ └─────────────────┘
┌─────────────────┐ ┌─────────────────────────────────────┐
│ Vtable Recon │ │ Cross-Target Learning │
│ stripped C++ ELF│ │ confirmed findings seed all sweeps │
└─────────────────┘ └─────────────────────────────────────┘
│
▼
[ FORGE ]
| Module | |
|---|---|
| Semantic Search | Takes a plain-language description and returns matching functions. Queries scope to the target binary, so results land in under a second. |
| Version Diffing | Checks whether logic changed, not whether the file changed. A cosmetic recompile cannot hide an unpatched vulnerability. |
| Hypothesis Engine | Runs multiple working hypotheses about a function simultaneously and scores incoming evidence against each. Analysis state persists across sessions. |
| Vtable Recon | Recovers C++ virtual dispatch tables from stripped ELF. A generated annotation script propagates slot names through every call site. |
| Cross-Target Learning | Every confirmed finding seeds semantic searches on every future target. |
Pre-Auth · Crypto · Heap · Format String · BYOVD · MpyLifter
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Pre-Auth │ │ Crypto │ │ Heap │
│ Exposure │ │ Analysis │ │ Scanner │
└──────────────┘ └──────────────┘ └──────────────┘
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│Format String │ │BYOVD / Kernel│ │ MpyLifter │
│ Scanner │ │driver audit │ │ .mpy v6 · RE │
└──────────────┘ └──────────────┘ └──────────────┘
│
▼
[ FORGE ]
| Scanner | |
|---|---|
| Pre-Auth Exposure | Maps every path from the network entry point to a sensitive operation that runs before authentication. |
| Crypto Analysis | Recovers key material from compiled firmware and audits TLS and JWT configurations. |
| Heap Scanner | Audits heap allocations for chunk corruption and use-after-free across all supported architectures. |
| Format String | Finds format string sinks reachable from tainted input. |
| BYOVD / Kernel | Classifies signed kernel drivers for BYOVD capability before deployment. |
| MpyLifter | Lifts .mpy v6 bytecode to pseudo-Python. Detects dangerous imports, exec/eval, and machine.mem32 across ESP32, STM32, and CC13xx firmware. |
→ Finding Registry
Taint Engine ──┐
Analysis ──┼──▶ ╔═══════════════════╗ ╔═══════════════════╗
Scanners ──┘ ║ FORGE Quality ║────▶║ Finding Registry ║
║ Gate ║ ╠═══════════════════╣
╚═══════════════════╝ ║ cross-target ║
╚═════════╤═════════╝
│
seeds future sweeps
│
▼
Semantic Search
Every module passes a 10-section audit before storage. Confirmed findings enter the Finding Registry and seed semantic searches on every future target.
→ FORGE
pip install git+https://github.com/Ablation-Tool/ablation- Python >= 3.10
capstone,numpy,lief,sentence-transformers,pyelftools
Ablation is built for authorized security research. Use it only against systems you own or have explicit written permission to test. Running it against systems without authorization violates computer fraud laws in most jurisdictions. The author is not responsible for misuse.