National Cyber Warfare Foundation (NCWF)login

Inside paranoia: how one Rust engine brings local-first disassembly, decompilation and debugging to PE, ELF and Mach-O


0 user ratings
2026-11-10 19:31:59
milo
Red Team (CNA)
"Inside

paranoia is a local-first reverse-engineering workbench covering PE, ELF and Mach-O across x86, x64 and AArch64, aimed at analysts doing authorized malware triage and binary research without any network dependency.








ToolAltumptic/paranoia — a local-first disassembler, decompiler and debugger for PE, ELF and Mach-O, written in Rust
CategoryBinary reverse-engineering and static/dynamic analysis platform
Primary UseAuthorized malware triage, vulnerability research and binary auditing via disasm, pseudo, xrefs and the GUI pseudocode and graph views
Safe UseIntended for authorized security assessments, malware-analysis labs and defensive research; the README itself instructs analysts to run samples in a VM
Telemetry Noteparanoia is explicitly NO-TELEMETRY and LOCAL-FIRST — it makes no network connections except an opt-in AI assistant, so defenders should assume its use leaves no external traces beyond local %APPDATA% artifacts

paranoia positions itself unapologetically as a local-first alternative to commercial reverse-engineering suites, and the README's topic list even includes the tag ida-alternative. It does disassembly, control-flow graphs, decompilation, debugging and scripting in one workbench, with keybindings deliberately matched to what IDA users already know: F5 for pseudocode, N to rename, X for cross references, P to create a function. The pitch is privacy and independence rather than raw power — no account, no telemetry, no update checks, and an engine written in Rust that is shared across a desktop app, a CLI, a WebAssembly browser build and an MCP server for AI agents.


The architecture is the most interesting part of the project. The same engine lives in crates/paranoia-core and is wrapped by crates/paranoia-engine, an out-of-process engine host for the Electron desktop shell, crates/paranoia-cli for the paranoia command, crates/paranoia-db for a redb-backed workspace store, and crates/paranoia-wasm for in-browser analysis. The renderer is sandboxed, the engine runs in its own process and only opens files you explicitly choose, and both the debugger and Python scripting require interactive confirmation before execution. That process separation is a sensible design for a tool whose users routinely open hostile binaries.


Format coverage is broad. On the PE side it handles PE32+ with forwarders, TLS callbacks, .pdata unwind data and .NET detection; on ELF it copes with PIE, PLT/GOT indirection and symbol versioning; on Mach-O it parses universal binaries, bind opcodes, chained fixups and the export trie. Architecture support spans x86, x86-64, AArch64, ARM32/Thumb-2, RISC-V, MIPS and PowerPC. For an authorized analyst working on mixed corpora — Windows loaders, Linux implants, macOS droppers — that breadth in a single tool with consistent keybindings is genuinely useful.


Automatic analysis recovers functions from entry points, exports, symbols and unwind tables, which is the detail that matters most: the README explicitly notes that stripped ELF and Mach-O files keep their functions because of the unwind-table heuristic. Switch tables, cross references and IDA-style automatic naming round out the static pass. Speed is documented rather than hand-waved: notepad.exe analyses in 45 ms and shell32.dll — 7.7 MB with 24,449 functions — in about a second on a Core i5-12450H. Those numbers suggest a genuinely modern engine rather than a toy.


The decompiler is where the honest limits live. Pseudocode generation exists for x86 and x64 with typed variables, API constants, loops, switch, and struct member access via Y on a variable, with types propagating across calls. AArch64 decompilation is explicitly experimental — no types, tested only against Go binaries — and every other architecture gets disassembly and graphs only. The README's Limits section is unusually candid, also covering MIPS being validated only on known instruction encodings, and the inability to load raw firmware images without a PE/ELF/Mach-O header.


The editing and patching workflow is close to complete. Renaming, comments, bookmarks, code/data/string definitions, local C types and full undo/redo are all persistent per file hash, so annotations survive across sessions and re-analysis. A hex view supports byte patches plus NOP, invert-jump and force-jump shortcuts backed by a built-in x86 assembler, with the ability to save the patched executable. In an authorized context this is what turns static analysis into iterative hypothesis-testing rather than one-shot observation.


Symbol and debug-info support is another strong signal of seriousness: PDB and DWARF names and types are consumed, and FLIRT library signatures in both .sig and .pat formats can be applied via paranoia sigapply. That last point matters practically, because reusing existing IDA signature collections to filter out statically linked library code saves enormous triage time on large legitimate-software binaries. The paranoia strings --referenced --json pipeline shows the CLI is designed for scripted, output-parseable workflows, not just interactive use.


Debugging is currently scoped to local targets only — Windows x64 and x32, plus Linux x86-64 — with remote debugging on the roadmap. The standard keys are there: F2 for breakpoints, F9 to run, F7/F8 for step into/over, F4 for run-to-cursor. The README's security note is worth internalizing for any professional: the debugger executes the program under analysis, so malware work belongs in a VM. That is exactly the right operational hygiene for dynamic analysis in an authorized lab.


Scripting will feel immediately familiar to IDA veterans: Python runs in your own interpreter with idc and idautils shims covering common calls, plus JavaScript, a plugin system, and a headless batch mode through paranoia script sample.exe analyse.py. This compatibility layer is a shrewd move — it lowers migration friction for teams with an existing script corpus and makes the headless CLI viable for automating bulk triage across sample collections in a controlled environment.


The AI angle is handled with notable restraint. An optional in-app assistant can use a local or hosted model, and paranoia mcp --root ./samples exposes an MCP server for agents like Claude Code. Critically, the MCP mode can hide the sample's strings from the model and keeps a log of everything the agent was shown — a thoughtful containment gesture given that leaking sample strings to third-party model APIs is a real operational risk during sensitive investigations. The --root scoping is also a sensible blast-radius control.


Supply-chain posture is better than most hobby projects. The README advertises SIGNED, ATTESTED, SBOM and NO-TELEMETRY badges, points to docs/PSB.md for definitions, and gives concrete verification commands: Get-FileHash against SHA256SUMS, cosign verify-blob against the Sigstore bundle tied to the CI workflow, and gh attestation verify. Since the Windows executables aren't Authenticode-signed and SmartScreen will warn on first launch, actually running those checks before analysis is the professional default, not paranoia theater.


The current constraints are real but well-documented: release builds are Windows-only (Linux users must build from source with Rust 1.82+ and Node.js 20+, with a documented CARGO_TARGET_DIR workaround for dlltool path-space errors), macOS and Linux packages are planned, and there has been no independent audit — the README says so plainly. At 54 stars and Apache-2.0, paranoia is an early-stage but architecturally credible entry in the open reverse-engineering space, worth watching for anyone who wants an IDA-shaped, offline, scriptable workbench for authorized binary analysis.



Official project repository for Altumptic/paranoia.

Download Tool

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






Source: OffensiveSec
Source Link: https://www.offsecblog.com/2026/11/inside-paranoia-how-one-rust-engine.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.