Radare2 百科指南

← 返回指南列表

Radare2 百科指南

Radare2(简称 R2)是一个开源、模块化、脚本化的逆向工程框架,支持多架构、多平台二进制分析。它设计之初就是为逆向工程师提供一个命令行驱动的轻量工具,完整覆盖从反汇编、反编译、调试到二进制修改的全流程。

本指南基于 Radare2 5.8+ 版本编写,社区协作的官方文档:**https://book.rada.re/**


一、概述

1.1 什么是 Radare2

Radare2 是 pancake 于 2009 年启动的项目,经过近 20 年演进,已经成长为业界最完整的开源逆向工程框架。它是 rada.re 项目的第三代版本,2024 年刚刚完成官方书的第三次修订。

核心特性:

特性 说明
多架构支持 x86/x86-64, ARM32/64, AVR, MIPS, PowerPC, RISC-V, …
多格式支持 ELF, PE, Mach-O, raw binary, kernel dump, firmware, …
命令行原生 纯文本界面,Vim 风格按键,可编程
完全脚本化 内置 rizin 解释器(r2pipe),支持 Python 绑定
可视化模式 函数流程图、CFG 可视化、十六进制编辑
零配置便携 单文件可执行,不依赖 GUI,适合远程分析
社区驱动 GitHub 开源,活跃开发,持续更新
免费开源 LGPLv3 许可证,商业项目可免费使用

1.2 主要应用场景

场景 说明
逆向工程 分析未知二进制,恢复函数、识别数据结构
漏洞研究 定位漏洞位置,分析利用路径
固件修改 提取固件、反汇编、打补丁、重新打包
恶意软件分析 静态分析、动态调试、代码混淆清除
软件破解 跳过验证流程、修改关键判断分支
调试分析 本地调试、远程 gdb 调试、qemu-user 调试
二进制 diff 比较两个版本的差异变化
CTF 逆向 快速定位标志,解决逆向挑战题

1.3 Radare2 发展简史

年份 版本 里程碑
2009 radare1 初始版本,由 pancake 开发
2009 - 2014 社区参与,文档停滞
2014 重构并重写官方书,第一版出版
2014 - 2024 持续开发功能,文档再次老化
2024 5.8+ pancake 更新文档,第三版编写中

二、环境配置

2.1 安装方式

Linux(Debian/Ubuntu):

BASH
# 从软件源安装(版本可能稍旧)
sudo apt install radare2

# 如果需要最新版,可使用官方安装脚本
wget -qO- https://radare.org/install | sh

# 查看版本
r2 -v
# radare2 5.8.x ...

macOS(Homebrew):

BASH
brew install radare2

编译源码(推荐,获取最新特性):

BASH
# 克隆仓库
git clone https://github.com/radareorg/radare2.git
cd radare2

# 配置编译(自动检测)
./configure

# 编译并安装
make
sudo make install
# 或
sudo make install prefix=/usr/local

# 卸载
sudo make uninstall

Docker:

BASH
# 拉取镜像
docker pull radare/radare2

# 运行
docker run -it --rm -v $(pwd):/pwd radare/radare2 /pwd/binary

2.2 安装验证

BASH
# 启动 r2
r2 -v
# 应输出类似:
# radare2 5.8.8 (git commit ...)  Linux x86-64
BASH
# 测试反汇编一个简单文件
echo 'int main(){return 0;}' > test.c
gcc -c test.c -o test.o
r2 -A -c 'pdf @ main' test.o
# 应打印出 main 函数的反汇编

2.3 配置文件

Radare2 配置文件通常位于 ~/.config/radare2/radare2rc。

常用配置:

CODE
# ~/.config/radare2/radare2rc
# 使用 Intel 语法
asm.syntax = intel
# 反汇编显示地址
asm.addr = true
# 高亮显示
scr.color = true
# 增量分析
anal.incremental = true
# 自动反分析超时限制(毫秒)
anal.timeout = 5000
# 可视化模式配色
theme = zenburn

加载配置:

BASH
r2 -i ~/.config/radare2/radare2rc binary

三、基础概念与界面布局

3.1 核心设计思想

Radare2 采用单地址空间设计:你打开一个二进制后,整个二进制被映射到一个虚拟地址空间,你可以自由跳转到任意地址查看、编辑。

概念 说明
seek 移动当前偏移(地址),核心操作
seek s 绝对偏移,s 0x401000 跳转到 0x401000
s+ / s- 相对偏移移动
seeker 模式匹配、字符串搜索、指令模式搜索
block 当前显示块大小,按页浏览
flag 标签(符号名),将地址命名为函数/变量名
function 分析出函数边界后,标记为函数
analysis 自动分析函数、交叉引用、调用图
seek 命令 s 是最基础命令,几乎每次操作都用到

3.2 启动方式

BASH
# 分析并打开二进制(自动分析)
r2 -A binary

# 只读打开(不修改原文件)
r2 -A -r binary

