radare2 — Security analysis and diagnostics

An open-source tool suite that provides disassembly, debugging, and reverse engineering in a single framework.

Basic information

What is this program?

radare2 (r2 for short) is an open-source reverse engineering framework that opens executable and firmware binaries to examine their internal structure, disassemble them, and even debug them when needed.

Rather than a single monolithic GUI, it consists of small tools such as the r2 shell and rabin2, rasm2, and radiff2, making it easy to put into command-line scripts or attach to existing analysis pipelines. It handles more than 60 architectures including x86, ARM, MIPS, and RISC-V.

What problems does it solve?

• When you need to check the internal behavior of an executable file whose origin is unknown.
• When you need to quickly scan strings and function structures in firmware images.
• When you need to automate binary comparison and analysis from the command line without a large GUI like Ghidra or IDA.
• When you need to reduce licensing burden in education and research environments that require support for diverse architectures.

Key features

Disassembly and session management

Opens binaries to explore sections, symbols, and disassembly, and saves analysis sessions.

• Use case: Follows the flow of the main function in PE/ELF executable files.
• Result: Obtains function-level disassembly and call structure.
• Limitations: Analysis time can be long for binaries with tens of thousands of lines.

rabin2 information extraction

Quickly extracts architecture, sections, symbols, and embedded strings from executable files.

• Use case: View an overview before opening a file.
• Result: Obtains entry point, imports, and string list.
• Limitations: Detailed analysis must be performed in the main r2 shell.

Emulation and debugging

Provides basic debugger integration and virtually executes some flows through code emulation.

• Use case: Check results by running only specific functions without real hardware.
• Result: Tracks register and memory changes.
• Limitations: Emulation cannot reproduce complete system behavior.

Scripting

Programmatically calls analysis commands from Python, Node, and others via r2pipe.

• Use case: Batch-scan hundreds of binaries using the same criteria.
• Result: Collects analysis results as structured data.
• Limitations: Learning r2 command syntax must come before writing scripts.

Installation and execution

Official repository (Linux/macOS)

Clone the official GitHub repository and run the installation script.

git clone --depth 1 https://github.com/radareorg/radare2
cd radare2
sys/install.sh

Ubuntu / Debian (repository version)

The distribution repository version may be older, so check the version.

sudo apt update
sudo apt install radare2
r2 -v

Windows

Use the Windows build or source build from the releases page.

# https://github.com/radareorg/radare2/releases

Real-world usage examples

Information summary

View architecture and symbol overview without opening the file.

rabin2 -I /usr/bin/ls

Disassembly (example)

Open with r2, perform automatic analysis, and disassemble around main. The output is shown as an example.

r2 -A /usr/bin/ls
pdf @main

String extraction

Extract printable strings embedded in the file.

rabin2 -z /usr/bin/ls

Advantages and limitations

Advantages

• LGPL license means fewer commercial restrictions and is fully open source.
• Supports more than 60 CPU architectures, making it useful for firmware and embedded analysis.
• Its small, composable tool design makes it easy to fit into automation pipelines.
• Can run in server environments without a GUI.

Points to consider before use

• The command system is extensive, so the learning curve is steep for beginners.
• Decompilation convenience is lacking compared to large GUI reversing tools such as Ghidra.
• Distribution repository versions are often behind the latest official version.
• Some recent architecture features may be supported only in development builds.

Comparison with similar programs

Official resources and further learning

• Official homepage — https://www.radare.org/
• Official documentation / knowledge base — https://book.rada.re/
• Official download — https://github.com/radareorg/radare2/releases
• Release notes — https://github.com/radareorg/radare2/releases
• Source / development resources — https://github.com/radareorg/radare2

Version and supported environment information was checked on the official site as of 2026-10-18. Installation commands may vary depending on the distribution and version you use, so please also check the official installation documentation.

Actual execution screen

This is a composite example that reconstructs, in a server style, the file information extraction output of rabin2, a companion tool to radare2. The screen is a composite example and not an actual execution result.

!Terminal screen extracting ELF file information (arch, bintype, bits, etc.) using the radare2 rabin2 command

A server actually in operation.

Source (HTML): https://games.aidebatehub.com/programs/apps/security/radare2.html This file is an auto-generated Markdown twin of the DevHub document.