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):
# 从软件源安装(版本可能稍旧)
sudo apt install radare2
# 如果需要最新版,可使用官方安装脚本
wget -qO- https://radare.org/install | sh
# 查看版本
r2 -v
# radare2 5.8.x ...
macOS(Homebrew):
brew install radare2
编译源码(推荐,获取最新特性):
# 克隆仓库
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:
# 拉取镜像
docker pull radare/radare2
# 运行
docker run -it --rm -v $(pwd):/pwd radare/radare2 /pwd/binary
2.2 安装验证
# 启动 r2
r2 -v
# 应输出类似:
# radare2 5.8.8 (git commit ...) Linux x86-64
# 测试反汇编一个简单文件
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。
常用配置:
# ~/.config/radare2/radare2rc
# 使用 Intel 语法
asm.syntax = intel
# 反汇编显示地址
asm.addr = true
# 高亮显示
scr.color = true
# 增量分析
anal.incremental = true
# 自动反分析超时限制(毫秒)
anal.timeout = 5000
# 可视化模式配色
theme = zenburn
加载配置:
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 启动方式
# 分析并打开二进制(自动分析)
r2 -A binary
# 只读打开(不修改原文件)
r2 -A -r binary
# 写模式打开(允许写入修改)
r2 -w binary
# 调试二进制
r2 -d binary
# 附加到进程
r2 -d <pid>
# 远程调试
r2 -d gdb://localhost:1234
3.3 帮助系统
在 r2 交互界面:
# 显示所有可用命令分类
?
# 搜索命令(正则)
? /seek
# 显示特定命令帮助
?i aaa
# 显示版本和支持架构
?v
3.4 三种操作模式
| 模式 | 进入方式 | 说明 |
|---|---|---|
| 命令模式 | 进入 r2 后默认 | 输入命令,回车执行 |
| 可视化 | V 或 VV |
图形化显示,箭头键导航 |
| 十六进制编辑 | Vp 或 p |
字节级修改 |
| 调试模式 | -d 启动或 ood 重新打开 |
设置断点、单步执行 |
| 面板模式 | V 再按 p |
多面板布局 |
3.5 基本导航
# 跳转到绝对地址
s 0x401000
s 0x0 # 跳转到文件开头
s $ # 跳转到文件结尾
# 相对跳转
s+ 0x100 # 向前移动 0x100 字节
s- 0x100 # 向后移动 0x100 字节
# 跳转到符号/标签
s main # 跳转到 main 函数
sym.main # 简写,等价于 s main
# 跳转到节(section)
s .text # 跳转到 .text 节起始
3.6 查看当前状态
# 打印当前 seek(地址)
s
# 打印文件信息
iI
# 打印各个 section 信息
iS
# 打印符号表
is
# 打印导入/导出表
ii
四、核心命令详解
4.1 自动分析:aaa 家族
aaa # 全自动分析全部函数
# 等同于:aa; aac; aar; aaa; afl
aa # 分析所有代码块
aaa # 自动分析全部(推荐,最常用)
aaad # 删除所有分析结果
aac # 分析函数调用信息
aaf # 分析标志信息
aap # 分析程序入口点
aar # 重新分析引用关系
aae[!] # 扩展自动分析(需要更多时间)
aacp # 分析函数参数类型
aan # 分析命名空间
aab # 分析基本块边界
实际工作流:
$ r2 -A binary # 启动时自动执行 aaa
# 或者打开后手动:
[0x00000000]> aaa
分析后可以:
- 自动识别所有函数边界
- 建立基本块
- 计算控制流图
- 建立交叉引用(XREF)
- 识别出字符串、常量
- 识别出导入函数
注意:
- 大文件分析可能需要几十秒到几分钟
- 如果只想快速打开,可以只做
aa不做aaa - 如果增量修改后,可用
aaa重新分析
4.2 搜索功能:z 家族
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 # 重新执行最后的搜索
搜索结果跳转:
# 搜索结果列表
z
# 跳转到下一个匹配
oz
# 跳转到上一个匹配
Oz
正则搜索:
z/[0-9]
# 正则搜索字节模式
十六字节搜索:
z: 48 8b 05 → 搜索 48 8b 05 三个字节
4.3 命令分隔符:\
\ 是 Radare2 特有的命令分隔符,你可以在一行写多个命令。
# 等价写法:
s main; pdf # 用分号分隔(Shell 风格)
s main\ pdf # 用反斜杠分隔(R2 风格)
| 分隔符 | 用法说明 |
|---|---|
; |
分号,Shell 风格,大部分情况可用 |
\ |
反斜杠,R2 原生风格,不受空格影响,建议用这个 |
常见组合:
s main\ pdf # 跳转到 main 然后打印反汇编
s 0x401000\ pd 10 # 跳转到地址然后反汇编 10 条指令
aaa\ afl # 全分析然后列出所有函数
4.4 打印函数反汇编:pdf / pdf @ addr
pdf # 打印当前地址所在函数的完整反汇编
pdf @ main # 直接打印 main 函数反汇编
pdf @ 0x401000 # 打印 0x401000 所在函数
pD # 打印当前块反汇编(不按函数)
pd 10 # 只打印 10 条指令
输出格式(Intel 语法):
; 输出示例:
; 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
...
常用参数:
pdfs # 显示指令偏移 + 字节 + 汇编
pdfj # 以 JSON 格式输出函数分析结果
pdd # 反汇编为 NASM 语法输出
4.5 打印 basic block 反汇编:pd
pd # 打印从当前位置开始的反汇编
pd N # 打印 N 条指令
pd 20 # 打印 20 条指令
pD # 直到当前块结束,一次性全部打印
pD 0x100 # 打印 0x100 字节
4.6 列出所有函数:afl
afl # 列出所有分析出的函数
输出示例:
0x00001129 123 bytes main
0x00001050 87 bytes __libc_start_main
0x00001200 45 bytes foo
过滤输出:
afl~main # 正则过滤包含 main 的函数
4.7 交叉引用:ax
axp # 打印谁调用这里(callers)
axa # 打印这里调用哪里(callees)
axr # 打印数据引用
示例:
[0x00001129]> axp
# 显示:
# 0x00001050: call sym.main
# 所以 __libc_start_main 调用了 main
4.8 标记标签:f
f # 列出所有标签
f name addr # 在 addr 处添加标签 name
f name 0x401000 # 在 0x401000 添加标签
f- name # 删除标签
f- 0x401000 # 删除地址处标签
示例:
f main 0x401129
4.9 地址信息:i
i # 显示文件头信息
iS # 显示所有 section
is # 显示所有符号
ii # 显示导入符号
ie # 显示导出符号
4.10 二进制输出:wtf / wo
# 写入修改后,保存到新文件
wtf output.bin # 写入整个文件
w 0x1234 0x90 # 在 0x1234 写入字节 0x90
wx 90 90 # 写入连续两个 0x90
wo output.bin # 写入当前块
五、调试模式全面指南
5.1 启动调试的三种方式
# ===== 方式 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 完整调试会话示例
# ===== 准备阶段:编译一个有漏洞的程序 =====
$ 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 使栈可执行(简化演示)
调试会话:
$ 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 调试中的内存查看技巧
# 打印栈指针(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 栈溢出漏洞调试实战
$ r2 -d ./vuln AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA # 40 个 A
在 r2 中:
[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(编译成二进制):
#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;
}
编译:
$ gcc -o crackme crackme.c
步骤 1:打开并分析
$ r2 -A ./crackme
步骤 2:查看文件信息
[0x00000000]> iI
# 架构: x86-64, 类型: ELF, 操作系统: linux, 位数: 64
# 入口点: 0x00401040 (entry0)
[0x00000000]> iS
# section 列表,确认 .text / .rodata / .data / .bss
步骤 3:列出函数,找到验证逻辑
[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 函数反汇编
; ┌─ 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! |
检查字符串引用:
[0x004011ad]> iz
# 0x00402008 string "Crack!"
构造密码(其中一个解):
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!
验证运行:
$ echo "R2ABCrack!" | ./crackme
# Enter password: Correct! Flag{R2ABCrack!}
成功! 我们通过反汇编完全逆向出了密码规则。
或者——打补丁绕过(不需要找密码):
[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
验证:
$ chmod +x crackme_patched
$ echo "anything" | ./crackme_patched
# Enter password: Correct! Flag{anything}
无论输入什么都通过!我们成功 patch 了验证逻辑。
6.2 案例:从 .rodata 提取隐藏字符串
有时候密码/flag 不是逐字节比较,而是存储在只读数据段中。
$ r2 -A ./another_crackme
# 查看所有字符串(.rodata 段)
[0x00000000]> iz
# 或者在整个二进制中搜索
[0x00000000]> z/ flag
# 0x004020a0 hit0_0 "flag{hidden_in_rodata}"
# 直接得到 flag,不需要分析反汇编!
6.3 案例:分析静态链接的混淆代码
当二进制被 strip(去掉符号),所有函数变成 fcn.地址。
$ 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 系列配置命令
# 查看所有配置变量
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 启动时会读取以下位置的配置(优先级从低到高):
/etc/radare2rc~/.config/radare2/radare2rc./radare2rc(当前目录)
示例配置:
# ~/.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 主题配色
# 列出可用主题
eco
# 切换主题
eco zenburn
eco dark
eco solarized
# 自定义颜色
ec rgb:0xff0000 ; 主颜色
ec rgb:0x00ff00 ; 反汇编颜色
八、r2pipe 自动化脚本
8.1 Python r2pipe 基础
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:批量分析多个二进制
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:自动提取字符串引用
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:自动打补丁绕过验证
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),可以识别静态链接的标准库函数。
# 加载 sig 文件(预定义签名库)
zfs /path/to/libc.sig
# 应用签名
za
# 查看识别出的库函数
afl ~ sym.imp.
# 创建自己的签名
zf ./my_lib.sig 0x401000 0x402000 # 从 0x401000 到 0x402000 创建签名
9.2 图分析:控制流图 / 调用图
# 生成当前函数的控制流图
agc # 函数控制流图(ASCII 显示)
agc > func.dot # 保存为 DOT 格式(可用 graphviz 可视化)
agj # JSON 格式输出图结构
# 整个程序的函数调用图
agc
# 或:
axf > callgraph.dot
用 graphviz 可视化:
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 最佳实践清单
- 打开文件前:先用
file/readelf -h/rabin2 -I了解文件类型和架构 - 分析前:用
r2 -A自动分析,或打开后手动aaa - 大文件:用
aa不做完整引用分析,节省时间 - 调试前:先静态分析找到关键函数,再用断点精准调试
- 修改后:永远用
wtf保存到新文件,不要覆盖原始文件 - 找密码:先用
iz/z/搜字符串,找不到再分析反汇编 - 混淆代码:用
aaa!强制重新分析,可能需要afb手动标记函数边界 - 脚本化:重复性任务一律用 r2pipe python 脚本自动化
- 注释:分析过程中用
f name addr给关键地址加标签,方便后续回顾 - 保存项目:分析大量文件时,可以保存会话避免重复分析:
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 学习路径
入门: r2 -A binary → afl → pdf @ main → z/ string → 基本操作
进阶: 调试模式 (-d) → 断点 → 寄存器 → 栈回溯 → 动态分析
高级: r2pipe 脚本 → 自动化分析 → 反编译 → 混淆分析 → CTF
专家: 自定义分析 → 漏洞挖掘 → 固件分析 → 内核调试 → 贡献代码
10.3 社区与支持
- IRC:
#radareonirc.libera.chat - 邮件列表: radare-dev
- GitHub Issues: bug 报告、功能请求
- CTF Write-up: 大量实战案例可搜索
本文档基于 Radare2 5.8+ 编写,内容持续更新中。