⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
binary-re:static-analysis
Performs static analysis of binary code using radare2 and Ghidra — function enumeration, cross-reference tracing, decompilation, and control flow graphs without executing the binary. Use when disassembling or decompiling code, mapping functions, tracing data flow, or building hypotheses before dynamic verification.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
Binary Reverse Engineering Plugin
You pulled a binary off an embedded device. It's an ELF, probably ARM, and you need to figure out what it does. Binary RE gives Claude the tools to help — radare2 for disassembly, Ghidra for decompilation, GDB for dynamic analysis, QEMU for emulation — driven by hypothesis-testing, not blind exploration.
Installation
/plugin marketplace add 2389-research/claude-plugins
/plugin install binary-re@2389-research
What this plugin provides
Skills
binary-re-- structured RE workflow with hypothesis-driven analysis
Sub-skills
| Name | Description |
|---|---|
binary-re:triage | Fast binary fingerprinting — architecture, ABI, dependencies, and strings via rabin2. Use first on any unknown binary. |
binary-re:static-analysis | Deep code analysis via radare2 and Ghidra — functions, cross-references, decompilation, and CFGs without execution. |
binary-re:dynamic-analysis | Runtime behavior observation via QEMU, GDB, and Frida — syscall tracing, breakpoints, and memory inspection; requires human approval. |
binary-re:synthesis | Compiles analysis findings into structured reports with validated hypotheses and evidence chains. |
binary-re:tool-setup | Installs and configures radare2, Ghidra, GDB, QEMU, Frida, and cross-compilation toolchains. |
Capabilities
- Cross-architecture static analysis (ARM64, ARMv7, x86_64, MIPS)
- Dynamic tracing via QEMU user-mode emulation
- GDB integration for debugging
- Ghidra headless decompilation
- Human-in-the-loop gates for risky operations
Quick example
User: "Analyze this binary from an IoT device - ARM, Linux-based"
Claude: [Triggers binary-re skill]
Let me start with triage to understand what we're working with.
Phase 1: Initial Triage
┌─────────────────────────────────────────┐
│ Architecture: ARM 32-bit LE (v7) │
│ Libc: musl 1.2.3 │
│ Dependencies: libcurl, libssl, libz │
│ Stripped: Yes │
│ Strings: 847 (including URLs, paths) │
└─────────────────────────────────────────┘
FACTS recorded:
- Links against libcurl.so.4 (network client)
- Contains string "api.vendor.com/telemetry"
- Imports socket, connect, SSL_read functions
HYPOTHESIS: This is a telemetry client that phones home over HTTPS
Confidence: 0.7
Evidence: curl+ssl imports, telemetry URL string
Do you want me to proceed with static analysis of network-related
functions, or should we try dynamic analysis under QEMU first?
Tool requirements
# Required
sudo apt install radare2 qemu-user gdb-multiarch
# Recommended
# Ghidra from https://ghidra-sre.org/
pip install frida-tools
# ARM sysroots
sudo apt install libc6-armhf-cross libc6-arm64-cross
Use cases
- Firmware analysis -- understand device behavior without source
- Protocol reverse engineering -- map network communications
- Security research -- find vulnerabilities in embedded systems
- Hardware hacking -- analyze robot/IoT device internals
Philosophy
The LLM drives analysis; the human provides context.
You tell Claude what platform/device the binary came from, what hardware is involved, what the binary is theorized to do, and any constraints (no network, isolated test env, etc).
Claude runs the tools, forms hypotheses from evidence, designs experiments to test theories, and synthesizes findings into something actionable.
Human-in-the-loop
The skill asks for confirmation before:
- Executing binaries (even sandboxed)
- Network-capable dynamic analysis
- Operations requiring device access
- Major changes in analysis direction
Documentation
- CLAUDE.md -- detailed skill reference
- skills/binary-re/SKILL.md -- full workflow documentation
If Binary RE helped you crack a firmware blob, a ⭐ helps us know it's landing.
Built by 2389 · Part of the Claude Code plugin marketplace
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/static-analysis/SKILL.md8.7 KBbcd52c1870c1upstream ↗
--- name: binary-re:static-analysis description: "Performs static analysis of binary code using radare2 and Ghidra — function enumeration, cross-reference tracing, decompilation, and control flow graphs without executing the binary. Use when disassembling or decompiling code, mapping functions, tracing data flow, or building hypotheses before dynamic verification." --- # Static Analysis (Phases 2-3) ## Purpose Understand binary structure and logic without execution. Map functions, trace data flow, decompile critical code. ## When to Use - After triage has established architecture and ABI - To understand specific functions identified as interesting - When dynamic analysis is impractical or risky - To build hypotheses before dynamic verification ## Two-Stage Approach **Stage 1 (Light):** Function enumeration, strings, imports - fast, broad coverage **Stage 2 (Deep):** Targeted decompilation, CFG analysis - slow, focused ## Stage 1: Light Analysis (radare2) ### Analysis Depth Selection | Binary Size | Command | Tradeoff | |-------------|---------|----------| | < 500KB | `aaa` | Full analysis, may be slow | | 500KB - 5MB | `aa; aac` | Functions + all call targets | | > 5MB | `aa` + targeted `af @addr` | Fast, manual depth control | ### Session Setup ```bash # Launch r2 with controlled analysis r2 -q0 -e scr.color=false -e anal.timeout=120 -e anal.maxsize=67108864 binary # Inside r2 (choose based on binary size): aa # Basic analysis aac # Also analyze all call targets (recommended for most binaries) ``` **Critical settings:** - `anal.timeout=120` - Prevent runaway analysis - `anal.maxsize=67108864` - 64MB max function size - Use `aa; aac` for medium binaries, `aaa` only for small ones ### Handling Unanalyzed Call Targets If `axtj` returns empty for known imports: ```bash # The import may be called indirectly or analysis was too shallow # Option 1: Deeper analysis aac # Analyze all calls # Option 2: Manually create function at call target af @0x8048abc # Option 3: Search for references to import address axtj @sym.imp.connect ``` ### Function Enumeration ```bash # All functions as JSON aflj # Filter by name pattern aflj~main aflj~init aflj~network aflj~send aflj~recv # Function count afl~? ``` ### Cross-Reference Analysis ```bash # Who calls this function? axtj @sym.imp.connect # What does this function call? axfj @sym.main # Data references to address axtj @0x12345 ``` ### String-Function Correlation ```bash # Find which function contains a string izj~api.vendor.com # Note the vaddr, then find containing function afi @0xVADDR # Or search and map "/j api" # Search for string axtj @@hit* # Xrefs to all hits ``` ### Import/Export Mapping ```bash # Imports with addresses iij # Exports with addresses iEj # Symbols (if not stripped) isj ``` ### Quick Disassembly ```bash # Disassemble function as JSON pdfj @sym.main # Disassemble N instructions from address pdj 20 @0x8400 # Print function summary afi @sym.main ``` ## Stage 2: Deep Analysis ### r2ghidra Availability Check **Before attempting decompilation, verify r2ghidra is installed:** ```bash # Check if r2ghidra is available r2 -qc 'pdg?' - 2>/dev/null | grep -q Usage && echo "r2ghidra OK" || echo "SKIP: r2ghidra not installed" # If missing, install with: r2pm -ci r2ghidra ``` **If r2ghidra unavailable:** Rely on disassembly (`pdf`) and cross-reference analysis (`axt/axf`). ### Targeted Decompilation (r2ghidra) ```bash # Decompile specific function pdgj @sym.target_function # Or named function pdgj @sym.main ``` ### Ghidra Headless (Large Binaries) For complex functions or when r2ghidra struggles: ```bash # Create analysis project and run script analyzeHeadless /tmp/ghidra_proj proj \ -import binary \ -overwrite \ -processor ARM:LE:32:v7 \ -postScript ExportDecompilation.java sym.target_function \ -deleteProject ``` **Processor strings:** - ARM 32-bit: `ARM:LE:32:v7` or `ARM:LE:32:Cortex` - ARM 64-bit: `AARCH64:LE:64:v8A` - x86_64: `x86:LE:64:default` - MIPS LE: `MIPS:LE:32:default` - MIPS BE: `MIPS:BE:32:default` ### Control Flow Analysis ```bash # Basic blocks in function afbj @sym.main # Function call graph (dot format) agCd @sym.main > callgraph.dot # Control flow graph agfd @sym.main > cfg.dot ``` ### Data Structure Recovery ```bash # Analyze local variables afvj @sym.main # Stack frame layout afvd @sym.main # Global data references adrj ``` ## Analysis Patterns ### Pattern: Network Function Tracing ```bash # Find all network-related calls axtj @sym.imp.socket axtj @sym.imp.connect axtj @sym.imp.send axtj @sym.imp.recv axtj @sym.imp.SSL_read axtj @sym.imp.SSL_write # Trace caller chain for func in $(aflj | jq -r '.[].name'); do axfj @$func | grep -q "socket\|connect" && echo $func done ``` ### Pattern: Configuration File Analysis ```bash # Find file operations axtj @sym.imp.open axtj @sym.imp.fopen # Trace string arguments "/j /etc" "/j .conf" "/j .json" # Check what functions reference these paths ``` ### Pattern: Crypto Identification ```bash # Common crypto imports axtj @sym.imp.EVP_EncryptInit axtj @sym.imp.AES_encrypt axtj @sym.imp.SHA256 # Hardcoded keys (check strings near crypto calls) izj | jq '.strings[] | select(.length == 16 or .length == 32)' ``` ## r2 JSON Commands Reference | Command | Output | Use Case | |---------|--------|----------| | `aflj` | Functions list | Map code structure | | `axtj @addr` | Xrefs TO address | Who uses this? | | `axfj @addr` | Xrefs FROM address | What does it call? | | `pdfj @addr` | Disassembly | Understand instructions | | `pdgj @addr` | Decompilation | Pseudo-C output | | `afbj @addr` | Basic blocks | Control flow | | `izj` | Data strings | Configuration, URLs | | `iij` | Imports | External dependencies | | `iEj` | Exports | Public interface | | `afvj @addr` | Local variables | Stack analysis | ## Output Format Record analysis findings as structured facts: ```json { "functions_analyzed": [ { "name": "sub_8400", "address": "0x8400", "size": 256, "calls": ["socket", "connect", "send"], "called_by": ["main", "init_network"], "strings_referenced": ["api.vendor.com"], "hypothesis": "network_initialization" } ], "call_graph": { "main": ["init_config", "init_network", "main_loop"], "init_network": ["sub_8400", "SSL_CTX_new"] }, "data_flow": [ { "source": "config_file_read", "through": ["parse_config", "extract_url"], "sink": "connect_to_server" } ] } ``` ## Knowledge Journaling After static analysis, record findings for episodic memory: ``` [BINARY-RE:static] {filename} (sha256: {hash}) Functions analyzed: {count} Decompilation performed: {yes|no} Key functions: FACT: Function at {addr} calls {imports} (source: r2 axfj) FACT: Function at {addr} references string "{string}" (source: r2 axtj) FACT: Function {name} appears to {purpose} (source: decompilation) Cross-references: FACT: {caller} calls {callee} (source: r2 axtj) HYPOTHESIS UPDATE: {refined theory} (confidence: {new_value}) Supporting: {fact_ids} Contradicting: {fact_ids} New questions: QUESTION: {discovered unknown} Answered questions: RESOLVED: {question} → {answer} ``` ### Example Journal Entry ``` [BINARY-RE:static] thermostat_daemon (sha256: a1b2c3d4...) Functions analyzed: 47 Decompilation performed: yes (function 0x8400) Key functions: FACT: Function 0x8400 calls curl_easy_perform, curl_easy_setopt (source: r2 axfj) FACT: Function 0x8400 references string "api.thermco.com/telemetry" (source: r2 axtj) FACT: Function 0x9200 parses JSON using jsmn library (source: decompilation) FACT: Function 0x10800 is main loop, calls 0x8400 after sleep(30) (source: r2 pdf) Cross-references: FACT: main calls init_config (0x9000) then main_loop (0x10800) (source: r2 axtj) FACT: main_loop calls send_telemetry (0x8400) in loop (source: r2 pdf) HYPOTHESIS UPDATE: Telemetry client sending to api.thermco.com every 30 seconds (confidence: 0.85) Supporting: URL string, curl imports, sleep(30) in loop Contradicting: none New questions: QUESTION: What data fields are included in telemetry payload? QUESTION: Is there any authentication/API key? Answered questions: RESOLVED: "What endpoint?" → api.thermco.com/telemetry via HTTPS ``` ## Decision Points After static analysis: 1. **Identified critical functions?** → Ready for dynamic verification 2. **Unclear behavior?** → Try dynamic analysis for runtime observation 3. **Crypto detected?** → Document key handling, note for security review 4. **Anti-analysis patterns?** → Consider Unicorn snippet emulation ## Next Steps → `binary-re:dynamic-analysis` to verify hypotheses with runtime observation → `binary-re:synthesis` if sufficient understanding reachedREADME.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/2389-research-binary-re-skills-static-analysis.md