reverse-engineering · transilienceai — Claude Code skill: how to install
reverse-engineering guides disassembly and decompilation of ELF, PE, and Mach-O files to recover logic, emulate custom bytecode, and defeat binary obfuscation.
MIT 203 installs ★ 632 updated 2026-07-29
npx skills add transilienceai/communitytools --skill reverse-engineering -a claude-codeWhat reverse-engineering does
The skill focuses on typical CTF challenges and malware triage where a native binary executes a custom bytecode payload. It helps locate dispatcher loops, translate opcodes into Python lambdas, and rebuild the transformation chain without running the host executable.
It contains structured guidance for flattening callfuscation, simplifying mixed boolean-arithmetic expressions, and resolving encrypted instruction handlers unpacked into executable memory at runtime. Static-first analysis remains the primary focus, preventing issues with anti-debugging tricks or architecture mismatches.
Because the instructions emphasize purely static reconstruction, dynamic Frida hooks remain a fallback when memory cannot be parsed offline.
What it helps with
- identify custom virtual machine dispatchers and map opcodes to logic
- simplify mixed boolean-arithmetic expressions in disassembled code
- extract algorithm logic from binaries without dynamic execution
- decrypt instruction handlers stored inside data sections
Example prompts for the agent
- Locate the custom VM dispatcher in this ELF binary and draft a Python solver for its bytecode
- Deobfuscate the MBA arithmetic chain inside this checking routine
- Reconstruct the input verification routine from this PE file statically
How to install reverse-engineering
1Skills CLI (Vercel)
npx skills add transilienceai/communitytools --skill reverse-engineering -a claude-code2Manually: put the files in place
~/.claude/skills/reverse-engineering/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/reverse-engineering/
1Skills CLI (Vercel)
npx skills add transilienceai/communitytools --skill reverse-engineering -a codex2Manually: put the files in place
.agents/skills/reverse-engineering/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add transilienceai/communitytools --skill reverse-engineering -a cursor2Manually: put the files in place
.cursor/skills/reverse-engineering/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install transilienceai/communitytools skills/reverse-engineering2Manually: put the files in place
.github/skills/reverse-engineering/SKILL.md1Skills CLI (Vercel)
npx skills add transilienceai/communitytools --skill reverse-engineering -a gemini-cli2Platform CLI
gemini skills install https://github.com/transilienceai/communitytools --path skills/reverse-engineeringManually: put the files in place
.devin/skills/reverse-engineering/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add transilienceai/communitytools --skill reverse-engineering -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about reverse-engineering
How to install reverse-engineering in Claude Code?
Run npx skills add transilienceai/communitytools --skill reverse-engineering -a claude-code in your terminal.
What does the reverse-engineering skill do?
It guides static analysis of ELF, PE, and Mach-O binaries, custom-VM bytecode inversion, and deobfuscation of protected code.
When is this skill preferred over dynamic debuggers?
It solves inspection challenges when binaries contain anti-debug routines, lack a suitable execution environment, or run on foreign architectures.
Source text
SKILL.md · MIT
---
name: reverse-engineering
description: Static and dynamic reverse engineering — ELF/PE analysis, custom-VM bytecode, packed binaries, anti-debug bypass, Frida hooking.
---
# Reverse Engineering
## Scope
Reverse engineering compiled binaries (ELF, PE, Mach-O) and bytecode artifacts to recover algorithms, validate inputs, or build static solvers. Focused on the recurring CTF / malware-analysis pattern of a host binary that loads a "program" file under a custom ISA — recognising the dispatcher loop, mapping opcodes to Python lambdas, and inverting the transformation chain in pure Python without executing the host. Also covers callfuscation (control-flow chunking), MBA (mixed boolean-arithmetic) operator obfuscation, encrypted-handler tricks, and three-layer deobfuscation pipelines.
## When to use
- A binary plus a "program data" file are delivered together and the binary appears to be an interpreter (themed opcode names, dispatcher switch / jump table).
- Disassembly reveals a `while(true){ op = mem[pc++]; switch(op){...}; }` style loop or jump-table indexed by opcode.
- The binary is heavily obfuscated (callfuscation, MBA wrappers, encrypted handlers in `.data` decrypted to RWX at startup).
- You need to recover an algorithm or check function from native code without dynamic execution (anti-debug, wrong arch, no TTY).
- Static-first reverse engineering is preferred (faster, more reliable than emulator chains).
## References
- [reference/custom-vm-bytecode.md](reference/custom-vm-bytecode.md) — recognising and inverting custom stack/register/tape VMs; callfuscation linearization; MBA operator identification; encrypted-handler decryption.
© transilienceai · MIT · transilienceai/communitytools
Similar skills
All skills for Security →reverse-engineering by other authors comes first.