8000 GitHub - JackBeerman/ablation: Ablation is an autonomous reverse engineering system. · GitHub
[go: up one dir, main page]

Skip to content
JackBeermanPublic
forked from ohio813/ablation

About

Ablation is an autonomous reverse engineering system.

Resources

Code of conduct

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

 
 

Repository files navigation

ABLATION

NIST SP 800-218 CISA Secure by Design MIL-HDBK-115C

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.


demo

Capabili 8000 ties

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.

Decompilers

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

Real-World Results

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

Acknowledgments

This project was greatly informed and inspired by several key literary works.

Research Papers

Title Authors
Reverse Compilation Techniques · Specifying the Semantics of Machine Instructions · UQBT: Adaptable Binary Translation at Low Cost · Machine-Adaptable Dynamic Binary Translation Dr. Cristina Cifuentes
Design of a Retargetable Decompiler for a Static Platform-Independent Malware Analysis Petr Zemek, Lukáš Ďurfina, Jakub Křoustek, Dušan Kolář, Tomas Hruska, Karel Masařík, Alexander Meduna
Finding Taint-Style Vulnerabilities in Linux-based Embedded Firmware with SSE-based Alias Analysis Cheng, Zheng, Liu, Guan, Liu, Li, Zhu, Ye, Sun
iResolveX: Multi-Layered Indirect Call Resolution via Static Reasoning and Learning-Augmented Refinement Monika Santra, Bokai Zhang, Mark Lim, Vishnu Asutosh Dasu, Dongrui Zeng, Gang Tan
Extracting Protocol Format as State Machine via Controlled Static Loop Analysis Qingkai Shi, Xiangzhe Xu, Xiangyu Zhang
NEMETYL: Message Type Identification of Binary Network Protocols using Continuous Segment Similarity Stephan Kleber, Rens Wouter van der Heijden, Frank Kargl
Imperfect Forward Secrecy: How Diffie-Hellman Fails in Practice David Adrian, Karthikeyan Bhargavan, Zakir Durumeric, Pierrick Gaudry, Matthew Green, J. Alex Halderman, Nadia Heninger, Drew Springall, Emmanuel Thomé, Luke Valenta
Nonce-Disrespecting Adversaries: Practical Forgery Attacks on GCM in TLS Hanno Böck, Aaron Zauner, Sean Devlin, Juraj Somorovsky, Philipp Jovanovic
Whitening Sentence Representations for Better Semantics and Faster Retrieval Jianlin Su, Jiarun Cao, Weijie Liu, Yangyiwen Ou
Constant Propagation with Conditional Branches Mark N. Wegman, F. Kenneth Zadeck
A Simple, Fast Dominance Algorithm Cooper, Harvey, Kennedy
libdft: Practical Dynamic Data Flow Tracking for Commodity Systems Vasileios P. Kemerlis, Georgios Portokalidis, Kangkook Jee, Angelos D. Keromytis

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.


Framework Architecture & Module Orchestration

Target Binary ELF · PE · firmware
  ┌────────┐     ┌───────────┐     ┌──────────┐
  │  ELF   │     │ PE/Driver │     │ firmware │
  └───┬────┘     └─────┬─────┘     └────┬─────┘
      └────────────────┴────────────────┘
                             │
                            load
                             ▼
BinaryContext PLT · Strings · Call Graph · XRefs
         ╔══════════════════════════════════════╗
         ║             BinaryContext            ║
         ╠══════════════════════════════════════╣
         ║  PLT  ·  Strings  ·  Call Graph      ║
         ║  XRefs  ·  CFG  ·  Func boundaries   ║
         ╚══════════════════════════════════════╝
                            │
                         context
                            ▼
Claude Code Central Orchestrator
         ╔══════════════════════════════════════╗
         ║       Claude Code (Orchestrator)     ║
         ╚══════════════════════════════════════╝
                            │
              ┌─────────────┼─────────────┐
              ▼             ▼             ▼
       ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
       │   Corpus  
8000
  │ │    Taint    │ │   FmtStr    │
       │  Semantic   │ │   Diffing   │ │    Heap     │
       └─────────────┘ └─────────────┘ │  MultiArch  │
                                       │   Driver    │
                                       └─────────────┘
                    ·· findings ··▶
Analysis Engines 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
Finding Registry 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.


Example RE Workflow

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.

target-package.rpm third-party bundle · x86-64
              ┌──────────────────────────────┐
              │      target-package.rpm      │
              │   third-party bundle x86-64  │
              └──────────────────────────────┘
                              │
                     rpm2cpio / cpio
                              ▼
                  platform/linux-x86_64/
Extracted Binaries 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   │
  └──────────┘ └────────┘ └──────────┘
Inference Engine Track 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
Library Analysis Track 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
Controller Track 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
Findings 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                       │
  └─────────────────────────────────────────────────────┘

Module Map

Input Formats 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.

BinaryContext 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.

Taint Engine 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.

→ Taint Analysis

Analysis Modules 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.
Security Scanners 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.
FORGE Quality Gate → 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


Install

pip install git+https://github.com/Ablation-Tool/ablation

Requirements

  • Python >= 3.10
  • capstone, numpy, lief, sentence-transformers, pyelftools

Responsible Use

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.

About

Ablation is an autonomous reverse engineering system.

Resources

Code of conduct

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages

You can’t perform that action at this time.
0