More screenshots
Works with the AI Agents you already use
Binary Analysis Patterns: Disassembly Reading
Read compiled code by shape, not by instruction: a fifteen-minute triage, the compiler idioms that reveal intent, and an outside-in reading order with confidence-labeled notes.
$5
Binary Analysis Patterns: Disassembly Reading
Example session with this skill installed
We found an old utility binary from a former contractor on a build server. Before we decide whether it can stay, I need to know what it actually does — especially whether it runs anything at startup or reaches out to the network. Here's the disassembly access; walk it.
- Read your context and instructions
- Compiled the binary analysis patterns
TRIAGE + ANCHORED READS — target: svc_helper.exe, supplied by the owner for assessment of their own build server.
Map first (15 minutes, no functions read yet): PE32+ x86-64, not packed — section entropy normal, strings fully readable. Imports: file and registry APIs, CreateServiceW, StartServiceCtrlDispatcher, Winsock WSAStartup/connect/send. Strings: a service name matching the filename, an error log path under the temp directory, the format string "retry %d: %s", and one dotted-quad address, 203.0.113.87, appearing as a plain string. Startup behavior is already indicated: service APIs plus dispatcher imports mean this binary is built to run as a service, before any function is read.
Anchor 1 — the address string. Its only cross-reference is function sub_1400013C0, which also calls connect and send. Read once, fast: it builds a short buffer containing the machine name and OS version, sends it, and retries three times with the "retry %d" string on failure. Named on the spot: report_inventory. Claim level: finding — the full data flow (buffer construction → send) was read end to end, and the buffer's contents are named in the notes.
Anchor 2 — startup. StartServiceCtrlDispatcher is called from the entry-point flow; the service control handler registers within the first call layer. Combined with the import evidence: finding — the binary installs into the service model and starts with the machine, not on user launch.
What was NOT found, stated just as plainly: no process-creation imports, no shell or command-interpreter strings, no file-deletion calls — the absence was checked against the full import table, not assumed.
Notes delivered in the skill's format: one entry per examined function, callers noted, confidence labeled; two regions (the config parser and an XOR-loop helper) marked purpose-partly-unknown rather than narrated past the evidence. Verdict for the owner's decision: a contractor inventory reporter that beacons the machine name and OS version to a hardcoded address on a retry loop, running as a service. Whether it stays is their call — what it does is no longer a guess.
Connects securely to your tools. The creator never sees your data.
About this skill
Nobody reads assembly one instruction at a time — experienced analysts recognize the shapes compilers can't help emitting and spend their attention only where the shapes get interesting. This skill teaches that pattern vocabulary and the discipline around it. It starts with authorization and scope: only binaries you own or are cleared to assess, worked on as copies, with understanding — not exploitation — as the deliverable. Then the fifteen-minute triage that maps any unknown binary before deep reading: what it is, where it starts, what it talks to, what it says, what's big. The core is the idiom catalog: function-frame rhythms that mark boundaries in stripped binaries, dispatch shapes that distinguish a small switch from a vtable call (and how collecting same-offset call sites recovers the vtable), widening moves that reveal source types, scaled indexing that gives away element sizes, and the string and memory idioms that point at logging, parsing, and protocol code. Reading strategy is outside-in: anchor on a telling string, follow its cross-references, read one function fast, go one call deep in each direction, and write the one-sentence summary before moving on. A claim-strength rubric (rumor, indicated, finding, confirmed) keeps every statement in your notes at the level its evidence actually supports. The worked example answers "does our old updater phone home anywhere else?" with three anchored reads instead of 400 functions. Edge cases cover packed code, optimization-erased frames, table-driven designs, and decompiler overconfidence, and the quality gate requires that a reader could re-walk your analysis from the notes alone.
- Packed, virtualized, or heavily obfuscated binaries defeat the static patterns until they're unpacked; the skill flags that as the triage verdict instead of pretending the protector's code is the program.
- Idiom examples are compiler- and architecture-flavored (MSVC/GCC-style x86-64); unusual compilers or aggressive optimization weaken some shapes, and the skill says which evidence to lean on instead.
- It teaches understanding, not modification: patching, key generation for software you don't own, and exploit development are explicitly out of scope.
How to use
- 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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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 24 days ago
Permissions
No special permissions declared or detected