# 写模式打开(允许写入修改)
r2 -w binary

# 调试二进制
r2 -d binary

# 附加到进程
r2 -d <pid>

# 远程调试
r2 -d gdb://localhost:1234

3.3 帮助系统

在 r2 交互界面:

CODE
# 显示所有可用命令分类
?

# 搜索命令(正则)
? /seek

# 显示特定命令帮助
?i aaa

# 显示版本和支持架构
?v

3.4 三种操作模式

模式 进入方式 说明
命令模式 进入 r2 后默认 输入命令,回车执行
可视化 V 或 VV 图形化显示,箭头键导航
十六进制编辑 Vp 或 p 字节级修改
调试模式 -d 启动或 ood 重新打开 设置断点、单步执行
面板模式 V 再按 p 多面板布局

3.5 基本导航

CODE
# 跳转到绝对地址
s 0x401000
s 0x0             # 跳转到文件开头
s $               # 跳转到文件结尾

# 相对跳转
s+ 0x100         # 向前移动 0x100 字节
s- 0x100         # 向后移动 0x100 字节

# 跳转到符号/标签
s main            # 跳转到 main 函数
sym.main          # 简写,等价于 s main

# 跳转到节(section)
s .text          # 跳转到 .text 节起始

3.6 查看当前状态

CODE
# 打印当前 seek(地址)
s

# 打印文件信息
iI

# 打印各个 section 信息
iS

# 打印符号表
is

# 打印导入/导出表
ii

四、核心命令详解

4.1 自动分析:aaa 家族

CODE
aaa         # 全自动分析全部函数
            # 等同于:aa; aac; aar; aaa; afl

aa          # 分析所有代码块
aaa         # 自动分析全部(推荐,最常用)
aaad        # 删除所有分析结果
aac         # 分析函数调用信息
aaf         # 分析标志信息
aap         # 分析程序入口点
aar         # 重新分析引用关系
aae[!]      # 扩展自动分析(需要更多时间)
aacp        # 分析函数参数类型
aan         # 分析命名空间
aab         # 分析基本块边界

实际工作流:

BASH
$ r2 -A binary    # 启动时自动执行 aaa
# 或者打开后手动:
[0x00000000]> aaa

分析后可以:

  • 自动识别所有函数边界
  • 建立基本块
  • 计算控制流图
  • 建立交叉引用(XREF)
  • 识别出字符串、常量
  • 识别出导入函数

注意:

  • 大文件分析可能需要几十秒到几分钟
  • 如果只想快速打开,可以只做 aa 不做 aaa
  • 如果增量修改后,可用 aaa 重新分析

4.2 搜索功能:z 家族

CODE
z                   # 显示搜索统计
z/  string          # 搜索字符串(忽略大小写)
z/  "hello world"   # 搜索带空格的字符串
z/  test\x00         # 搜索带\x00结束符
z/b  90             # 搜索字节值 0x90
z/b  90 90          # 搜索连续两个 0x90
z/  e0 f1            # 搜索字节序列 e0 f1
z/w  0x1234          # 搜索 word 0x1234
z/d  0x12345678      # 搜索 dword 0x12345678
z/q  0x123456789      # 搜索 qword
z/a                  # 重新执行最后的搜索

搜索结果跳转:

CODE
# 搜索结果列表
z

# 跳转到下一个匹配
oz

# 跳转到上一个匹配
Oz

正则搜索:

CODE
z/[0-9]
# 正则搜索字节模式

十六字节搜索:

CODE
z:  48 8b 05  →  搜索 48 8b 05 三个字节

4.3 命令分隔符:\

\ 是 Radare2 特有的命令分隔符,你可以在一行写多个命令。

CODE
# 等价写法:
s main; pdf            # 用分号分隔(Shell 风格)
s main\ pdf            # 用反斜杠分隔(R2 风格)
分隔符 用法说明
; 分号,Shell 风格,大部分情况可用
\ 反斜杠,R2 原生风格,不受空格影响,建议用这个

常见组合:

CODE
s main\ pdf                # 跳转到 main 然后打印反汇编
s 0x401000\ pd 10          # 跳转到地址然后反汇编 10 条指令
aaa\ afl                  # 全分析然后列出所有函数

4.4 打印函数反汇编:pdf / pdf @ addr

CODE
pdf                 # 打印当前地址所在函数的完整反汇编
pdf @ main          # 直接打印 main 函数反汇编
pdf @ 0x401000      # 打印 0x401000 所在函数
pD                  # 打印当前块反汇编(不按函数)
pd 10               # 只打印 10 条指令

输出格式(Intel 语法):

NASM
; 输出示例:
; main (int argc, char **argv);
; rbp: rbp frame size: 32
0x00001129      push rbp
0x0000112a      mov rbp, rsp
0x0000112d      sub rsp, 0x20
0x00001131      mov dword [rbp-0x14], edi
0x00001134      mov qword [rbp-0x20], rsi
...

