Imported from muort521/R2AIBridge (SKILL.md). Install upstream with npx skills add muort521/R2AIBridge. Copyright stays with the author.

Radare2 MCP 二进制分析技能

基于 Radare2 MCP 服务对二进制文件进行深度逆向分析并生成结构化报告。

核心原则

本技能不预设固定分析内容，而是根据用户的具体分析需求动态执行分析。

用户可以指定：

• 二进制文件路径
• 分析目标（函数、字符串、交叉引用、反编译等）
• 分析深度（基础信息、函数列表、反编译伪代码、完整逆向报告）
• 特定地址范围或函数名过滤

分析决策框架

用户意图
├─ "这个程序做了什么"        → 架构概览路径（T1）
├─ "找到XXX函数在哪"         → 函数定位路径（T2）
├─ "有没有安全隐患"          → 安全审计路径（T4）
├─ "网络请求/URL在哪"         → 网络追踪路径（T3）
├─ "这个函数谁调用了"         → 调用链追踪路径（T5）
├─ "这段汇编什么意思"         → 反编译/反汇编路径（T6）
├─ "有没有加壳/混淆"          → 保护机制识别路径（T7）
└─ 模糊意图                  → 先获取文件信息建立全局认知，再追问细化

关键判断： 用户说"分析"时往往隐含了"理解逻辑"或"找到漏洞"的意图。分析过程中应主动记录关键发现，为后续深入分析积累素材。

第一部分：快速入门

1.1 核心流程

必须先调用 r2_open_file → 获取 session_id → 后续所有调用都需要此 ID

1.2 分析策略选择器

1.3 常见陷阱

#1 大文件处理：

OK:   r2_open_file(file_path="large.bin", auto_analyze=false)  (大文件 >10MB 先不开分析)
OK:   后续手动调用 r2_analyze_target(strategy="basic")         (按需分析)
BAD:  r2_open_file(file_path="large.bin", auto_analyze=true)    (大文件可能超时)

#2 地址格式：

OK:   address="0x401000"        (十六进制，带 0x 前缀)
OK:   address="sym.main"        (符号名)
OK:   address="main"           (函数名)
BAD:  address="401000"          (缺少 0x 前缀可能被误解)

#3 会话管理：

OK:   打开文件 → 分析 → 关闭会话（释放资源）
BAD:  打开多个文件不关闭（资源泄漏）
BAD:  关闭会话后继续使用 session_id

#4 分析策略选择：

OK:   先 basic(aa) → 再按需 blocks/calls/refs
OK:   小文件直接 full(aaa)
BAD:  大文件直接 full(aaa)（极耗时）

#5 函数截断问题：

症状:  反编译结果不完整，函数看起来被截断
修复:  r2_analyze_target(strategy="blocks") 修复基本块结构
      r2_config_manager(action="set", key="anal.hasnext", value="true")

#6 字符串搜索不到：

症状:  r2_list_strings 找不到目标字符串
修复:  r2_config_manager(action="set", key="bin.str.min", value="3") 降低最小长度
      r2_list_strings(mode="all") 搜索所有段（包括代码段中的字符串）

第二部分：工具规范

2.1 r2_open_file

打开二进制文件并创建分析会话。必须第一个调用。 返回 session_id，后续所有工具都需要此 ID。

参数：

返回字段：

注意事项：

• 大文件（>10MB）强烈建议 auto_analyze=false，避免超时
• 如需深度分析，可后续调用 r2_analyze_file 或 r2_analyze_target

2.2 r2_get_info

获取二进制文件的详细信息。打开文件后首先调用此工具了解文件基本信息。

参数：

返回关键信息：

用途： 根据文件信息决定后续分析策略（如 ARM 代码需要不同的分析思路）。

2.3 r2_list_functions

列出二进制文件中已识别的函数。使用 afl 命令。

参数：

返回信息：

过滤技巧：

2.4 r2_list_strings

列出二进制文件中的字符串。通过配置 bin.str.min 进行底层过滤。

参数：

