National Cyber Warfare Foundation (NCWF)login

binny for agent-driven binary reverse engineering and reporting


0 user ratings
2026-11-10 09:29:01
milo
Red Team (CNA)
"binny

binny is an open source agent harness that drives any LLM through function-level reverse engineering of binaries and APKs, producing reviewable draft reports for authorized malware and vulnerability analysis.








Toolopenbin-ai/binny — a Go-based agent harness that plugs any LLM into local Ghidra/JADX decompilation and runs an automated triage-investigate-draft reverse engineering loop
CategoryReverse engineering / LLM agent orchestration
Primary UseAuthorized malware triage and vulnerability research on samples you own or are cleared to analyze, using /investigate, /ask, and /decompile against local Ghidra or JADX output
Safe UseEducational and documentary analysis for authorized professionals: use in malware analysis labs, internal security research, and sanctioned incident-response engagements on samples you have the right to examine
Telemetry NoteRuns on your own API key or fully local models via ollama/lmstudio; sandboxed scripts execute in a Docker container with no network, and decompiled artifacts stay on disk unless explicitly pushed to an OpenBin/OpenAPK project

binny is an open source agent harness for reverse engineering, written in Go and licensed under AGPL-3.0, currently sitting at 227 stars on GitHub. The critical design decision, which the README states bluntly, is that binny is the harness, not the model. It supplies the tools — decompiled functions, strings, imports, data symbols, a sealed sandbox, and local Ghidra and JADX integration — along with playbooks, budgets, checkpoints, and a report format. The model is whatever you bring: Claude, GPT, DeepSeek, Qwen, Kimi, Gemini, Bedrock, or a local model through Ollama or LM Studio. This separation matters for practitioners who already have strong opinions about which model reasons best over decompiled C and don't want that choice dictated by the tooling.


The workflow is oriented around a loop the README describes as triage, investigate, draft. /investigate kicks off the full pipeline: triage first classifies the sample against the STIX 2.1 malware vocabulary, selects matching playbooks, and then the agent walks the binary function by function until either the budget or the evidence is exhausted. Two lenses are available via /mode malware and /mode vuln, switching between a malware analysis report and a vulnerability research report. What's notable architecturally is that everything is exposed as a watchable tool call — listing functions, reading decompilations, pulling strings and imports, running sandboxed scripts — so the operator can audit the agent's reasoning trail rather than trusting a black box.


The command surface is unusually disciplined for this category of tool. /ask skips the pipeline entirely and lets you interrogate a project at its current state: verify a claim in an existing report, inspect one function, or build a defensive proof of concept such as a config decryptor. The README makes a subtle but important epistemological point here — an existing report is treated as claims to check, not facts. That skepticism baked into the tooling is a good sign that the authors understand how LLM-generated analysis should be reviewed rather than accepted. /autonomy offers three modes — autonomous runs to a finished draft, supervised pauses at phase boundaries and when the agent is unsure, and collaborative adds a short pre-writeup interview about audience, depth, and framing.


Sandboxing is where binny earns trust for authorized lab work. The sandbox run tool executes scripts in a Docker container with no network access, a read-only root filesystem, a read-only sample mount, dropped capabilities, and CPU, memory, and PID limits. That is a meaningfully hardened profile for executing anything derived from untrusted binary content. /work provides a persistent workspace that survives between sessions, and /sample attaches the raw binary to unlock extraction tooling. For firmware, /decompile [processor] accepts a Ghidra processor ID such as ARM:LE:32:v7, runs Ghidra locally, and keeps the result on disk — nothing is uploaded.


Android support is first-class rather than bolted on. Point /decompile at an .apk or .xapk and it runs JADX instead of Ghidra, sharing a worker image and image cache with the openbin CLI. Android projects get their own toolset: the parsed manifest with permissions, exported components, and intent filters, plus code search, find definition/find usages, and file listing and reads. The native-only tools are simply not offered in that context, which suggests the tool layer is honest about what the underlying analysis can actually support. /upload converts a locally decompiled APK into an OpenAPK project without redoing the work, and /samples//switch handle multi-sample projects such as dropper-plus-payload relationships or firmware revisions.


