Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Enigma Reverse Eng

    1

    Evidence-driven reverse-engineering workflows for the Enigma Engine CLI, Qt GUI, and C++ APIs, with verified commands, output formats, and explicit limitations.

    Free

    1 useSecurity scanned
    Enigma Reverse Eng

    Enigma Reverse Eng

    Example session with this skill installed

    Use the Enigma toolchain to triage 'utility.exe', dump its functions to a CSV, and decompile the function at 0x140001514.

    • Read your context and instructions
    • Compiled the enigma reverse eng
    • Generated the data export

    I have performed a triage and initial analysis of utility.exe using the Enigma Engine toolchain.

    Analysis Summary

    The triage identified a 64-bit PE binary. I have successfully mapped the function inventory and generated pseudocode for the requested entry point.

    Binary Triage (enigma_binary_audit)

    MetricValue
    FormatPE32+ (64-bit)
    Architecturex86_64:LE
    Image Base0x140000000
    Sections5 (.text, .rdata, .data, .pdata, .reloc)
    Imports42 symbols from 3 DLLs

    Function Inventory (Top 5)

    address,type,name
    0x140001000,named,init_runtime
    0x140001240,entry,entry
    0x140001514,named,main
    0x140001890,thunk,GetSystemTimeAsFileTime
    0x140002100,discovery,func_0x140002100
    

    Decompiled Pseudocode (0x140001514)

    // Address: 0x140001514
    // Decompiled using Enigma Engine enigma_decompile_full
    longlong main(int param_1, char **param_2) {
        void *pvVar1;
        longlong lVar2;
        
        pvVar1 = (void *)lookup_config_string("target_path");
        if (pvVar1 == (void *)0x0) {
            log_error("Missing configuration");
            lVar2 = 1;
        } else {
            lVar2 = process_payload(pvVar1);
        }
        return lVar2;
    }
    

    Next steps

    Explore XRefs: Open the Qt GUI and use Navigate > Show References on 0x140001514 to find where the config string is used.

    Deep Dive: Run enigma_dump_listing utility.exe unused.csv 0x140001514 to verify the branch logic against raw assembly.

    • Audit Imports: Use enigma_pipeline_audit to see the full list of imported Windows APIs for capability mapping.

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

    Analyzing opaque binaries without a structured workflow leads to missed cross-references and unreliable decompilation. This skill provides a rigorous, evidence-based reverse-engineering methodology using the Enigma Engine toolchain.

    What it does

    • Binary Triage identifies file headers, architectures, entry points, and section counts for PE, ELF, Mach-O, and COFF formats.
    • Function Mapping generates CSV inventories of function addresses and types, including support for Ghidra-compatible naming.
    • Decompilation & Disassembly extracts C-like pseudocode and instruction listings for specific memory addresses or entry points.
    • Project Inspection reads Ghidra .gzf and .rep projects natively to inspect tables and reconstruct program models.
    • Byte Patching applies hex modifications to binary copies with integrated verification of the exported output.
    • Fingerprint Comparison analyzes and compares function signatures between two different builds to track changes.

    How it works

    1. Audit the target using enigma_binary_audit to confirm the architecture, image base, and symbol counts.
    2. Inventory functions with enigma_dump_functions to create a map of named and auto-discovered entry points.
    3. Analyze flow by disassembling specific addresses with enigma_dump_listing before running full decompilation.
    4. Verify evidence by separating diagnostics from machine-readable output and documenting observed versus inferred facts.

    Frameworks & tools

    Native C++17 Enigma Engine framework, SLEIGH specifications, Qt GUI for interactive analysis, and CLI tools for batch processing.

    Why this beats prompting it yourself

    Generic prompts often hallucinate CLI flags or assume standard Ghidra behavior that does not apply to the Enigma toolchain. This skill uses verified command signatures and explicit workflows for handling stderr logs, image base offsets, and SLEIGH directory requirements.

    Use cases

    • Triage unknown malware samples to identify entry points and imported APIs.
    • Document legacy binary behavior when source code is lost or unavailable.
    • Compare two versions of a firmware blob to find patched vulnerabilities.
    • Import existing Ghidra projects for headless analysis or C++ API integration.

    Known limitations

    No CLI for cross-references or control-flow graphs; these require the Qt GUI or C++ API. Decompiler output is pseudocode, not recovered source. Requires local SLEIGH files.

    No CLI for xrefs or CFGs (GUI/API only). Pseudocode is inferred, not original source. Requires manual SLEIGH path configuration. No Python bindings or stable plugin ABI.

    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 any payment.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables
    Browser
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    This skill integrates directly with the Enigma Engine's native C++17 framework and SLEIGH specifications, preventing the hallucinated command flags and workflow errors common when using general-purpose LLMs for reverse engineering.

    The skill supports a wide range of binary formats including PE, ELF, Mach-O, and COFF, and it can natively read Ghidra .gzf and .rep projects for seamless analysis.

    While the skill provides powerful CLI-based triage, decompilation, and patching, advanced features like control-flow graphs and complex cross-references require the Enigma Engine Qt GUI or C++ API.

    You will receive the AI agent skill configuration, a suite of verified command signatures for the Enigma Engine, and a structured methodology for evidence-based binary auditing.

    Yes, the skill includes a specific 'enigma_compare_signatures' workflow designed to identify changes, patches, or version drifts between two different builds of the same binary.

    Users must have the Enigma Engine toolchain installed locally, along with the necessary SLEIGH specification files for the architectures they intend to analyze.

    New in Agents & Orchestration