模式说明：

使用技巧：

• 如果找不到目标字符串，尝试降低 min_length 到 3-4
• 使用 mode="all" 搜索代码段中嵌入的字符串
• 字符串结果可用于定位功能代码（通过交叉引用）

2.5 r2_decompile_function

反编译指定地址的函数为伪代码。使用 pdc 命令。

参数：

输出： 类 C 语言的伪代码，比汇编更易理解。

最佳实践：

• 先用 r2_list_functions 找到目标函数地址
• 反编译前确保已执行足够深度的分析（至少 basic）
• 如果伪代码不完整，尝试 r2_analyze_target(strategy="blocks")

2.6 r2_disassemble

反汇编指定地址的代码。使用 pd 命令。

参数：

用途：

• 查看精确的汇编指令
• 理解编译器生成的具体代码
• 验证反编译结果的准确性
• 分析底层漏洞（如缓冲区溢出）

2.7 r2_get_xrefs

获取指定地址/函数的交叉引用。

参数：

方向说明：

使用场景：

• 找到某个函数的所有调用者：direction="to"
• 理解某个函数内部调用了哪些子函数：direction="from"
• 追踪字符串在哪里被使用：对字符串地址使用 direction="to"

2.8 r2_analyze_target

执行特定的 Radare2 递归分析策略。

参数：

策略说明：

策略选择建议：

小文件 (<5MB):   basic → 按需 calls/refs → 必要时 full
中等文件 (5-50MB): basic → 按需 calls/refs (避免 full)
大文件 (>50MB):   basic → 精确分析特定地址 (避免全局分析)

2.9 r2_run_command

在指定会话中执行任意 Radare2 命令。

参数：

常用命令参考：

2.10 r2_config_manager

管理 Radare2 的分析与显示配置。

参数：

关键配置参考：

2.11 r2_analysis_hints

管理分析提示，用于修正 R2 的分析错误或优化显示。

参数：

操作类型：

使用场景：

• 代码被错误识别为数据：设置正确的架构和位数
• 立即数难以理解：切换显示进制（十进制/IP地址）
• 间接跳转目标错误：手动指定跳转目标

2.12 r2_manage_xrefs

管理代码和数据的交叉引用。

参数：

操作类型：

2.13 r2_close_session

关闭 Radare2 会话，释放资源。

参数：

最佳实践：

• 分析完成后及时关闭会话
• 长时间不用的会话也应关闭
• 不要在关闭后继续使用该 session_id

第三部分：文件类型与场景

3.1 支持的文件类型

3.2 分析场景速查

功能分析：

安全分析：

逆向工程：

3.3 搜索模式速查

3.4 进阶分析策略

锚点扩散法 — 从已知信息出发，逐步扩大分析范围：

1. r2_list_strings(min_length=5)  → 找到关键字符串（如 URL、API 路径）
2. r2_get_xrefs(address=<字符串地址>, direction="to")  → 找到引用此字符串的函数
3. r2_decompile_function(address=<引用函数>)  → 理解使用逻辑
4. r2_get_xrefs(address=<引用函数>, direction="to")  → 找到谁调用了这个函数
5. 重复步骤 3-4 扩大分析范围

函数追踪法 — 理解程序的执行流程：

1. r2_get_info()  → 获取入口点地址
2. r2_disassemble(address=<入口点>)  → 查看入口代码
3. r2_get_xrefs(address=<被调用函数>, direction="from")  → 查看入口调用了哪些函数
4. r2_decompile_function(address=<关键子函数>)  → 理解子函数逻辑
5. 递归追踪每个子函数的内部调用

导入函数分析法 — 通过库调用推断程序功能：

1. r2_list_functions(filter="sym.imp.")  → 列出所有导入函数
2. 按功能分类导入函数：
   - 网络: connect, send, recv, socket, getaddrinfo
   - 文件: fopen, fread, fwrite, open, close
   - 加密: AES_encrypt, RSA_public_encrypt, MD5
   - 内存: malloc, free, memcpy, memset
   - 线程: pthread_create, pthread_mutex_lock