常用参数:

CODE
pdfs                # 显示指令偏移 + 字节 + 汇编
pdfj                # 以 JSON 格式输出函数分析结果
pdd                 # 反汇编为 NASM 语法输出

4.5 打印 basic block 反汇编:pd

CODE
pd                  # 打印从当前位置开始的反汇编
pd N                # 打印 N 条指令
pd 20               # 打印 20 条指令
pD                  # 直到当前块结束,一次性全部打印
pD 0x100            # 打印 0x100 字节

4.6 列出所有函数:afl

CODE
afl                 # 列出所有分析出的函数

输出示例:

CODE
0x00001129  123 bytes  main
0x00001050   87 bytes  __libc_start_main
0x00001200   45 bytes  foo

过滤输出:

CODE
afl~main           # 正则过滤包含 main 的函数

4.7 交叉引用:ax

CODE
axp                 # 打印谁调用这里(callers)
axa                 # 打印这里调用哪里(callees)
axr                 # 打印数据引用

示例:

CODE
[0x00001129]> axp
# 显示:
# 0x00001050: call sym.main
# 所以 __libc_start_main 调用了 main

4.8 标记标签:f

CODE
f                   # 列出所有标签
f name addr          # 在 addr 处添加标签 name
f name 0x401000      # 在 0x401000 添加标签
f- name              # 删除标签
f- 0x401000          # 删除地址处标签

示例:

CODE
f main 0x401129

4.9 地址信息:i

CODE
i                   # 显示文件头信息
iS                  # 显示所有 section
is                  # 显示所有符号
ii                  # 显示导入符号
ie                  # 显示导出符号

4.10 二进制输出:wtf / wo

CODE
# 写入修改后,保存到新文件
wtf output.bin       # 写入整个文件
w 0x1234 0x90        # 在 0x1234 写入字节 0x90
wx 90 90             # 写入连续两个 0x90
wo output.bin         # 写入当前块

五、调试模式全面指南

5.1 启动调试的三种方式

BASH
# ===== 方式 1:调试本地可执行文件 =====
$ r2 -d ./binary
# r2 会 fork + exec 运行 binary,然后 attach
# 程序在 entrypoint 暂停,等待你控制

# ===== 方式 2:附加到运行中进程 =====
$ ps aux | grep binary
user    1234  ...  ./binary
$ r2 -d 1234          # 附加到 PID 1234
# 注意:需要 root 权限或 ptrace 权限

# ===== 方式 3:远程 gdbstub 调试 =====
# 常用场景:调试嵌入式设备、qemu 模拟器
# 在目标端启动 gdbserver:
$ gdbserver :1234 ./binary
# 在本地用 r2 连接:
$ r2 -d gdb://192.168.1.100:1234

# 调试内核(qemu)
$ qemu-system-x86_64 -kernel bzImage -s -S ...
# -s = -gdb tcp::1234,-S = 启动即暂停
$ r2 -d gdb://localhost:1234

5.2 调试命令全集 d 系列

命令 含义 示例
dc continue 继续执行 dc
ds step 单步步入 ds 3(连步 3 次)
dso step over 单步步过 dso
dsu step until 返回 跳出当前函数
dbt backtrace 栈回溯 dbt / dbt 10
db breakpoint 设置断点 db 0x401150
db 无参数 = 列出所有断点 db
db- 删除断点 db- 0x401150 / db-
dbh hardware breakpoint 硬件断点 dbh 0x401150
dbc conditional breakpoint 条件断点 dbc 0x401150 eax==0
dr 显示所有寄存器 dr
dr=reg 设置寄存器值 dr eax=0
drr 寄存器引用(找出寄存器指向哪里) drr
dpx 打印栈指针附近的十六进制 dpx 0x40
dm 显示内存映射 / proc maps dm
dp 显示进程信息 dp
dk 显示信号信息 dk
dcs 显示调用栈 dcs
ood reopen in debug mode 重新以调试模式打开 ood
oo+ reopen in write mode + debug 重新写入模式打开
doo reopen and seek to entry 重新打开并跳转到入口

5.3 完整调试会话示例

BASH
# ===== 准备阶段:编译一个有漏洞的程序 =====
$ cat vuln.c
#include <stdio.h>
#include <string.h>

int check_password(char *input) {
    char buf[32];
    strcpy(buf, input);         // 危险!栈溢出
    return strcmp(buf, "secret123");
}

int main(int argc, char **argv) {
    if (argc != 2) {
        printf("Usage: %s password\n", argv[0]);
        return 1;
    }
    if (check_password(argv[1]) == 0) {
        printf("Access granted!\n");
    } else {
        printf("Access denied.\n");
    }
    return 0;
}

$ gcc -fno-stack-protector -z execstack -o vuln vuln.c
# -fno-stack-protector 关闭栈金丝雀(简化演示)
# -z execstack 使栈可执行(简化演示)

调试会话:

