For a binary unpacking toolkit, the first results are qilingframework/qiling, radareorg/radare2 (Radare2 is a versatile reverse engineering framework with built-in static and dynamic analysis, scripting, and multi-format support PE, ELF, Mach-O, making it well-suited for unpacking and analyzing obfuscated malware, though it may need extra scripting for specific packers) and avast/retdec. 0xd4d/de4dot and radare/radare2 round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
These open-source utilities help security researchers unpack, disassemble, and analyze malicious binaries for threat intelligence.
A True Instrumentable Binary Emulation Framework
Qiling is a binary emulation framework that can execute and instrument malware binaries across multiple architectures and formats (PE, ELF, Mach-O) in a sandbox, making it ideal for dynamic unpacking, memory analysis, and scriptable reverse engineering — exactly the kind of tool needed here.
Radare2 is a comprehensive framework for reverse engineering and analyzing compiled software. It provides a command-line environment designed for disassembling, debugging, and patching binary executables across a wide range of processor architectures and operating systems. The system distinguishes itself through a modular, plugin-based architecture that supports cross-platform analysis and automated workflows. It utilizes memory-mapped file access to enable efficient structural inspection and modification of binaries without requiring full file loads. By lifting machine instructions into a un
Radare2 is a versatile reverse engineering framework with built-in static and dynamic analysis, scripting, and multi-format support (PE, ELF, Mach-O), making it well-suited for unpacking and analyzing obfuscated malware, though it may need extra scripting for specific packers.
RetDec is a reverse engineering framework and static binary analysis tool. Its primary purpose is to function as an LLVM-based machine code decompiler that translates binary machine code from multiple architectures into high-level C source code. The system employs a multi-stage lifting pipeline to recover program logic, using an intermediate representation to apply optimizations before emitting source code. It distinguishes itself through the ability to identify compilers and packers, perform executable unpacking, and reconstruct class hierarchies and original program structures. The framewo
RetDec is a reverse-engineering framework that unpacks packers, performs static binary analysis across PE/ELF/Mach-O, detects compilers and packers, and is scriptable—covering the core static-analysis needs for malware unpacking and analysis, but it does not include built-in dynamic sandbox execution for runtime behavior analysis.
de4dot is a .NET deobfuscator, unpacker, and assembly analysis tool. It is designed to remove obfuscation layers, restore metadata, and simplify bytecode control flow to transform protected binaries back into human-readable code. The project features specialized systems for decrypting strings and constants using both static and dynamic analysis. It identifies specific protection tools through pattern-based detection and strips anti-analysis protections, such as tamper detection and anti-debugging code. The tool provides a suite of reverse engineering capabilities, including binary wrapper un
de4dot is a specialized .NET deobfuscator and unpacker that fits the malware-analysis category by stripping obfuscation and restoring code, but it is limited to .NET binaries and does not cover the broader multi-format, sandbox, or memory-analysis capabilities this search requires.
radare2 is a reverse engineering framework and binary analysis toolset. It functions as a multi-architecture disassembler, low-level binary debugger, and hexadecimal editor for inspecting executable structures and interpreting machine code when original source files are unavailable. The framework provides capabilities for decompiling machine instructions, performing symbolic analysis, and diffing binary files to identify structural changes across versions. It also includes a digital forensic analyzer and disk analyzer for browsing filesystem formats in userland. The toolset supports binary p
Radare2 is a general-purpose reverse engineering framework with scripting, multi-format support, and both static and dynamic analysis capabilities, so it can be used for unpacking and analyzing obfuscated malware, but it lacks a dedicated sandbox and built-in packer detection, making it fit rather than the best-in-class answer.
pe-sieve is a set of diagnostic tools for scanning Windows process memory to identify malicious implants, shellcode, and hooks. It functions as an in-memory implant detector, malware unpacker, and process callstack analyzer designed to locate and dump memory patches and injected code from running processes. The project identifies advanced evasion techniques, such as process hollowing and reflective injection, by verifying portable executable structures in memory. It distinguishes itself by analyzing process callstacks to detect anomalies and redirections and by reconstructing executable heade
pe-sieve is a Windows-focused in-memory malware unpacker and implant detector that dumps and analyzes injected code and evasion techniques from running processes, directly supporting unpacking, process analysis, and obfuscation detection required for reverse engineering and security research.
Volatility is a memory forensics framework and digital forensics tool designed to extract and analyze evidence from volatile computer memory dumps. It functions as a memory dump parser and analysis platform used to identify running processes, network connections, and loaded modules from a system RAM capture. The framework enables the reconstruction of system state to uncover malicious activity, such as rootkits and injected code, during malware incident response and threat hunting. It provides capabilities for digital forensic investigations to detect unauthorized access and indicators of com
Volatility is a memory forensics framework that analyzes RAM dumps to detect injected code and rootkits, making it useful for malware incident response, but it does not unpack or statically analyze obfuscated binary files themselves, so it is not a malware unpacking and binary analysis tool.
pyinstxtractor is a PyInstaller executable unpacker and Python bytecode recovery tool. It functions as a helper for decompiling compiled Python binaries by extracting bundled binaries and bytecode from executables created with PyInstaller. The project includes a bytecode decryptor to remove encryption from extracted files and a header repair tool that restores corrupted headers. These capabilities ensure that extracted compiled files are compatible with bytecode decompilation software. The utility covers reverse engineering of Python applications, supporting malware analysis workflows throug
This repository is a specialized unpacker for PyInstaller-compiled executables, which helps recover Python bytecode from that specific packer; while valuable for analyzing Python-based malware, it does not cover the multi-format (PE, ELF, Mach‑O) or general static/dynamic analysis features required for a broad malware unpacking and analysis tool.
Web App for Volatility framework
This web interface for the Volatility framework supports memory forensics and process analysis, which can aid malware analysis, but it does not provide unpacking of obfuscated binaries or static/dynamic binary analysis—it is a memory analysis tool, not a malware unpacking and analysis tool in itself.
Rekall Memory Forensic Framework
Rekall is a memory forensic framework focused on analyzing RAM dumps, not a tool for unpacking and analyzing obfuscated malware binaries; it can assist in malware analysis from memory but lacks the core binary unpacking and static/dynamic analysis features you need.
dnSpy is a desktop application designed for the analysis, debugging, and modification of compiled .NET assemblies. It functions as an assembly analysis suite and decompiler, translating binary instruction streams back into readable source code to facilitate reverse engineering when original source files are unavailable. The tool distinguishes itself through an integrated binary patching engine and metadata editor, which allow for the direct modification of executable logic and internal metadata tables. It supports in-process debugging instrumentation, enabling users to inject runtime hooks, s
dnSpy is a .NET assembly decompiler and debugger, not a general malware unpacking and analysis tool—it only handles .NET binaries and lacks the multi-format packer unpacking, sandbox execution, and obfuscation detection this search requires.
Ghidra is a software reverse engineering suite designed to analyze compiled binaries and reconstruct program logic without access to original source code. It provides an interactive environment for disassembly and decompilation, utilizing a platform-independent intermediate representation to maintain consistency across diverse hardware architectures. The framework supports automated binary analysis through programmatic routines, enabling the investigation of complex code patterns and security indicators. The platform distinguishes itself through a modular architecture that allows for extensiv
Ghidra is a general-purpose reverse engineering suite with static analysis and scripting capabilities, but it lacks built-in dynamic analysis and automated packer unpacking, making it a broader platform rather than a dedicated malware unpacking and analysis tool.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| qilingframework/qiling | 6K | Python | GPL-2.0 | |
| radareorg/radare2 | 23.1K | C | other | |
| avast/retdec | 8.6K | C++ | MIT | |
| 0xd4d/de4dot | 7.4K | C# | GPL-3.0 | |
| radare/radare2 | 24.1K | C | NOASSERTION | |
| hasherezade/pe-sieve | 3.6K | C++ | bsd-2-clause | |
| volatilityfoundation/volatility | 8K | Python | gpl-2.0 | |
| extremecoders-re/pyinstxtractor | 4.1K | Python | gpl-3.0 | |
| kevthehermit/volutility | 387 | Python | GPL-3.0 | |
| google/rekall | 2K | Python | GPL-2.0 |