3. 对感兴趣的导入函数使用 r2_get_xrefs(direction="to")  → 找到使用位置
4. 分析使用导入函数的上下文

第四部分：工作流模板

T1: 二进制文件概览

1. r2_open_file(file_path="target", auto_analyze=true)
   → session_id

2. r2_get_info(session_id, detailed=true)
   → 架构、平台、文件类型、入口点、段信息

3. r2_list_functions(session_id, filter="sym.imp.", limit=50)
   → 导入函数列表（了解使用了哪些库）

4. r2_list_functions(session_id, limit=100)
   → 所有函数概览（了解程序规模和结构）

5. r2_list_strings(session_id, min_length=8)
   → 关键字符串（URL、版本信息、错误消息）

6. r2_disassemble(session_id, address=<入口点>, lines=30)
   → 入口点代码，了解程序启动流程

7. r2_close_session(session_id)

T2: 定位特定功能

1. r2_open_file(file_path="target", auto_analyze=true)
   → session_id

2. r2_list_strings(session_id, min_length=5)
   → 搜索与目标功能相关的字符串

3. r2_get_xrefs(session_id, address=<相关字符串地址>, direction="to")
   → 找到引用这些字符串的函数

4. r2_list_functions(session_id, filter="<关键词>")
   → 按名称搜索相关函数

5. r2_decompile_function(session_id, address=<目标函数>)
   → 反编译理解函数逻辑

6. r2_get_xrefs(session_id, address=<目标函数>, direction="to")
   → 找到谁调用了这个函数

7. r2_close_session(session_id)

T3: 网络通信分析

1. r2_open_file(file_path="target", auto_analyze=true)
   → session_id

2. r2_list_strings(session_id, min_length=8)
   → 提取所有 URL、域名、IP 地址

3. r2_list_functions(session_id, filter="sym.imp.")
   → 查找网络相关导入: connect, send, recv, socket, gethostbyname, getaddrinfo

4. r2_get_xrefs(session_id, address=<网络函数>, direction="to")
   → 找到网络调用的位置

5. r2_decompile_function(session_id, address=<网络调用所在函数>)
   → 理解网络通信逻辑

6. r2_get_xrefs(session_id, address=<网络处理函数>, direction="to")
   → 追踪完整的网络调用链

7. r2_close_session(session_id)

T4: 安全漏洞分析

1. r2_open_file(file_path="target", auto_analyze=true)
   → session_id

2. r2_list_functions(session_id, filter="sym.imp.")
   → 查找危险函数: strcpy, strcat, sprintf, gets, system, exec

3. r2_get_xrefs(session_id, address=<危险函数>, direction="to")
   → 找到危险函数的所有调用位置

4. r2_disassemble(session_id, address=<调用位置>, lines=20)
   → 检查缓冲区大小和输入验证

5. r2_list_strings(session_id, min_length=5)
   → 查找硬编码密钥、密码、token

6. r2_list_functions(session_id, filter="ptrace|debug|trap")
   → 查找反调试机制

7. r2_close_session(session_id)

T5: 调用链追踪

1. r2_open_file(file_path="target", auto_analyze=true)
   → session_id

2. r2_analyze_target(session_id, strategy="calls")
   → 确保所有函数调用关系被分析

3. r2_get_xrefs(session_id, address=<目标函数>, direction="to")
   → 找到所有直接调用者

4. 对每个调用者递归执行 r2_get_xrefs(direction="to")
   → 构建完整的调用树

5. r2_get_xrefs(session_id, address=<目标函数>, direction="from")
   → 理解目标函数内部调用了什么

6. r2_decompile_function(session_id, address=<调用链中的关键函数>)
   → 反编译理解每层逻辑

7. r2_close_session(session_id)

T6: 反编译与伪代码分析

1. r2_open_file(file_path="target", auto_analyze=true)
   → session_id

2. r2_analyze_target(session_id, strategy="basic")
   → 确保基础分析完成

