More screenshots
Works with the AI Agents you already use
Go and Rust Binary Reverse Engineering
Reverse stripped Go and Rust binaries through their runtimes: recover Go function names from pclntab, follow Rust panic strings, cut the monomorphized bloat, confirm behavior.
$5
Go and Rust Binary Reverse Engineering
Example session with this skill installed
We pulled a stripped 11.8 MB Linux binary named agentd off a build server during an incident review (authorized). strings shows go.buildid, runtime/proc.go, '/api/v2/ingest', 'panic: runtime error: index out of bounds', and 'x509: certificate signed by unknown authority'. Tell us what it is and what it does.
- Read your context and instructions
- Compiled the go and rust
Step 1 — Identification: Go, definitively. Tells: the go.buildid string, runtime source paths in the strings output, and the 11.8 MB size — the runtime ships inside every Go binary. The embedded build info gives a toolchain version, so all runtime-structure reading uses that version's layout.
Step 2 — Recovery: pclntab parsed cleanly; roughly 1,900 function names restored and applied to the database marked as recovered, not confirmed. The package map does the triage before any decompilation: main.*, net/http, crypto/tls, crypto/x509 — and notably no os/exec and no exec-shaped syscall surface, which already argues against a shell-style backdoor. A vendored metrics library accounts for most of the bulk.
Target selection from names: main.main → main.runCollectors → main.postBatch. postBatch xrefs the '/api/v2/ingest' string and the TLS client path. Decompiled (supported level): it batches collected counters, marshals them to JSON, and POSTs on a 60-second ticker. The x509 string is stock error text from crypto/x509, reachable from the dial path — and nothing in the main.* functions disables certificate verification; the "it must be MitM-able" hypothesis was checked, not assumed, and didn't hold. The panic string maps to a bounds check inside the vendored library's parser, not to custom code.
Verdict: an internal metrics agent — collects host counters, posts them to an ingest endpoint every 60 seconds, verifies TLS normally. Every claim in the full report is labeled hypothesis, supported, or confirmed; the recovered names are cited as tool output. Remaining gap, stated rather than papered over: the config file path and the exact counter list — one more decompile pass over runCollectors closes it.
Connects securely to your tools. The creator never sees your data.
About this skill
Stripped C binaries are anonymous; stripped Go and Rust binaries are chatty. Both runtimes leave metadata, panic text, and idiomatic shapes that survive stripping — and this skill is the protocol for exploiting that. Step 1 identifies the language before any disassembly, from cheap tells in order: go.buildid and runtime paths for Go, rust_begin_unwind and crate paths for Rust, section names, and the tell-tale binary size — plus recording the toolchain version, because runtime internals shift between releases. Step 2 (Go) recovers the function map from pclntab with a parser such as GoReSym or redress: names, file paths, and line numbers that turn a wall of anonymous addresses into the program's table of contents, with the interesting packages (crypto, net/http, os/exec, syscall) flagged on sight. It also teaches the idioms that make Go disassembly readable — strings as pointer/length pairs, slices as triples, interfaces as pairs — and the traps: goroutines make the call graph lie about execution order, so you trace data flow instead. Step 3 (Rust) works the panic strings: every unwrap and bounds-check message carries file and line info, giving you labeled landmarks across the binary; crate paths reconstruct the module tree; monomorphized duplicates get named once as a template and skipped; async functions are read as the state machines they compile to. Step 4 confirms statically recovered claims dynamically, breaking where the recovered names say the interesting work happens. A recovery checklist, a confidence rubric (hypothesis / supported / confirmed) that keeps recovered names from being reported as proven behavior, an evidence-discipline section, a full worked example (a stripped Go backdoor profiled in under an hour), and edge cases — garbled Go from obfuscators, panic=abort Rust, recovery tools lagging a new compiler release, cgo boundaries, packed samples — round it out. For binaries you own or are authorized to analyze.
- Name-garbling obfuscators defeat name recovery; the protocol degrades to panic paths, strings, and call patterns, which is slower and yields more hypotheses than findings.
- Rust binaries built with panic = abort and heavy stripping may retain few landmarks; expectations should be set accordingly.
- Recovery tools can lag a brand-new Go toolchain release; the skill covers manual pclntab fallback, but full automation isn't guaranteed per version.
- Recovered names are labels, not proof — behavior claims still require reading the function or a dynamic run, and the report format keeps the levels separate.
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