BASH
$ r2 -d ./vuln correct_password
# r2 启动调试,在 entrypoint 暂停
# 输出: attach pid 12340, ./vuln correct_password

# 1. 先分析
[0x7f000000]> aaa

# 2. 查找 check_password 函数
[0x7f000000]> afl ~ check
# 0x00401136  41  sym.check_password

# 3. 在 check_password 入口设置断点
[0x7f000000]> db 0x00401136

# 4. 继续执行到断点
[0x7f000000]> dc
# hit breakpoint at 0x00401136

# 5. 查看寄存器状态
[0x00401136]> dr
# rax = 0x00000000
# rbx = 0x7ffe12345678
# rcx = 0x00000000
# rdx = 0x00000000
# rsi = 0x7ffe12345abc ("correct_password")
# rdi = 0x7ffe12345abc ("correct_password") ← 第一个参数
# rbp = 0x7ffe12345600
# rsp = 0x7ffe123455f0
# rip = 0x00401136 (sym.check_password)
# r8-r15 = ...

# 6. 查看当前指令
[0x00401136]> pd 5
# 0x00401136  55  push rbp
# 0x00401137  4889e5  mov rbp, rsp
# 0x0040113a  4883ec30  sub rsp, 0x30
# 0x0040113e  48897de8  mov qword [rbp-0x18], rdi
# 0x00401142  488d45e0  lea rax, [rbp-0x20]
#                              ^^^^^^^^ 这就是 buf 的地址

# 7. 查看 rdi 指向的字符串(参数)
[0x00401136]> ps @ rdi
# "correct_password"

# 8. 单步到 strcmp 之前
[0x00401136]> dso ; 步过 push / mov
[0x0040113a]> dso
# ... 直到 strcmp

# 9. 在 strcmp 返回时设置断点(查看返回值)
# 先找到 call strcmp 的位置
[0x0040113a]> pdf ~ strcmp
# 0x00401160  e8cb...  call sym.imp.strcmp
# 在 call 之后设置断点,查看 eax 返回值
[0x00401160]> db 0x00401166
[0x0040113a]> dc
# 命中断点,查看 eax
[0x00401166]> dr eax
# eax = 0x00000001 (非零 = 密码错误)

# 10. 修改变量:直接把 eax 改成 0(让它 "成功")
[0x00401166]> dr eax=0
[0x00401166]> dc
# 继续执行,程序输出 "Access granted!"

5.4 调试中的内存查看技巧

CODE
# 打印栈指针(rsp)附近的内容
[0x00401136]> px 0x80 @ rsp
# 显示 128 字节栈内容

# 打印参数 rdi 指向的字符串
[0x00401136]> ps @ rdi

# 打印 rsi 指向的字符串(argv[1])
[0x00401136]> ps @ rsi

# 显示所有字符串引用
[0x00401136]> iz

# 显示全局变量
[0x00401136]> iS
# .bss 段 = 未初始化全局变量
# .data 段 = 已初始化全局变量

# 显示 proc maps(内存映射)
[0x00401136]> dm
# 0x00400000 - 0x00401000 r-x .text
# 0x00401000 - 0x00402000 r-- .rodata
# 0x00402000 - 0x00403000 rw- .data
# 0x7ffe12340000 - 0x7ffe12346000 rw- [stack]

5.5 栈溢出漏洞调试实战

BASH
$ r2 -d ./vuln AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA  # 40 个 A

在 r2 中:

CODE
[0x7f000000]> aaa

# 在 strcpy 之后设置断点
[0x7f000000]> pdf @ sym.check_password
# 找到:
# 0x00401142  call sym.imp.strcpy   ← 危险调用
# 0x00401147  ...                  ← strcpy 返回后
[0x7f000000]> db 0x00401147
[0x7f000000]> dc

# 查看栈(strcpy 写入 buf 之后)
[0x00401147]> px 0x60 @ rsp
# 应该能看到 buf 被 0x41414141 (AAAA) 填充
# 继续看,是否覆盖到返回地址(rbp+8 指向的位置)

# 如果返回地址被覆盖,继续执行时会 crash
[0x00401147]> dc
# 会在 ret 时崩溃,rip = 0x414141414141
# 这就是我们控制返回地址的证据!

# 确定精确偏移量:用 pattern 创建
# 200 字节的唯一模式输入,看 crash 时 rip 的值反推偏移

六、完整逆向工程实战

6.1 实战案例:从零分析一个密码验证程序

目标程序 crackme.c(编译成二进制):

C
#include <stdio.h>
#include <string.h>

int check(char *input) {
    int result = 1;
    if (strlen(input) != 8) { result = 0; }
    if (input[0] != 'R' || input[1] != '2') { result = 0; }
    if (input[2] + input[3] != 'A' + 'B') { result = 0; }
    if (strcmp(input+4, "Crack!") != 0) { result = 0; }
    return result;
}

