Skip to main content
skill CX Codex

binary-analysis — Claude Code skill: what it does, how to install

binary-analysis guides your coding agent in inspecting unknown binaries, running hex dumps, and extracting embedded artifacts.

MIT 146 installs ★ 60 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add laurigates/claude-plugins --skill binary-analysis -a claude-code
Open on GitHub

What binary-analysis does

This skill equips coding assistants with procedures for non-text inspection tools. It provides workflows around file, strings, hexdump, xxd, and binwalk to examine opaque blobs, firmware images, and compiled binaries. The agent learns when to calculate entropy graphs, extract nested file systems, or locate hardcoded endpoints in raw bytes.

While utilities like strings and xxd come standard on most Unix systems, recursive firmware unpacking requires installing binwalk via cargo or pip beforehand.

What it helps with

  • identify unknown file formats using magic bytes
  • extract ASCII and UTF-16 strings from binaries
  • inspect raw hex offsets of corrupted files
  • unpack nested archives from firmware dumps

Example prompts for the agent

  • Inspect mystery_file with file and show the first 32 bytes in hex
  • Extract printable strings from firmware.bin filtering for api_key
  • Run an entropy check on firmware.bin to find compressed sections

How to install binary-analysis

1Skills CLI (Vercel)

npx skills add laurigates/claude-plugins --skill binary-analysis -a claude-code

2Manually: put the files in place

~/.claude/skills/binary-analysis/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/binary-analysis/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about binary-analysis

How to install binary-analysis in Claude Code?

Run npx skills add laurigates/claude-plugins --skill binary-analysis -a claude-code in your terminal.

What does the binary-analysis skill do?

It guides your agent to parse binary headers, inspect offsets, and extract embedded strings with native Unix tools.

Does this skill require extra packages?

Standard utilities like file and strings are built into binutils, but binwalk must be installed separately via pip or cargo.

Source text

SKILL.md · MIT
---
name: binary-analysis
description: "Binary analysis: strings, binwalk, hexdump, xxd, file, objdump. Use when identifying unknown files, extracting strings, hunting credentials, or entropy analysis."
user-invocable: false
allowed-tools: Bash(file *), Bash(xxd *), Bash(hexdump *), Bash(strings *), Bash(objdump *), Bash(readelf *), Bash(nm *), Read, Grep, Glob
created: 2025-12-27
modified: 2026-05-09
reviewed: 2026-04-25
---

# Binary Analysis

Tools for exploring and reverse engineering binary files, firmware, and unknown data.

## When to Use This Skill

| Use this skill when... | Use rg-code-search instead when... |
|---|---|
| Identifying unknown or non-text file types (`file`, `xxd`) | Searching tracked source files for a regex |
| Extracting strings or symbols from compiled binaries / firmware | Auditing a repo's text-encoded files for hardcoded patterns |
| Inspecting raw hex layout of an ELF, Mach-O, or `.bin` blob | The input is human-readable code or markdown |

| Use this skill when... | Use jq-json-processing instead when... |
|---|---|
| Reverse-engineering an opaque binary format | The data is already structured JSON awaiting transformation |
| Hunting embedded files with `binwalk -e` | A field needs extraction from a parsed JSON payload |

## Quick Reference

| Tool | Purpose | Install |
|------|---------|---------|
| `strings` | Extract printable text from binaries | Built-in (binutils) |
| `binwalk` | Firmware analysis, file extraction | `pip install binwalk` or `cargo install binwalk` |
| `hexdump` | Hex/ASCII dump | Built-in |
| `xxd` | Hex dump with reverse capability | Built-in (vim) |
| `file` | Identify file type | Built-in |

## strings - Extract Text from Binaries

Find human-readable strings embedded in binary files.

```bash
# Basic usage - find all printable strings (min 4 chars)
strings binary_file

# Set minimum string length
strings -n 10 binary_file          # Only strings >= 10 chars

# Show file offset of each string
strings -t x binary_file           # Hex offset
strings -t d binary_file           # Decimal offset

# Search for specific patterns
strings binary_file | grep -i password
strings binary_file | grep -E 'https?://'
strings binary_file | grep -i api_key

# Wide character strings (UTF-16)
strings -e l binary_file           # Little-endian 16-bit
strings -e b binary_file           # Big-endian 16-bit
strings -e L binary_file           # Little-endian 32-bit

# Scan entire file (not just initialized data sections)
strings -a binary_file
```

**Common discoveries with strings:**
- Hardcoded credentials, API keys
- URLs and endpoints
- Error messages (hints at functionality)
- Library versions
- Debug symbols and function names
- Configuration paths

## binwalk - Firmware Analysis

Identify and extract embedded files, analyze entropy, find hidden data.

