rustrip
Make stripped Rust binaries readable again.
rustrip recovers three classes of artifacts that disassembly tools miss
on stripped, release-mode Rust binaries:
- String boundaries —
&strfat pointers(ptr, len)are reconstructed into individual labeled strings instead of one stretching blob of bytes. - Demangled symbol names — both legacy
_ZN...Eand v0_R...mangling, including generic-parameter context, are rendered ascore::fmt::writeinstead of<core::fmt::Write as core::fmt::Write>::write_fmt. - Panic site source paths — every
core::panic::Locationis recovered aspath/to/source.rs:line:col, letting you map a binary back to its source tree.
Output goes to a CLI table, JSON, or a Ghidra / Binary Ninja Python script that re-applies the annotations to whichever view you open it in.
Demo

$ rustrip target/release/rustrip.exe
vaddr kind label
------------------ ------- --------------------------------------------------------
0x1400b87d0 panic /rustc/.../library/std/src/io/stdio.rs:854:20
0x1400b9728 string /rustc/.../library/alloc/src/wtf8/mod.rs
0x1400b9888 string /rustc/.../library/alloc/src/fmt.rs
0x1400b9b40 string BOLD
0x1400b9b48 string DIMMED
0x1400b9b52 string ITALIC
0x1400b9b69 string UNDERLINE
0x1400b9b93 string DOTTED_UNDERLINE
...
0x1400c2100 symbol rustrip::binary::Binary::parse
0x1400c2280 symbol rustrip::analyzers::strings::StringsAnalyzer::analyze
0x1400c2450 symbol rustrip::output::table::Table::render
131 annotations recovered in 0.02s
$ rustrip target/release/my_app -f ghidra -o annotations.py
$ # paste annotations.py into Ghidra: Window > Script Manager > New > Python
Install
If crates.io still shows an older version, use the published binaries from the latest GitHub release while the crates index catches up.
Or grab a prebuilt binary from Releases.
Use
# Default: CLI table
# JSON for scripting / piping
# `--output` creates a new file and refuses to overwrite an existing path.
# If rendering fails, rustrip retains the partial new file and reports its path.
# Ghidra script (paste into Script Manager)
# Binary Ninja script (paste into Python console)
# Read from stdin
# File and stdin input are bounded to 64 MiB.
|
# Skip analyzers you don't need
# Limit string recovery length
Open the generated script in Ghidra
(Window > Script Manager > New > Python > paste),
or in Binary Ninja's Python console, and run it on the open view.
How it works
rustrip pipeline
┌─────────────┐ ┌──────────┐ ┌──────────────┐ ┌────────────┐
│ goblin │────▶│ Binary │────▶│ Analyzers │────▶│ Output │
│ ELF/PE/Mach │ │ vaddr↔ │ │ strings │ │ table │
│ parser │ │ offset │ │ symbols │ │ json │
└─────────────┘ │ readers │ │ panics │ │ ghidra │
└──────────┘ └──────────────┘ │ binja │
└────────────┘
binary.rs— goblin-backed model withvaddr <-> file-offsettranslation and size-aware readers (read_ptr,read_at_vaddr). All pointer arithmetic useschecked_add— malicious binaries withu64::MAXvaddrs can't overflow.analyzers/— independent passes. Each walks the binary and emits typed annotations. Add a new analyzer without touching the others.output/— backends receive only the merged annotation list and render it. Add a new backend without touching analyzers.
The architecture is intentionally narrow: only data analysis, no full disassembly in v0.1. That keeps the tool fast (sub-second on multi-MB binaries) and reliable on stripped output where disassembly is messy.
Verification
rustrip is verified by 15 free tools across 9 GitHub Actions workflows:
| Tool | What it checks | Result |
|---|---|---|
cargo test |
265 declared: 265 run on Unix, 264 on Windows (one Unix-only) | 0 failed |
cargo clippy |
Lints (pedantic + nursery) | 0 warnings |
cargo fmt |
Format consistency | 0 diffs |
cargo audit |
Dependency vulnerabilities | 0 advisories (49 deps) |
cargo-deny |
Supply chain: licenses + bans | all ok |
cargo-mutants |
v0.1.0 mutation baseline; integrated-source rerun pending | 81.0% (222/274) |
cargo-fuzz |
Coverage-guided fuzzing (6 targets) | 0 crashes |
cargo-llvm-cov |
Line + function coverage | 94% lines, 98% functions |
cargo-nextest |
Flaky test detection (3 retries) | 0 flaky |
| MIRI | Undefined behavior detection | 0 UB |
| CodeQL | SAST (GitHub) | 0 alerts |
| semgrep | Custom SAST rules | 0 ERROR findings |
| SonarCloud | Code quality + coverage dashboard | link |
| Codacy | Second-opinion static analysis dashboard | link |
| Ghidra 11.2.1 | Headless import + generated annotation script | 128 comments, 301 labels, 0 failures |
The core build/test workflow runs on Linux, Windows, and macOS for pushes
to main, PRs targeting main, its weekly schedule, and manual dispatches.
Fuzzing is nightly or manual, mutation testing also runs weekly, and releases
run only for version tags.
A bug this suite actually caught
Verification isn't just a badge wall. In v0.1.1, adversarial-input testing
found a real script-injection bug before it shipped to a tagged release:
Recovered strings were embedded into Ghidra/Binary Ninja scripts as Python raw literals (
r'''...'''). Raw strings can't end in a backslash — and a recovered&strending in\(trivial in a Windows path, and trivially craftable in a hostile binary) desynced the closing quote and corrupted the entire generated script, silently dropping every annotation.
Fixed by switching both backends to fully-escaped normal string literals,
then verified end-to-end by compiling the generated scripts under CPython —
see CHANGELOG.md. This is exactly the
class of bug cargo-fuzz and the property/metamorphic suites exist to catch
on a tool whose whole job is parsing untrusted, potentially adversarial
binaries.
Roadmap
- v0.1 (now): string-slice recovery, symbol demangling, panic-site recovery. ELF, PE, Mach-O. CLI + table / JSON / Ghidra / Binary Ninja.
- v0.2: instruction-aware slice recovery via
iced-x86(catches slices that aren't stored as static(ptr, len)pairs). - v0.3: enum discriminant and monomorphized generic-type recovery.
- v1.0: native Ghidra and Binary Ninja plugins; type propagation.
Reliability & threat model
rustrip is intended for reverse-engineering and malware triage. It must not panic on adversarial input. The pipeline returns an empty or parser-error result rather than crashing — verified by 6 fuzz targets with a nightly budget of 4 hours per target.
Contributing
PRs welcome. See CONTRIBUTING.md. Checks triggered for the PR must pass before review; scheduled fuzzing and tag-only releases do not run on pull requests.
License
MIT OR Apache-2.0 — pick whichever you prefer.