More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Go and Rust Binary Reverse Engineering

    1

    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

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Go and Rust Binary Reverse Engineering

    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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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

    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    For C, mostly yes. Go keeps its function table in pclntab because the runtime needs it for stack traces, and Rust bakes file-and-line panic messages into the binary. Stripping removes the symbol table, not the runtime's own metadata — that's the whole opening this skill exploits.

    As a map, yes; as proof, no. Names are recorded as tool output, used to pick targets, and each reported behavior is labeled hypothesis, supported (code read), or confirmed (observed running). A misleadingly named function is exactly what the code read is for.

    No — it front-loads one. Runtime recovery tells you where to look and what the pieces are called; you still decompile in a disassembler, and for C libraries linked via cgo you switch back to the general survey-first method at the boundary.

    New in Security