int main(int argc, char **argv) {
    char buf[128];
    printf("Enter password: ");
    scanf("%127s", buf);
    if (check(buf)) {
        printf("Correct! Flag{%s}\n", buf);
    } else {
        printf("Wrong.\n");
    }
    return 0;
}

编译:

BASH
$ gcc -o crackme crackme.c

步骤 1:打开并分析

BASH
$ r2 -A ./crackme

步骤 2:查看文件信息

CODE
[0x00000000]> iI
# 架构: x86-64, 类型: ELF, 操作系统: linux, 位数: 64
# 入口点: 0x00401040 (entry0)

[0x00000000]> iS
# section 列表,确认 .text / .rodata / .data / .bss

步骤 3:列出函数,找到验证逻辑

CODE
[0x00000000]> afl
# 0x00401136  119  main
# 0x004011ad  202  check
# 0x00401000   16  sym.imp.printf
# 0x00401010   16  sym.imp.scanf
# 0x00401020   16  sym.imp.strcmp
# 0x00401030   16  sym.imp.strlen
# 0x00401040  ...  entry0

# 有 check 函数!直接看它
[0x00000000]> pdf @ sym.check

步骤 4:分析 check 函数反汇编

NASM
; ┌─ int check(char *input)
; │  rdi = input 字符串指针
; │  返回值: eax = 1 (正确) 或 0 (错误)
; └───────────────────────────────
0x004011ad  55             push rbp
0x004011ae  4889e5         mov rbp, rsp
0x004011b1  4883ec20       sub rsp, 0x20
0x004011b5  48897de8       mov qword [rbp-0x18], rdi  ; 保存 input 指针
0x004011b9  c745fc010000.  mov dword [rbp-4], 1        ; result = 1 (默认正确!)
; ───────────────────────────────
; 检查 1: strlen(input) == 8
0x004011c0  488b45e8       mov rax, qword [rbp-0x18]   ; rax = input
0x004011c4  4889c7         mov rdi, rax                 ; 参数1: input
0x004011c7  e864feffff     call sym.imp.strlen          ; strlen(input)
0x004011cc  4883f808       cmp rax, 8                    ; if (len != 8)
0x004011d0  7407           je 0x4011d9                   ; ├─ 跳过 (长度正确)
0x004011d2  c745fc000000.  mov dword [rbp-4], 0          ; └─ result = 0 (长度错误)
; ───────────────────────────────
; 检查 2: input[0] == 'R' && input[1] == '2'
0x004011d9  488b45e8       mov rax, qword [rbp-0x18]
0x004011dd  0fb600         movzx eax, byte [rax]          ; al = input[0]
0x004011e0  3c52           cmp al, 0x52                   ; if (input[0] != 'R')
0x004011e2  7518           jne 0x4011fc                   ; └─ 跳错误
0x004011e4  488b45e8       mov rax, qword [rbp-0x18]
0x004011e8  0fb64001       movzx eax, byte [rax+1]        ; al = input[1]
0x004011ec  3c32           cmp al, 0x32                   ; if (input[1] != '2')
0x004011ee  750c           jne 0x4011fc                   ; └─ 跳错误
; ───────────────────────────────
; 检查 3: input[2] + input[3] == 'A' + 'B' == 0x41 + 0x42 == 0x83
0x004011f0  488b45e8       mov rax, qword [rbp-0x18]
0x004011f4  0fb65002       movzx edx, byte [rax+2]        ; dl = input[2]
0x004011f8  488b45e8       mov rax, qword [rbp-0x18]
0x004011fc  0fb64003       movzx eax, byte [rax+3]        ; al = input[3]
0x00401200  01d0           add eax, edx                    ; eax = input[2] + input[3]
0x00401202  3d83000000     cmp eax, 0x83                   ; cmp 0x83 (131 = 'A'+'B')
0x00401207  7403           je 0x40120c                    ; 相等则继续
0x00401209  c745fc000000.  mov dword [rbp-4], 0          ; 不相等 result = 0
; ───────────────────────────────
; 检查 4: strcmp(input+4, "Crack!") == 0
0x0040120c  488d45e8       lea rax, [rbp-0x18]
0x00401210  488b00         mov rax, qword [rax]           ; rax = input
0x00401213  4883c004       add rax, 4                      ; rax = input+4
0x00401217  488d35ea0d00. lea rsi, [0x00402008]          ; rsi = "Crack!" 地址
0x0040121e  4889c7         mov rdi, rax                    ; rdi = input+4
0x00401221  e8fafdffff     call sym.imp.strcmp            ; strcmp(input+4, "Crack!")
0x00401226  85c0           test eax, eax                   ; if (result == 0)
0x00401228  7403           je 0x40122d                     ; └─ 相等则继续
0x0040122a  c745fc000000.  mov dword [rbp-4], 0           ; 不相等 result = 0
; ───────────────────────────────
; 返回 result
0x0040122d  8b45fc         mov eax, dword [rbp-4]         ; eax = result
0x00401230  c9             leave
0x00401231  c3             ret