3. r2_list_functions(session_id, filter="<目标函数名>")
   → 获取目标函数地址

4. r2_decompile_function(session_id, address=<目标函数地址>)
   → 获取伪代码

5. 如果伪代码不完整:
   r2_analyze_target(session_id, strategy="blocks")
   r2_config_manager(session_id, action="set", key="anal.hasnext", value="true")
   r2_decompile_function(session_id, address=<目标函数地址>)
   → 重新反编译

6. r2_disassemble(session_id, address=<目标函数地址>, lines=50)
   → 对比汇编验证伪代码准确性

7. r2_close_session(session_id)

T7: 加壳/保护机制识别

1. r2_open_file(file_path="target", auto_analyze=false)
   → session_id（大文件先不开分析）

2. r2_get_info(session_id, detailed=true)
   → 查看段信息、入口点

3. r2_list_functions(session_id, limit=20)
   → 查看函数数量（加壳程序通常只有少量函数）

4. r2_list_strings(session_id, min_length=4)
   → 查看字符串（加壳程序字符串很少）

5. r2_disassemble(session_id, address=<入口点>, lines=50)
   → 查看入口代码（加壳程序入口通常是解壳代码）

判断标准:
- 函数数量极少（<10）且文件较大 → 可能加壳
- 入口代码大量 push/pop 和循环 → 可能是解壳代码
- 段名异常（如 .upx0, .vmp0）→ 已知壳
- 字符串极少 → 可能被加密

6. r2_close_session(session_id)

第五部分：高级技巧

5.1 分析策略优化

按文件大小选择策略：

分析深度递进：

Level 0: r2_get_info                    → 文件基本信息
Level 1: r2_list_functions + strings    → 函数和字符串概览
Level 2: r2_analyze_target(basic)        → 基础分析
Level 3: r2_analyze_target(calls/refs)  → 调用和数据引用分析
Level 4: r2_decompile_function          → 反编译伪代码
Level 5: r2_analyze_target(full)        → 全量深度分析（谨慎使用）

5.2 常见问题修复

函数截断：

症状: 反编译结果不完整，函数提前结束
原因: R2 未正确识别函数边界
修复:
  1. r2_analyze_target(strategy="blocks", address=<截断函数>)
  2. r2_config_manager(action="set", key="anal.hasnext", value="true")
  3. r2_config_manager(action="set", key="anal.jmp.after", value="true")
  4. 重新反编译

间接跳转未解析：

症状: 反编译中出现 "jump [未知地址]" 或 switch 语句不完整
修复:
  1. r2_analyze_target(strategy="pointers", address=<跳转表地址>)
  2. r2_config_manager(action="set", key="anal.jmp.tbl", value="true")
  3. 或使用 r2_analysis_hints(action="override_jump") 手动指定跳转目标

代码被识别为数据：

症状: 应该是代码的区域显示为数据字节
修复:
  1. r2_analysis_hints(action="set_arch", value="<正确架构>")
  2. r2_analysis_hints(action="set_bits", value="<正确位数>")
  3. r2_run_command(command="af @ <地址>") 重新分析为函数

字符串引用缺失：

症状: 知道字符串存在但找不到引用
修复:
  1. r2_config_manager(action="set", key="anal.strings", value="true")
  2. r2_analyze_target(strategy="refs")
  3. r2_manage_xrefs(action="add_string", target_address=<字符串地址>)

5.3 架构特定技巧

ARM/AArch64：

x86/x64：

5.4 性能优化

分析优先级（最快获得结果的路径）：

性能规则：

5.5 与其他工具配合

R2-MCP + MT-MCP 联合分析（Android SO 库）：

场景: 分析 Android 应用中的 native 库 (.so 文件)

1. 先用 MT-MCP (mt-mcp-apk-analyzer) 分析 APK:
   - 搜索 System.loadLibrary 找到加载了哪些 SO 库
   - 提取 SO 文件路径

