Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    BinaryRE Agentic Suite

    1

    A multi-phase binary reverse engineering suite for triage, static analysis, and dynamic debugging of ELF executables.

    $19

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    BinaryRE Agentic Suite

    Example session with this skill installed

    Triage this binary located at ./samples/iot_daemon and identify its architecture, dependencies, and potential network capabilities.

    • Read your context and instructions
    • Compiled the binaryre agentic suite

    I have analyzed the binary ./samples/iot_daemon using rabin2 and readelf. The artifact is an ARM 32-bit ELF executable.

    Triage Report: iot_daemon

    PropertyValue
    ArchitectureARM (32-bit, Little Endian)
    ABIEABI5 (hard-float)
    Libcglibc (Interpreter: /lib/ld-linux-armhf.so.3)
    StrippedNo (symbols present)
    StaticNo (dynamically linked)

    Library Dependencies

    • libcurl.so.4 (HTTP/HTTPS client capabilities)
    • libpthread.so.0 (Multi-threading support)
    • libc.so.6 (Standard C library)

    Capability Assessment

    Network Client: High confidence. Imports socket, connect, and send. libcurl presence suggests high-level protocol usage.

    • File I/O: High confidence. Imports openat, read, and write.
    • System Commands: Medium confidence. Imports system, suggesting it may spawn shell commands.

    Strings of Interest

    • http://api.internal-update.local/v1/heartbeat
    • /etc/config/device_secret
    • ERROR: Failed to initialize sensor bus

    Next steps

    1. Perform Static Analysis on the main and network_init functions to map the heartbeat logic.
    2. Setup Dynamic Analysis using qemu-arm to trace the actual URLs being hit during startup.
    3. Verify if the device_secret file is read during the authentication flow.

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

    About this skill

    Reversing unknown binaries is a slow, manual process prone to rabbit holes. This skill package provides a structured, multi-phase methodology to analyze ELF files, executables, and firmware images using industry-standard tooling like radare2, Ghidra, and QEMU. It automates the boilerplate of binary investigation, from initial fingerprinting to runtime behavior observation.

    What it does

    • Binary Triage fingerprints unknown files to identify architecture (ARM, x86, MIPS), ABI, and dependencies.
    • Static Analysis maps functions, traces cross-references, and decompiles code using radare2 and Ghidra scripts.
    • Dynamic Analysis observes runtime behavior via QEMU emulation, GDB debugging, and syscall tracing.
    • Capability Mapping identifies specific features like network servers, file I/O, or cryptographic functions based on import patterns.
    • Automated Synthesis correlates facts across phases to generate structured reports and validate behavioral hypotheses.

    How it works

    1. Triage Phase uses rabin2 to establish baseline facts like bit width, endianness, and linked libraries.
    2. Analysis Phase executes targeted disassembly or decompilation of specific functions to map logic.
    3. Execution Phase runs the binary in a controlled QEMU or Docker sandbox to trace syscalls and verify hypotheses.
    4. Synthesis Phase compiles findings into a standardized markdown report for archival or handoff.

    Frameworks & tools

    The skill requires radare2 and qemu-user. It supports Ghidra (via r2ghidra), gdb-multiarch, and binutils. Targets include ARM64, ARMv7, x86_64, MIPS, and Python bytecode.

    Why this beats prompting it yourself

    Writing reliable scripts for r2 or setting up cross-arch qemu environments is error-prone. This skill manages the complex command flags, handles environment isolation, and ensures analysis remains hypothesis-driven rather than aimless.

    Use cases

    • Analyzing suspect firmware for hidden network calls or backdoors.
    • Reversing Linux malware to understand its command-and-control behavior.
    • Debugging proprietary ARM binaries without access to original source code.
    • Auditing third-party libraries for specific cryptographic or file-system interactions.

    Known limitations

    Dynamic analysis requires human approval before execution for safety. Decompilation quality depends on the availability of r2ghidra or Ghidra headless. Stripped binaries reduce function name accuracy.

    Requires local installation of radare2 and QEMU. Dynamic analysis requires explicit human approval for sandbox execution. Stripped binaries limit static analysis depth.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    Requires

    Blah
    Python
    macOS
    Git

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files

    Allowed Hosts

    gef.blah.cat
    Listed13 days ago
    Updated2 days ago

    What's inside

    Frequently Asked Questions

    The skill supports common architectures including x86_64, ARM64, ARMv7, and MIPS, as well as Python bytecode. It is designed specifically for ELF executables and Linux-based firmware images.

    This skill leverages local installations of radare2 and QEMU-user to perform heavy lifting. You will need these tools installed on your host system or accessible within your agent's execution environment to enable the full static and dynamic analysis suite.

    Safety is a priority; the skill includes a mandatory "human-in-the-loop" approval step before any dynamic analysis or QEMU emulation begins. This prevents the AI agent from executing potentially malicious code without your explicit consent.

    The package includes the full multi-phase logic for triage, static mapping, and dynamic debugging, along with standardized reporting templates. You receive the integrated skill set and documentation on configuring the environment for cross-architecture analysis.

    While the skill can still map logic and trace syscalls in stripped binaries, function name accuracy will be reduced. It uses cross-referencing and import pattern analysis to help rebuild the context that was lost when symbols were removed.

    New in APIs & Backend