Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Decompile And Verify

    1

    Decompile compiled software with an AI agent and prove every recovered function against the original, plus an assessment skill that measures how recoverable a build is.

    Free

    Security scanned
    decompile-and-verify

    decompile-and-verify

    Example session with this skill installed

    I have a stripped Linux binary 'auth_tool'. I need to recover the function at 0x4012a0 and prove the C code is correct. Use emulation for verification.

    • Read your context and instructions
    • Compiled the decompile-and-verify
    • Generated the data export

    I have completed the triage and verification for the requested function. The binary was identified as an x86-64 ELF (stripped). The function at 0x4012a0 has been recovered and verified as equivalent using differential emulation.

    Decompilation and Verification Result

    Target: auth_tool (sha256: 4f3a...b912)
    Function: FUN_004012a0
    Oracle: verify_emulated.py (Differential Emulation)
    Status: equivalent-tested

    // Verified candidate: attempt_2.c
    // Logic: FNV-1a hash comparison for license key validation
    #include <stdint.h>
    
    uint32_t FUN_004012a0(const uint8_t *input, uint32_t len) {
        uint32_t hash = 0x811c9dc5;
        for (uint32_t i = 0; i < len; i++) {
            hash ^= input[i];
            hash *= 0x01000193;
        }
        return (hash % 97 == 42);
    }
    

    Verification Evidence

    MetricValue
    Attempts2
    Total Time145s
    Inputs Tested256 (random, boundaries, null)
    VerdictMATCH (CANDIDATE_OUT == ORIGINAL_OUT)

    Next steps

    1. Check callers of 0x4012a0 to confirm the input buffer source.
    2. Run ledger.py add to commit this verification to work/ledger.csv.
    3. Use rank_functions.py to identify the next highest-priority function for recovery.

    ledger.csv

    CSV · data export

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Trusting a decompiler at face value leads to broken ports and incorrect audits. This skill package automates the decompilation of native and bytecode binaries while using mathematical and empirical oracles to prove the recovered source matches the original logic.

    What it does

    • Automated Decompilation: Extracts readable source from ELF, PE, Mach-O, .NET, Java, APK, Python bytecode, and WebAssembly targets.
    • Verification Oracles: Proves function accuracy using machine-code matching, differential emulation, or trace-replay tests.
    • Triage and Analysis: Identifies file formats, entry points, embedded secrets, and packer signatures automatically.
    • Progress Ledger: Tracks every recovery attempt, verification status, and time-on-task with cryptographic pinning to the binary.
    • Exposure Assessment: Measures a build's resistance to reverse engineering and generates reports mapped to OWASP MASVS-RESILIENCE.

    How it works

    1. Triage: Run triage.py to pin the binary's SHA256 and identify the target architecture.
    2. Export: Use Ghidra or language-specific routes to dump initial decompiled drafts and function lists.
    3. Verify: Select an oracle (e.g., verify_emulated.py or verify_match.py) to test recovered source against original execution.
    4. Iterate: Refine code attempts based on oracle failures until the logic is equivalent.
    5. Report: Generate a final exposure report or verified source ledger for the audit or port.

    Frameworks & tools

    This skill requires Python 3.9+, Ghidra with JDK 21+, and the Unicorn emulation engine. It supports native compilers like GCC and Clang for matching oracles and standard bytecode tools for managed targets.

    Why this beats prompting it yourself

    Generic LLM prompts often hallucinate logic or ignore compiler optimizations that change program flow. This skill forces the agent to verify every claim against the ground truth of the binary, ensuring recovered source actually runs the same way as the original code.

    Use cases

    • Recovering lost source code from legacy binaries or retro ROMs.
    • Auditing third-party libraries for hidden backdoors or embedded credentials.
    • Porting compiled logic from one architecture or language to another with high confidence.
    • Benchmarking software hardening and obfuscation techniques against automated recovery.

    Known limitations

    Static assessment cannot measure runtime anti-tampering or dynamic analysis protections. Large, heavily optimized modern builds may require manual toolchain identification for matching oracles to succeed.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Static analysis only. Does not measure dynamic anti-tampering. Requires Ghidra for native targets. Emulated oracles limited to x86 and x86-64.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed today

    • Free with an Agensi account

    Windows only

    Accounts
    GitHub
    Software
    PythonNode.jsrea-agents@electron/asarGit

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables

    Allowed Hosts

    raw.githubusercontent.com
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill automates the decompilation process while using mathematical oracles and differential emulation to prove the recovered source is logically identical to the original binary, preventing the hallucinations common in manual LLM decompilation.

    The package supports a wide range of formats including ELF, PE, Mach-O, .NET, Java, APK, Python bytecode, and WebAssembly, covering both native and managed targets.

    You will receive the core Python automation scripts, integration modules for Ghidra and Unicorn, verification oracles (matching and emulation), and the cryptographic progress ledger system.

    You will need a local environment running Python 3.9+, Ghidra with JDK 21+, and the Unicorn emulation engine to execute the verification and matching tasks.

    While the skill automates the heavy lifting, heavily optimized or obfuscated binaries may require you to manually specify the original compiler toolchain to achieve a perfect match in the verification phase.

    This skill is designed for use with advanced AI agents capable of executing local Python scripts and interacting with filesystem tools to perform iterative analysis.

    New in Code Quality & Review

    Free