2. 再用 R2-MCP 分析 SO 文件:
   - r2_open_file 打开 SO 文件
   - r2_get_info 确认架构（arm/arm64）
   - r2_list_functions(filter="Java_") 找 JNI 函数
   - r2_decompile_function 分析 JNI 函数逻辑

R2-MCP + Ghidra/IDA 对比验证：

1. R2-MCP 快速分析 → 获取初步结果
2. Ghidra/IDA 深度分析 → 验证和补充
3. 对比两者反编译结果 → 确保分析准确性

第七部分：eDBG 动态调试

7.1 概述

eDBG 是基于 eBPF 的 Android 动态调试器，与传统 ptrace 调试器不同，eDBG 不直接附加进程，具有抗干扰和反检测特性，几乎无法被目标程序感知。

特点：

• 基于 eBPF 实现，占用极小
• 用户态硬件断点，无法被检测
• 支持 uprobes 断点
• MCP 协议接口，便于 AI 集成

连接地址： http://127.0.0.1:19810/mcp

7.2 核心流程

必须先调用 attach 或 run → 获取目标进程 → 设置断点 → 执行调试

7.3 分析决策框架

用户意图
├─ "程序跑起来了，想下断点"      → attach/run → break
├─ "想看某地址的内存数据"         → examine
├─ "想修改某个变量的值"           → watch → write_memory
├─ "想追踪函数调用链"             → break → continue → backtrace
├─ "程序crash了，想看堆栈"       → attach → backtrace
├─ "想看寄存器状态"              → registers
└─ "这个函数内部怎么执行的"       → break → step/next

7.4 与 R2 配合使用

静态分析和动态调试可以形成互补的工作流：

静态分析 (R2 MCP:5050)           动态调试 (eDBG MCP:19810)
         │                                    │
         ▼                                    ▼
   r2_open_file                            attach/run
   r2_list_functions                         │
   r2_decompile_function                     ▼
         │                              break/continue
         │                                    │
         ▼                                    ▼
   定位关键函数地址 ──────────────────→ 在目标地址下断点
                                         │
                                         ▼
                                   step/next/examine
                                         │
                                         ▼
                                    运行时验证理解

典型工作流：

1. R2 静态分析 → 找到可疑函数地址 0x401000
2. eDBG 附加进程 → 在 0x401000 下断点
3. 触发断点 → 单步执行观察程序行为
4. examine 查看内存数据
5. registers 查看寄存器状态
6. backtrace 查看调用链

7.5 断点类型选择

7.6 工具详解

attach

附加到运行中的进程。

参数：

返回： 目标信息，包含 pid、name 等

run

以调试模式启动程序。

参数：

break / hbreak / watch

设置断点。

参数：

examine

查看内存内容。

参数：

registers

查看所有寄存器状态。

backtrace

查看栈回溯信息（调用链）。

list

反汇编查看代码。

参数：

continue / step / next / finish

执行控制。

7.7 注意事项

eDBG 要求：

• ARM64 Android 设备
• Root 权限（推荐 KernelSU）
• 内核版本 5.10+（eBPF 支持）

断点地址格式：

OK:   target="0x401000"    (十六进制地址)
OK:   target="main"        (函数名)
OK:   target="0x401000+10" (偏移量)
BAD:  target="401000"       (缺少 0x 前缀)

硬件断点限制：

• 通常最多 4-8 个硬件断点
• 超出限制会报错
• 敏感调试用 hbreak

uplate 模式：

attach 时如果目标进程使用了 anti-debug 技术，可以尝试 --uprobe 模式，它使用 uprobes 替代 ptrace。

7.8 常见问题

Q: attach 失败，显示 "No such process"

可能是进程名拼写错误，或进程已退出
解决：确认进程存在，使用正确的大小写

Q: break 设置成功但未触发

可能是地址错误或内存权限问题
解决：先用 examine 确认地址可访问

Q: step 卡住不动

可能是进入了内核态或等待 I/O
解决：尝试 next 跳过，或用 continue

Q: 设备不支持 eDBG