从反汇编推导出密码格式:

位置 检查 要求 结论
总长度 strlen == 8 8 个字符 长度必须是 8
input[0] cmp al, 0x52 == ‘R’ (0x52=82) 第一个字符是 R
input[1] cmp al, 0x32 == ‘2’ (0x32=50) 第二个字符是 2
input[2] + input[3] cmp eax, 0x83 == 131 (0x41+0x42) 只要两字符之和为 131 即可,可能有多个解
input[4..7] strcmp vs “Crack!” == “Crack!” (5 字节) 后 5 字符是 Crack!

检查字符串引用:

CODE
[0x004011ad]> iz
# 0x00402008 string "Crack!"

构造密码(其中一个解):

CODE
input[0] = 'R'
input[1] = '2'
input[2] + input[3] = 0x83 = 131
# 让 input[2] = 'A' (0x41 = 65), input[3] = 'B' (0x42 = 66), 和 = 131 ✓
input[4..8] = "Crack!"

完整密码: R2ABCrack!

验证运行:

BASH
$ echo "R2ABCrack!" | ./crackme
# Enter password: Correct! Flag{R2ABCrack!}

成功! 我们通过反汇编完全逆向出了密码规则。

或者——打补丁绕过(不需要找密码):

CODE
[0x004011ad]> pdf @ sym.check ~ cmp
# 找到所有比较指令的地址
# 0x004011cc  cmp rax, 8
# 0x004011e0  cmp al, 0x52
# 0x004011ec  cmp al, 0x32
# 0x00401202  cmp eax, 0x83
# 0x00401226  test eax, eax

# 最简单:把 result 的初始值改成 1,并且永不改成 0
# 或者:在函数开头直接 mov eax, 1; ret

# 方案:把函数前 16 字节改成:
#   mov eax, 1    (b8 01 00 00 00)
#   ret           (c3)
# 5 字节足够覆盖原函数序言

[0x004011ad]> s sym.check
[0x004011ad]> wx b801000000c3
# b8 01 00 00 00 = mov eax, 0x1
# c3 = ret

# 保存修改
[0x004011ad]> wtf ./crackme_patched

验证:

BASH
$ chmod +x crackme_patched
$ echo "anything" | ./crackme_patched
# Enter password: Correct! Flag{anything}

无论输入什么都通过!我们成功 patch 了验证逻辑。

6.2 案例:从 .rodata 提取隐藏字符串

有时候密码/flag 不是逐字节比较,而是存储在只读数据段中。

BASH
$ r2 -A ./another_crackme
CODE
# 查看所有字符串(.rodata 段)
[0x00000000]> iz

# 或者在整个二进制中搜索
[0x00000000]> z/ flag
# 0x004020a0 hit0_0 "flag{hidden_in_rodata}"

# 直接得到 flag,不需要分析反汇编!

6.3 案例:分析静态链接的混淆代码

当二进制被 strip(去掉符号),所有函数变成 fcn.地址。

BASH
$ r2 -A ./stripped_crackme
[0x00000000]> afl
# 0x00401000  1234  fcn.00401000
# 0x00401500  500   fcn.00401500
# 0x00401800  300   fcn.00401800
# ... (没有符号名,全是 fcn.xxx)

# 策略:找哪个函数包含 strcmp/scanf 等调用
[0x00400000]> axp  ; 找引用关系
# 或者:
[0x00400000]> iz ~ password
# 0x00402000 "Enter password: "
[0x00400000]> axr @ 0x00402000  ; 看谁引用这个字符串
# 0x00401500: mov edi, 0x402000
# 0x00401500 调用了 printf,可能是 main

# 跳转到 fcn.00401500 反汇编
[0x00400000]> pdf @ 0x00401500
# 手动分析函数逻辑

# 给函数命名(方便后续引用)
[0x00401500]> afn main
[0x00401500]> f main 0x00401500

# 再找内部调用的验证函数
[0x00401500]> axa  ; 打印谁被这里调用
# 0x00401580: call 0x00401600
[0x00401500]> afn check 0x00401600
[0x00401500]> pdf @ check

七、配置详解与个性化

7.1 e 系列配置命令

CODE
# 查看所有配置变量
e

# 查看特定变量
e asm.syntax
# intel

# 修改配置
e asm.syntax=att       # 改成 AT&T 语法
e scr.color=true        # 启用彩色输出

# 恢复默认
e-

7.2 常用配置选项

配置项 类型 默认 说明
asm.syntax string intel 反汇编语法(intel / att)
asm.bytes bool true 是否显示原始字节码
asm.offset bool true 是否显示地址偏移
asm.lines bool true 分隔线显示
anal.timeout int 0 分析超时(毫秒),0 = 不限
anal.hashes bool false 是否分析 hash 识别函数
anal.strings bool true 是否自动识别字符串
anal.cc string systemv 调用约定(systemv / cdecl / stdcall / fastcall)
scr.color int 3 颜色深度(0=off, 1=16色, 2=256色, 3=24bit)
scr.scrollbar bool true 右侧滚动条
cfg.newtab bool false 新命令输出在新 tab
file.offset addr 0 文件起始偏移

