Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    dogbolt binary decompiler

    1

    Decompile and analyze small binaries using 13 multi-engine decompilers like Ghidra and Hex-Rays.

    Free

    Security scanned
    dogbolt binary decompiler

    dogbolt binary decompiler

    Example session with this skill installed

    Decompile the local 'crackme' ELF binary using Ghidra and explain the logic in the check_password function.

    • Read your context and instructions
    • Compiled the dogbolt binary decompiler

    I have analyzed the crackme binary using the Ghidra decompiler. The file size is 1.2MB, which is within the operational limits. The analysis focused on the check_password function to understand its validation logic.

    Binary Analysis: crackme (Ghidra)

    FunctionAddressLogic TypeBehavior Summary
    main0x004011d0Entry PointCollects user input via fgets and passes it to check_password.
    check_password0x00401120ValidationPerforms a byte-wise XOR against a hardcoded key.
    print_flag0x00401250UtilityDecrypts and prints a success message if the check passes.
    /* Decompiled check_password function using Ghidra */
    bool check_password(char *input) {
      size_t input_len;
      int i;
      char hardcoded_key[8] = {0x6b, 0x61, 0x64, 0x6f, 0x68, 0x61, 0x63, 0x6b};
      
      input_len = strlen(input);
      if (input_len != 8) {
        return false;
      }
      
      for (i = 0; i < 8; i++) {
        /* XOR comparison logic detected */
        if ((input[i] ^ 0x2A) != hardcoded_key[i]) {
          return false;
        }
      }
      return true;
    }
    

    Behavioral Summary
    The binary implements a simple XOR-based password check. It expects an 8-character input. Each character is XORed with the constant 0x2A (42) and compared against the byte array kadohack. To pass this check, the input must be the result of hardcoded_key[i] ^ 0x2A.

    Next steps

    1. Run a comparison against hex-rays to verify the XOR constant detection.
    2. Generate a Python script to calculate the valid input string based on the XOR key.
    3. Inspect the print_flag function to see how the final payload is stored.

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

    About this skill

    Reverse-engineering binaries manually is a slow, error-prone process that requires switching between heavy, expensive desktop environments. This skill enables an AI agent to analyze executables and recover C source code using 13 industry-standard decompiler engines via the Dogbolt MCP server.

    What it does

    • Multi-Engine Decompilation recovers source code using Ghidra, Hex-Rays, Binary Ninja, Angr, and others.
    • Cross-Engine Comparison identifies discrepancies between decompiler outputs to resolve obfuscation or logic errors.
    • Symbol Analysis traces entry points, exported symbols, and function calls within ELF, PE, and Mach-O files.
    • Behavior Mapping identifies string references and system calls to explain high-level binary logic.

    How it works

    1. The agent verifies the local binary file size and architecture.
    2. The decompile_binary command uploads the file to the Dogbolt service.
    3. The agent selects a target engine like ghidra for general analysis or hex-rays for readability.
    4. The agent parses the returned C code to explain specific routines like crypto logic or main loops.

    Frameworks & tools

    This skill utilizes the Dogbolt MCP server for cloud-based decompilation and supports Ghidra, Hex-Rays/IDA, Binary Ninja, and Angr.

    Why this beats prompting it yourself

    Writing prompts to analyze assembly is unreliable. This skill provides structured access to the actual output of professional reverse-engineering tools, ensuring the agent works with real C code rather than hallucinated logic.

    Use cases

    • Auditing untrusted ELF binaries for malicious system calls.
    • Recovering lost source code from legacy Windows .exe files.
    • Comparing how different engines handle obfuscated ARM firmware routines.
    • Mapping data structures and crypto functions in Mach-O executables.

    Known limitations

    Supports binaries under 2MB only. Uses a public decompilation service, so it is not suitable for files containing sensitive proprietary secrets or private keys.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Security.

    Only supports binaries under 2MB. Dogbolt is a public service; do not use for confidential or proprietary code.

    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 12 days ago

    • Free with an Agensi account

    Accounts
    Dogbolt
    Software
    Python@modelcontextprotocol/inspectorNode.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Allowed Hosts

    dogbolt.org
    Listed12 days ago

    What's inside

    Frequently Asked Questions

    This skill supports 13 industry-standard engines, including Ghidra, Hex-Rays (IDA), Binary Ninja, Angr, Procyon, and REC, allowing for comprehensive cross-engine comparison.

    The skill works with ELF, PE (.exe), and Mach-O files, as well as various firmware formats, provided the file size is under 2MB.

    This skill is compatible with any AI agent that supports the Model Context Protocol (MCP), such as Claude Desktop or various developer-focused IDE extensions.

    The skill uses the public Dogbolt service for processing; therefore, it is intended for auditing untrusted or legacy binaries rather than sensitive, proprietary internal secrets.

    By providing real C code from professional engines, the agent avoids 'guessing' logic from raw bytes, leading to significantly higher accuracy in identifying crypto routines or system calls.

    The purchase includes the configured MCP skill package and documentation for connecting your agent to the Dogbolt server via the provided tools.

    New in Security

    Free