Local model support is documented with genuine operational depth rather than hand-waving. The README flags the two requirements that actually bite in practice: the model must support tool calling (it names qwen3, gpt-oss, llama3.1 and newer, mistral-nemo, and devstral as capable, and warns most small instruct models are not), and the context window must be large enough for decompiled code. Ollama's default 4k context is called out as too small, with OLLAMA_CONTEXT_LENGTH=32768 or a num_ctx Modelfile setting recommended. binny also compacts history earlier for local providers via a contextTokens setting in ~/.config/binny/config.json so the tool list stays in the window. llama.cpp (llama-server) and vLLM work through /endpoint, e.g. /endpoint ollama hxxp://localhost:8080/v1.


The provider story overall is bring-your-own-key, with Anthropic, OpenAI, DeepSeek, Qwen, Kimi, Gemini, and Bedrock preconfigured, keys stored locally via /key, and /endpoint able to point a provider at a gateway fronting an API on your own domain — a thoughtful touch for orgs with egress controls. The privacy posture is stated plainly: nothing about your sample goes to the vendor unless you put it into a project. For teams analyzing sensitive or customer-adjacent samples, running binny against a local Ollama model with local decompilation keeps the entire pipeline inside the lab boundary.


There are two interfaces. The terminal client is the primary surface, while binny desktop starts the same engine behind a graphical shell on a loopback port, opened in your browser with nothing else to install. The desktop exposes an Explorer and Code pane for decompiled sources, a Binary panel with functions, strings, imports, and decompiled C for Ghidra projects, a chat view showing every tool call, a Findings drawer where each finding links to the function it concerns, and Artifacts holding decryptors, PoCs, and YARA rules. A standalone Electron app lives in desktop/ and is built from the same backend, with installers attached to desktop-v* releases.


Reporting and resumability show engineering maturity. Sessions auto-save after every step, so a project marked resumable continues where it stopped — essential when a long autonomous run burns through budget mid-investigation. /draft, /findings, and /save expose the draft report, recorded findings, IOCs, classification, and coverage, and /save pushes the draft to the project report explicitly as a draft for human review before anything is published. That review gate, repeated throughout the README, aligns with how agent-assisted analysis should be governed: the model proposes, the operator disposes. /budget [n] caps per-project token spend, which is a practical control against runaway autonomous loops.


Building from source needs Go 1.22 or newer for a release build, though the module itself compiles on Go 1.18; go build -o binny . and go test ./... are the relevant commands, and release automation lives in .github/workflows/release.yml with cross-compilation for Linux, macOS, and Windows. Prebuilt binaries ship on the releases page, and installation is a one-liner: curl -fsSL https://openbin.ai/install-binny.sh | sh on macOS/Linux, with a PowerShell equivalent on Windows. Docker is required only for /decompile and the sandbox tools. Contributors must sign a CLA, which lets the project stay AGPL while OpenBin dual-licenses commercially — worth knowing if you plan to embed binny in a proprietary internal pipeline.


Where binny fits in an authorized workflow is clear: it's a force multiplier for malware analysts and vulnerability researchers who already know what a good report looks like, offloading the mechanical traversal of hundreds of decompiled functions while keeping every step observable and every claim reviewable. The topics list — ghidra, llm-agent, malware-analysis, ollama, reverse-engineering, security-research — matches the reality of the tool. Watch items are modest: the platform coupling to OpenBin/OpenAPK projects is optional but real, the 227-star project is young and its playbooks will evolve, and as with any LLM harness, findings still need a human to verify them before they land in a case file. Used inside that discipline, binny is one of the more thoughtfully architected entries in the emerging agent-assisted RE space.



Official project repository for openbin-ai/binny.

Download Tool

Educational analysis for authorized security professionals. Use only in controlled, authorized environments.






Source: OffensiveSec
Source Link: https://www.offsecblog.com/2026/11/binny-for-agent-driven-binary-reverse.html


Comments
new comment
Nobody has commented yet. Will you be the first?
 
Forum
Red Team (CNA)



Copyright 2012 through 2026 - National Cyber Warfare Foundation - All rights reserved worldwide.