```bash
# Signature scan - identify embedded files/data
binwalk firmware.bin

# Extract all identified files
binwalk -e firmware.bin            # Extract to _firmware.bin.extracted/
binwalk --extract firmware.bin     # Same as -e

# Recursive extraction (extract files within extracted files)
binwalk -Me firmware.bin

# Entropy analysis - find compressed/encrypted regions
binwalk -E firmware.bin            # Generate entropy graph
binwalk --entropy firmware.bin

# Opcode analysis - identify CPU architecture
binwalk -A firmware.bin
binwalk --opcodes firmware.bin

# Raw byte extraction at offset
binwalk --dd='type:extension' firmware.bin

# Specific signature types
binwalk --signature firmware.bin   # File signatures only
binwalk --raw='\\x1f\\x8b' firmware.bin  # Search for gzip magic bytes
```

**binwalk output interpretation:**
```
DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             TRX firmware header
28            0x1C            LZMA compressed data
1835008       0x1C0000        Squashfs filesystem, little endian
```

## hexdump / xxd - Raw Hex Analysis

```bash
# Hex + ASCII dump
hexdump -C binary_file
xxd binary_file

# Dump specific byte range
xxd -s 0x100 -l 256 binary_file    # 256 bytes starting at offset 0x100

# Just hex, no ASCII
hexdump -v -e '/1 "%02x "' binary_file

# Create hex dump that can be reversed
xxd binary_file > hex.txt
xxd -r hex.txt > reconstructed_binary

# Find specific bytes
xxd binary_file | grep "504b"      # Look for PK (ZIP signature)
```

## file - Identify File Types

```bash
# Basic identification
file unknown_file
file -i unknown_file               # MIME type

# Check multiple files
file *

# Follow symlinks
file -L symlink
```

## Common Analysis Workflows

### Unknown Binary Exploration
```bash
# 1. Identify file type
file mystery_file

# 2. Check for embedded files
binwalk mystery_file

# 3. Extract strings
strings -n 8 mystery_file | head -100

# 4. Look at hex header
xxd mystery_file | head -20

# 5. Check entropy (compressed/encrypted?)
binwalk -E mystery_file
```

### Firmware Analysis
```bash
# 1. Initial scan
binwalk firmware.bin

# 2. Extract everything
binwalk -Me firmware.bin

# 3. Explore extracted filesystem
find _firmware.bin.extracted -type f -name "*.conf"
find _firmware.bin.extracted -type f -name "passwd"

# 4. Search for secrets
grep -r "password" _firmware.bin.extracted/
strings -n 10 firmware.bin | grep -i -E "(pass|key|secret|token)"
```

### Finding Hidden Data
```bash
# Check for data after end of file
binwalk -E file.jpg               # Entropy spike at end = appended data

# Look for embedded archives
binwalk file.jpg | grep -E "(Zip|RAR|7z|gzip)"

# Extract with offset
dd if=file.jpg of=hidden.zip bs=1 skip=12345
```

## File Signatures (Magic Bytes)

| Signature | Hex | File Type |
|-----------|-----|-----------|
| `PK` | `50 4B 03 04` | ZIP archive |
| `Rar!` | `52 61 72 21` | RAR archive |
| `7z` | `37 7A BC AF` | 7-Zip |
| `ELF` | `7F 45 4C 46` | Linux executable |
| `MZ` | `4D 5A` | Windows executable |
| `PNG` | `89 50 4E 47` | PNG image |
| `JFIF` | `FF D8 FF E0` | JPEG image |
| `sqsh` | `73 71 73 68` | SquashFS |
| `hsqs` | `68 73 71 73` | SquashFS (LE) |

## Tips

- **Start with entropy**: High entropy = compressed or encrypted
- **Look for strings first**: Often reveals purpose quickly
- **Check file headers**: First 16 bytes often identify format
- **Use recursive extraction**: Firmware often has nested archives
- **Save offsets**: Note interesting locations for targeted extraction

© laurigates · MIT · laurigates/claude-plugins

Similar skills

All skills for Security →

From the same set27

The whole set →
python-development python-development gives your agent Python 3.10+ idioms: type hints, pattern matching, asyncio. Handy for library code and refactors. CX Codex +1 192installs generate-image The generate-image skill generates images from text prompts using Google's Gemini 3 Pro Image model on Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. CX Codex +1 177installs justfile-expert justfile-expert is a Claude Code skill for designing Just recipes, parameters, dependencies, and modules. It supports adding project commands and task automation. CX Codex +1 162installs git-commit-workflow The git-commit-workflow Claude Code skill defines commit-message and staging rules. It helps split related edits into focused commits and review staged changes. CX Codex +1 161installs shell-expert shell-expert is a Claude Code skill for writing Bash, zsh, and POSIX scripts and composing command-line automation. It activates for shell pipelines and portable scripting tasks. CX Codex +1 141installs rust-development A Rust development skill covering Cargo, ownership, async code, and Tokio. It fits coding tasks that mention Rust or its core tooling. CX Codex +1 108installs clippy-advanced clippy-advanced guides Clippy setup for Rust projects: custom lints, clippy.toml thresholds, suppression rules, and CI check commands. CX Codex +1 107installs playwright-testing The playwright-testing skill guides Playwright E2E work for web apps, including browser coverage, mobile viewports, API checks, and visual snapshots. CX Codex +1 106installs

Project sponsors

Companies that keep this analytics open