eDBG 需要 eBPF 支持
检查：内核版本 >= 5.10，KernelSU 已安装

第八部分：输出规范

6.1 报告模板

报告文件命名：{fileName}_{分析类型}报告.md

# {文件名} - {分析类型}分析报告

## 基本信息

| 项目 | 值 |
|------|------|
| 文件名 | {fileName} |
| 文件大小 | {文件大小} |
| 架构 | {arch} ({bits}位) |
| 平台 | {os} |
| 文件类型 | {type} |
| 端序 | {endian} |
| 入口点 | {entrypoint} |

## 分析配置

| 配置项 | 值 |
|--------|-----|
| 分析类型 | {分析类型} |
| 分析策略 | {策略列表} |
| 分析时间 | {时间戳} |

## 分析结果

### 1. {结果分类1}

{详细内容，包含函数地址、伪代码、交叉引用等}

### 2. {结果分类2}

{详细内容}

...

## 关键代码

{可选：反编译伪代码或关键汇编片段}

## 总结

{分析总结和建议}

---

*报告生成时间: {时间}*
*分析工具: R2-MCP Binary Analyzer*

6.2 报告撰写心法

一份好的逆向分析报告不只是罗列函数和字符串，而是让读者看完就知道"程序做了什么、有没有风险、关键逻辑在哪"。

报告质量分级：

每个分析发现的必备要素：

1. 定位信息 — 函数地址、函数名、关键字符串地址
2. 代码上下文 — 反编译伪代码或关键汇编片段
3. 调用关系 — 谁调用了这个函数、这个函数调用了谁
4. 影响分析 — 这个发现意味着什么，有什么安全影响
5. 建议 — 后续分析方向或修复建议

代码片段呈现规范： 用注释标注关键行：

// 伪代码示例
void check_password(char *input) {
    char buf[64];
    strcpy(buf, input);              // ← [危险] 无边界检查的 strcpy
    if (strcmp(buf, "admin123") == 0) {  // ← [硬编码] 密码硬编码
        grant_access();
    }
}

6.3 解决方案建议

重要原则：分析报告必须包含解决方案建议部分，指导用户如何处理分析结果。

工具选择原则：

R2-MCP 操作建议：

常见分析模式：

解决方案模板：

## 解决方案建议

### 推荐工具

本分析结果推荐使用 **R2-MCP** 进行进一步分析，配合 **Ghidra** 验证。

### 后续分析步骤

1. **深入分析目标函数**
   - 函数地址: 0x{address}
   - 函数名: {function_name}

2. **R2-MCP 操作**
   - r2_decompile_function(address="0x{address}")
   - r2_get_xrefs(address="0x{address}", direction="to")
   - r2_get_xrefs(address="0x{address}", direction="from")

3. **验证分析**
   - 使用 Ghidra 打开文件对比反编译结果
   - 使用 GDB 动态调试验证执行流

### 注意事项

- 大文件分析时注意内存使用
- 分析完成后及时关闭会话
- 反编译结果可能与源代码有差异（编译器优化）

### 备选方案

如果 R2-MCP 无法满足需求，推荐使用:
- Ghidra（免费，支持反编译和脚本）
- IDA Pro（专业级，插件生态丰富）
- Binary Ninja（现代化 UI，API 友好）

附录

A. Radare2 常用命令速查

信息类：

分析类：

反汇编/反编译类：

交叉引用类：

搜索类：

B. 常见文件类型特征

ELF 文件：

PE 文件：

DEX 文件：

C. 注意事项

1. 文件路径: 使用完整的绝对路径
2. 大文件处理: >10MB 的文件建议 auto_analyze=false
3. 会话管理: 分析完成后及时关闭会话释放资源
4. 分析策略: 优先使用轻量级策略，避免不必要的 full 分析
5. 结果验证: 重要发现建议用多种方式交叉验证
6. 敏感信息: 在报告中适当脱敏
7. MCP 服务器地址: 以实际连接成功的 MCP 配置为准
8. 架构识别: 分析前先确认文件架构，避免错误分析