7.3 .radare2rc 配置文件

Radare2 启动时会读取以下位置的配置(优先级从低到高):

  1. /etc/radare2rc
  2. ~/.config/radare2/radare2rc
  3. ./radare2rc(当前目录)

示例配置:

CODE
# ~/.config/radare2/radare2rc
# 反汇编语法
e asm.syntax = intel
# 彩色
e scr.color = 3
# 启用分析
e anal.incremental = true
# 默认主题
e theme = zenburn
# 显示字节码
e asm.bytes = true
# 显示地址偏移
e asm.offset = true
# 自动识别字符串
e anal.strings = true
# 设置 stack 大小
e dbg.stacksize = 0x100000
# 默认断点在 main
e dbg.bep = main

7.4 主题配色

CODE
# 列出可用主题
eco

# 切换主题
eco zenburn
eco dark
eco solarized

# 自定义颜色
ec rgb:0xff0000  ; 主颜色
ec rgb:0x00ff00  ; 反汇编颜色

八、r2pipe 自动化脚本

8.1 Python r2pipe 基础

PYTHON
import r2pipe

# 方式 1:打开二进制(静态分析)
r2 = r2pipe.open("./binary")

# 方式 2:启动调试
r2 = r2pipe.open("./binary", ["-d", "arg1"])

# 执行命令
output = r2.cmd("aaa")              # 执行命令,返回字符串输出
print(output)

# 执行并解析 JSON
funcs = r2.cmdj("aflj")             # aflj = afl 的 JSON 输出
for f in funcs:
    print(f"0x{f['offset']:08x} {f['name']}")

# 表达式求值
rax = r2.cmdj("?j $rax")           # 寄存器值
print(f"rax = {rax['num']}")

# 设置偏移(seek)然后打印
disasm = r2.cmd("s main; pdf")     # 跳 main 然后打印反汇编
r2.quit()

8.2 实战脚本 1:批量分析多个二进制

PYTHON
import r2pipe
import os
import json

def analyze_binary(path):
    """分析二进制,返回函数列表、字符串列表"""
    r2 = r2pipe.open(path)
    r2.cmd("aaa")

    funcs = r2.cmdj("aflj")
    strings = r2.cmdj("izzj")  # izzj = 所有字符串 JSON

    result = {
        "path": path,
        "num_functions": len(funcs),
        "functions": [f["name"] for f in funcs],
        "num_strings": len(strings),
        "interesting_strings": [s["string"] for s in strings
                                 if any(k in s["string"].lower()
                                        for k in ["password", "flag", "key", "secret"])],
    }

    r2.quit()
    return result

# 分析目录下所有二进制
for filename in os.listdir("./samples"):
    filepath = os.path.join("./samples", filename)
    if os.path.isfile(filepath) and os.access(filepath, os.X_OK):
        print(f"分析: {filename}")
        result = analyze_binary(filepath)
        print(f"  函数数量: {result['num_functions']}")
        print(f"  可疑字符串: {result['interesting_strings']}")

        # 保存到 JSON
        with open(f"{filename}.analysis.json", "w") as f:
            json.dump(result, f, indent=2)

8.3 实战脚本 2:自动提取字符串引用

PYTHON
import r2pipe

def find_password_functions(binary):
    """找出所有引用 password/key/flag 字符串的函数"""
    r2 = r2pipe.open(binary)
    r2.cmd("aaa")

    # 搜索所有可疑字符串
    keywords = ["password", "key", "flag", "secret", "enter"]
    suspicious = {}

    strings = r2.cmdj("izzj")
    for s in strings:
        text = s["string"].lower()
        for kw in keywords:
            if kw in text:
                addr = s["vaddr"]
                # 找到引用这个地址的指令
                refs = r2.cmd(f"axr @ {addr}")
                suspicious[hex(addr)] = {
                    "string": s["string"],
                    "refs": refs.strip(),
                }
                break

    r2.quit()
    return suspicious

result = find_password_functions("./crackme")
for addr, info in result.items():
    print(f"[+] {addr}: {info['string']}")
    print(f"    引用: {info['refs']}")
    print()

8.4 实战脚本 3:自动打补丁绕过验证

PYTHON
import r2pipe

def auto_patch_crackme(input_path, output_path):
    """自动分析 + 打补丁"""
    r2 = r2pipe.open(input_path)
    r2.cmd("aaa")

    # 1. 找到所有返回 0 或比较后跳转到错误分支的指令
    r2.cmd("s main")
    pdf = r2.cmd("pdf")

    # 2. 简单启发式:找所有 cmp + je/jne 后的 mov eax, 0
    #    然后把那些 mov eax, 0 改成 mov eax, 1
    #    (这是非常简化的版本,实际需要更精确分析)

    # 或者:查找所有 `mov eax, 0 ; ret` 模式
    #    这种是典型的错误返回模式

    # 更通用方法:把所有包含 call strcmp / strncmp 的比较后的条件跳转
    #            改成无条件不跳转(即恒为 "成功")

    r2.cmd(f"wtf {output_path}")  # 保存(这里没有真正修改,示例)
    r2.quit()

auto_patch_crackme("./crackme", "./patched")

重要提醒: 自动补丁脚本需要精确的反汇编分析,实际使用时建议先手动分析测试,再考虑自动化。


九、高级功能与最佳实践

9.1 函数签名识别(FLIRT)

Radare2 支持 FLIRT(Fast Library Identification and Recognition Technology),可以识别静态链接的标准库函数。

CODE
# 加载 sig 文件(预定义签名库)
zfs /path/to/libc.sig

# 应用签名
za

# 查看识别出的库函数
afl ~ sym.imp.

# 创建自己的签名
zf ./my_lib.sig 0x401000 0x402000  # 从 0x401000 到 0x402000 创建签名

9.2 图分析:控制流图 / 调用图

CODE
# 生成当前函数的控制流图
agc                 # 函数控制流图(ASCII 显示)
agc > func.dot     # 保存为 DOT 格式(可用 graphviz 可视化)
agj                 # JSON 格式输出图结构

# 整个程序的函数调用图
agc
# 或:
axf > callgraph.dot

用 graphviz 可视化:

BASH
dot -Tpng func.dot -o func.png
# 打开 func.png 看图形化的控制流

9.3 与 Ghidra / IDA 互补

虽然 Radare2 功能强大,但在大规模反编译和符号分析方面,Ghidra/IDA 更成熟。常用组合:

场景 工具
命令行分析 / 脚本自动化 Radare2
图形化反编译、复杂符号分析 Ghidra
大规模商业逆向(有 license) IDA Pro

Radare2 可以导入/导出与 Ghidra 兼容的格式,实现工作流互补。

9.4 最佳实践清单

  1. 打开文件前:先用 file/readelf -h/rabin2 -I 了解文件类型和架构
  2. 分析前:用 r2 -A 自动分析,或打开后手动 aaa
  3. 大文件:用 aa 不做完整引用分析,节省时间
  4. 调试前:先静态分析找到关键函数,再用断点精准调试
  5. 修改后:永远用 wtf 保存到新文件,不要覆盖原始文件
  6. 找密码:先用 iz / z/ 搜字符串,找不到再分析反汇编
  7. 混淆代码:用 aaa! 强制重新分析,可能需要 afb 手动标记函数边界
  8. 脚本化:重复性任务一律用 r2pipe python 脚本自动化
  9. 注释:分析过程中用 f name addr 给关键地址加标签,方便后续回顾
  10. 保存项目:分析大量文件时,可以保存会话避免重复分析:Ps project_name

9.5 常用命令速查表

场景 命令 说明
打开文件 r2 -A file 打开并自动分析
列出函数 afl 所有分析出的函数
查看反汇编 pdf @ main 打印 main 函数反汇编
跳地址 s 0x401136 / s main seek 到目标
搜索 z/ 'password' 搜索字符串
下一个搜索结果 oz 跳转命中处
写字节 wx 90 90 写入 NOP NOP
保存 wtf output 保存到新文件
设置断点 db 0x401150 设置地址断点
继续执行 dc continue
单步 ds / dso step / step over
寄存器 dr / dr eax=0 查看/修改寄存器
字符串 iz / ps @ addr 列出所有 / 打印一个
信息 iI / iS / is 文件头 / sections / symbols
配置 e var=value 修改配置
帮助 ? 命令分类帮助
退出 q 退出 r2

十、参考资源

10.1 官方文档

资源 链接
Radare2 官方手册 https://book.rada.re/
代码仓库 https://github.com/radareorg/radare2
r2pipe Python https://github.com/radareorg/radare2-r2pipe
rabin2(ELF/PE 信息提取) Radare2 自带工具
radiff2(二进制对比) Radare2 自带工具
rahash2(文件哈希) Radare2 自带工具

10.2 学习路径

CODE
入门: r2 -A binary → afl → pdf @ main → z/ string → 基本操作
进阶: 调试模式 (-d) → 断点 → 寄存器 → 栈回溯 → 动态分析
高级: r2pipe 脚本 → 自动化分析 → 反编译 → 混淆分析 → CTF
专家: 自定义分析 → 漏洞挖掘 → 固件分析 → 内核调试 → 贡献代码

10.3 社区与支持

  • IRC: #radare on irc.libera.chat
  • 邮件列表: radare-dev
  • GitHub Issues: bug 报告、功能请求
  • CTF Write-up: 大量实战案例可搜索

本文档基于 Radare2 5.8+ 编写,内容持续更新中。