Capstone是一个反汇编框架，提供了一个简单、轻量级的API接口，可透明地处理大多数流行的指令体系，包括x86/x86-64、ARM及MIPS等。Capstone支持C/C++和Python，并且可以在很多操作系统上运行。
python安装capstone: pip3 install capstone，之后启动python解释器就可以其中使用该模块。
Linux安装libcapstone: $ sudo apt-get install libcapstone3
安装开发包: $ sudo apt-get install libcapstone-dev
Capstone线性反汇编
Capstone接收一个含有字节块的缓冲区作为输入，并输出这些字节的反汇编指令，其最基本的使用方法是提供一个包含字节块的缓冲区(这些字节都来自二进制文件的.text节)。然后将这些字节序列线性反汇编为人类可读的形式，或是指令助记符形式。除了一些初始化和输出解析的代码之外，Capstone通过调用cs_disasm函数来实现上述功能。
下面实现一个简单的线性反汇编器
此处要用到上篇文章中的头文件和相关函数定义: C++ 基于libbfd实现二进制加载器
#include <stdio.h>
#include <string>
#include <capstone/capstone.h>
#include "loader.h"
int disasm(Binary *bin);
int main(int argc,char *argv[])
{
Binary bin;
std::string fname;
if (argc < 2) {
printf("Usage: %s <binary>\n",argv[0]);
return 1;
}
fname.assign(argv[1]); // 命令行参数赋值
// 加载二进制文件
if (load_binary(fname,&bin,Binary::BIN_TYPE_AUTO) < 0) {
return 1;
}
// 反汇编
if (disasm(&bin) < 0) {
return 1;
}
// 释放
unload_binary(&bin);
return 0;
}
int disasm(Binary *bin)
{
csh dis;
cs_insn *insns;
Section *text;
size_t n;
// 获取二进制文件的节
text = bin->get_text_section();
if (!text) {
fprintf(stderr,"Nothing to disassemble\n");
return 0;
}
// 初始化capstone
if (cs_open(CS_ARCH_X86,CS_MODE_64,&dis) != CS_ERR_OK) {
fprintf(stderr,"Failed to open Capstone\n");
return -1;
}
// 反汇编 将结果存放在insns结构体 返回
n = cs_disasm(dis,text->bytes,text->size,text->vma,0,&insns);
if (n <= 0) {
fprintf(stderr,"Disassembly error: %s\n",
cs_strerror(cs_errno(dis)));
return -1;
}
// 循环遍历insns
for (size_t i=0;i<n;i++) {
printf("0x%016jx: ",insns[i].address);
for (size_t j=0;j<16;j++) {
if (j < insns[i].size)
printf("%02x ",insns[i].bytes[j]);
else
printf(" ");
}
printf("%-12s %s\n",insns[i].mnemonic,insns[i].op_str);
}
cs_free(insns,n); // 释放空间
cs_close(&dis);
return 0;
}
首先使用LoadBinary函数将二进制程序加载进Binary对象，然后传递给disasm函数。在disasm函数中调用get_text_section首先获取.text节的数据，然后使用cs_open函数初始化capstone，该函数接收3个参数: 硬件体系结构、硬件模式和一个csh结构的指针，csh类型的变量作为一个句柄存在，将在capstone中的多个API函数中使用。
向cs_disasm函数传递csh句柄，作为第一个参数，第二个参数是缓冲区，即上面得到.text节内容(被加载到Section对象中)，第三个参数是传入的缓冲区的字节数，第四个参数是第一条指令的地址，最后一个参数是cs_insn类型的变量，将存放反汇编后的结果。
该结构定义如下:
// Detail information of disassembled instruction
typedef struct cs_insn {
// Instruction ID (basically a numeric ID for the instruction mnemonic)
// Find the instruction id in the '[ARCH]_insn' enum in the header file
// of corresponding architecture, such as 'arm_insn' in arm.h for ARM,
// 'x86_insn' in x86.h for X86, etc...
// This information is available even when CS_OPT_DETAIL = CS_OPT_OFF
// NOTE: in Skipdata mode, "data" instruction has 0 for this id field.
unsigned int id;
// Address (EIP) of this instruction
// This information is available even when CS_OPT_DETAIL = CS_OPT_OFF
uint64_t address;
// Size of this instruction
// This information is available even when CS_OPT_DETAIL = CS_OPT_OFF
uint16_t size;
// Machine bytes of this instruction, with number of bytes indicated by @size above
// This information is available even when CS_OPT_DETAIL = CS_OPT_OFF
uint8_t bytes[16];
// Ascii text of instruction mnemonic
// This information is available even when CS_OPT_DETAIL = CS_OPT_OFF
char mnemonic[32];
// Ascii text of instruction operands
// This information is available even when CS_OPT_DETAIL = CS_OPT_OFF
char op_str[160];
// Pointer to cs_detail.
// NOTE: detail pointer is only valid when both requirements below are met:
// (1) CS_OP_DETAIL = CS_OPT_ON
// (2) Engine is not in Skipdata mode (CS_OP_SKIPDATA option set to CS_OPT_ON)
//
// NOTE 2: when in Skipdata mode, or when detail mode is OFF, even if this pointer
// is not NULL, its content is still irrelevant.
cs_detail *detail;
} cs_insn;
该结构体中，id字段是指令类型(和硬件体系相关)的唯一标识符，可用于检查正在处理的指令类型，而无须与指令助记符进行字符串比较。
x86平台下相关的值如下:
// X86 instructions
typedef enum x86_insn {
X86_INS_INVALID = 0,
X86_INS_AAA,
X86_INS_AAD,
X86_INS_AAM,
X86_INS_AAS,
X86_INS_FABS,
X86_INS_ADC,
X86_INS_ADCX,
X86_INS_ADD,
X86_INS_ADDPD,
X86_INS_ADDPS,
X86_INS_ADDSD,
X86_INS_ADDSS,
X86_INS_ADDSUBPD,
.....
X86_GRP_VLX,
X86_GRP_SMAP,
X86_GRP_NOVLX,
X86_GRP_ENDING
} x86_insn_group;
address、size及bytes字段表示指令的地址、字节数及字节数据。
mnemonic是指令可读形式的指令字符串(不含操作数)，而op_str是指令操作数的可读表示，detail包含了更详细的信息，如下是cs_insn的定义:
// NOTE: All information in cs_detail is only available when CS_OPT_DETAIL = CS_OPT_ON
typedef struct cs_detail {
uint8_t regs_read[12]; // list of implicit registers read by this insn
uint8_t regs_read_count; // number of implicit registers read by this insn
uint8_t regs_write[20]; // list of implicit registers modified by this insn
uint8_t regs_write_count; // number of implicit registers modified by this insn
uint8_t groups[8]; // list of group this instruction belong to
uint8_t groups_count; // number of groups this insn belongs to
// Architecture-specific instruction info
union {
cs_x86 x86; // X86 architecture, including 16-bit, 32-bit & 64-bit mode
cs_arm64 arm64; // ARM64 architecture (aka AArch64)
cs_arm arm; // ARM architecture (including Thumb/Thumb2)
cs_mips mips; // MIPS architecture
cs_ppc ppc; // PowerPC architecture
cs_sparc sparc; // Sparc architecture
cs_sysz sysz; // SystemZ architecture
cs_xcore xcore; // XCore architecture
};
} cs_detail;
只有开启了capstone的详细反汇编模式，才会设置detail指针。
如果cs_disasm函数执行成功，则返回反汇编指令的数量，如果函数执行失败，则返回0。
cs_error函数可用于检查错误，cs_strerror可将cs_err值转换为字符串来描述错误，之后在循环中不断取出数据，按照地址 机器码 指令字符串的格式打印，循环之后调用cs_free函数释放内存，调用cs_close关闭。
终端执行命令编译: g++ -I . loader.cpp liner.cpp -o liner -lbfd -lcapstone
运行测试，反汇编一个hello world程序
$ ./liner ./hello
0x0000000000401040: 31 ed xor ebp, ebp
0x0000000000401042: 49 89 d1 mov r9, rdx
0x0000000000401045: 5e pop rsi
0x0000000000401046: 48 89 e2 mov rdx, rsp
0x0000000000401049: 48 83 e4 f0 and rsp, 0xfffffffffffffff0
0x000000000040104d: 50 push rax
0x000000000040104e: 54 push rsp
0x000000000040104f: 49 c7 c0 a0 11 40 00 mov r8, 0x4011a0
0x0000000000401056: 48 c7 c1 40 11 40 00 mov rcx, 0x401140
0x000000000040105d: 48 c7 c7 22 11 40 00 mov rdi, 0x401122
0x0000000000401064: ff 15 86 2f 00 00 call qword ptr [rip + 0x2f86]
0x000000000040106a: f4 hlt
0x000000000040106b: 0f 1f 44 00 00 nop dword ptr [rax + rax]
0x0000000000401070: c3 ret
.....
Capstone递归反汇编
线性反汇编只能显示基本的信息，但缺少更为详细的信息(指令类型、操作数类型等)，想要查看详细的信息只能在Capstone的详细反汇编模式中找到。递归反汇编从已知入口点开始分析，如二进制文件的主入口点或函数符号，并从此处跟踪控制流指令，而线性反汇编器会盲目地按顺序反汇编所有代码。与线性反汇编器相比，递归反汇编器不易被代码中的数据干扰，但可能会错过那些只能通过间接跳转才能到达的指令，这些指令不能被静态解析。
示例代码:
#include <stdio.h>
#include <queue>
#include <map>
#include <string>
#include <capstone/capstone.h>
#include "loader.h"
int disasm(Binary *bin); // 反汇编
void print_ins(cs_insn *ins); // 打印结构
bool is_cs_cflow_group(uint8_t g);
bool is_cs_cflow_ins(cs_insn *ins);
bool is_cs_unconditional_cflow_ins(cs_insn *ins);
uint64_t get_cs_ins_immediate_target(cs_insn *ins);
int main(int argc,char* argv[])
{
Binary bin;
std::string fname;
if (argc < 2) {
printf("Usage: %s <binary>\n");
return 1;
}
fname.assign(argv[1]); // 赋值给fname
// 加载二进制文件
if (load_binary(fname,&bin,Binary::BIN_TYPE_AUTO) < 0) {
return 1;
}
if (disasm(&bin) < 0) {
return 1;
}
// 释放
unload_binary(&bin);
return 0;
}
int disasm(Binary *bin)
{
csh dis;
cs_insn *cs_ins;
Section* text;
size_t n;
const uint8_t *pc;
uint64_t addr,offset,target;
std::queue<uint64_t> Q;
std::map<uint64_t, bool> seen;
text = bin->get_text_section();
if (!text) {
fprintf(stderr,"Nothing to disassemble\n");
return 0;
}
if (cs_open(CS_ARCH_X86,CS_MODE_64,&dis)!=CS_ERR_OK) {
fprintf(stderr,"Failed to open Capstone\n");
return -1;
}
cs_option(dis,CS_OPT_DETAIL,CS_OPT_ON);
cs_ins = cs_malloc(dis); // 分配缓冲区
if (!cs_ins) {
fprintf(stderr,"Out of memory\n");
cs_close(&dis);
return -1;
}
addr = bin->entry; // 二进制程序入口点
// 将入口地址放入队列
if (text->contains(addr)) Q.push(addr);
printf("entry point: 0x%016jx\n",addr);
// 遍历符号表
for (auto &sym: bin->symbols) {
if (sym.type == Symbol::SYM_TYPE_FUNC && text->contains(sym.addr)) {
Q.push(sym.addr); // 将函数起始地址放入队列
printf("function symbol: 0x%016jx\n",sym.addr);
}
}
// 遍历队列中的地址
while(!Q.empty()) {
addr = Q.front(); // 获取地址
Q.pop(); // 移出队列
if (seen[addr]) continue; // 跳过已经处理过的地址
offset = addr - text->vma; // 地址偏移
pc = text->bytes + offset; // 计算VMA
n = text->size - offset; // 字节数
while (cs_disasm_iter(dis,&pc,&n,&addr,cs_ins)) {
// 判断是否为无效命令
if (cs_ins->id == X86_INS_INVALID || cs_ins->size == 0) {
break;
}
}
seen[cs_ins->address] = true; // 记录已处理地址
print_ins(cs_ins);
// 判断是否为控制流指令
if (is_cs_cflow_ins(cs_ins)) {
target = get_cs_ins_immediate_target(cs_ins); // 解析流控制流目标地址
if (target && !seen[target] && text->contains(target)) {
Q.push(target);
printf(" -> new target: 0x%016jx\n",target);
}
if (is_cs_unconditional_cflow_ins(cs_ins)) {
break;
} else if (cs_ins->id == X86_INS_HLT) {
break;
}
}
printf("--------------\n");
}
cs_free(cs_ins,1);
cs_close(&dis);
return 0;
}
// 打印指令信息
void print_ins(cs_insn *ins)
{
printf("0x%016jx: ",ins->address);
for (size_t i = 0;i < 16;i++) {
if (i < ins->size)
printf("%02x ",ins->bytes[i]);
else
printf(" ");
}
printf("%-12s %s\n",ins->mnemonic,ins->op_str);
}
// 根据detail->group来判断控制流指令类型
bool is_cs_cflow_group(uint8_t g)
{
return (g == CS_GRP_JUMP) || (g == CS_GRP_CALL)
|| (g == CS_GRP_RET) || (g == CS_GRP_IRET);
}
bool is_cs_cflow_ins(cs_insn *ins)
{
for (size_t i = 0;i < ins->detail->groups_count;i++) {
if (is_cs_cflow_group(ins->detail->groups[i])) {
return true;
}
}
return false;
}
// 判断是否为无条件跳转指令
bool is_cs_unconditional_cflow_ins(cs_insn *ins)
{
switch (ins->id) {
case X86_INS_JMP:
case X86_INS_LJMP:
case X86_INS_RET:
case X86_INS_RETF:
case X86_INS_RETFQ:
return true;
default:
return false;
}
}
uint64_t get_cs_ins_immediate_target(cs_insn *ins)
{
cs_x86_op *cs_op;
for (size_t i=0; i < ins->detail->groups_count; i++) {
if (is_cs_cflow_group(ins->detail->groups[i])) {
for (size_t j = 0; j < ins->detail->groups[i];j++) {
cs_op = &ins->detail->x86.operands[j];
if (cs_op->type == X86_OP_IMM) {
return cs_op->imm;
}
}
}
}
return 0;
}
与线性反汇编的程序相比，main函数是相同的，disasm函数的初始化代码也是相似的，都是首先加载.text节并得到一个capstone句柄，额外增加了对cs_options的调用，设置CS_OPT_DETAIL选项开启详细反汇编模式。
程序中创建了一个队列，用于存储地址，便于跟踪指令流，而map结构的seen用于存放已经跟踪过的地址。首先将初始入口点放入该队列，即二进制程序的入口点，然后遍历整个符号表，将函数符号对应的地址放入队列。
之后会循环迭代这个队列，取出存放的地址，即起始点，对每个起始点进行线性反汇编，并将每个新发现的控制流跳转地址增加到队列中，这些新的地址将在后续的循环中再次被反汇编。每次线性扫描只在遇到hlt指令或者无条件分支指令时停止，因为这些指令之后出现的可能是数据而不是代码，所以不能继续进行反汇编。
cs_disasm_iter是cs_disasm函数的迭代版本。cs_disasm_iter一次只反汇编一条指令，而不是整个代码区。在每条指令进行反汇编后，cs_disasm_iter返回true或false，true表示指令已经成功反汇编，而false表示指令反汇编失败。因此创建一个while循环，知道该函数返回false才停止。该函数的第一个参数是capstone句柄，第二个参数是一个二级指针，指向反汇编代码，在cs_disasm_iter每次被调用时，会更新这个指针，将其指向上次反汇编字节的下一个位置，就好像程序计数器。第三个参数是反汇编的剩余字节数，在调用cs_disasm_iter时，该字节数会被自动递减，在该程序中其大小总是等于.text节的大小减去已经反汇编的字节数。之后的一个参数等于前一个参数指向的代码的VMA，最后一个参数是指向cs_insn对象的指针，该对象作为每个反汇编指令的缓冲区。
offset = addr - text->vma; // 地址偏移
pc = text->bytes + offset; // 计算VMA
n = text->size - offset; // 字节数
while (cs_disasm_iter(dis,&pc,&n,&addr,cs_ins)) {
// 判断是否为无效命令
if (cs_ins->id == X86_INS_INVALID || cs_ins->size == 0) {
break;
}
}
用cs_disasm_iter代替cs_disasm有两个优点: cs_disasm_iter支持迭代机制，在每条指令被反汇编后能立即查看，以便检查控制流指令并进行递归遍历。
在整个对队列的循环中，每次调用cs_disasm_iter函数时得到和指令相关的cs_ins结构后，使用is_cs_cflow_ins确定指令是否为控制流指令。
bool is_cs_cflow_ins(cs_insn *ins)
{
for (size_t i = 0;i < ins->detail->groups_count;i++) {
if (is_cs_cflow_group(ins->detail->groups[i])) {
return true;
}
}
return false;
}
该函数须要访问cs_ins结构体中detail的groups数组，如下是detail结构的详细信息:
// NOTE: All information in cs_detail is only available when CS_OPT_DETAIL = CS_OPT_ON
typedef struct cs_detail {
uint8_t regs_read[12]; // list of implicit registers read by this insn
uint8_t regs_read_count; // number of implicit registers read by this insn
uint8_t regs_write[20]; // list of implicit registers modified by this insn
uint8_t regs_write_count; // number of implicit registers modified by this insn
uint8_t groups[8]; // list of group this instruction belong to
uint8_t groups_count; // number of groups this insn belongs to
// Architecture-specific instruction info
union {
cs_x86 x86; // X86 architecture, including 16-bit, 32-bit & 64-bit mode
cs_arm64 arm64; // ARM64 architecture (aka AArch64)
cs_arm arm; // ARM architecture (including Thumb/Thumb2)
cs_mips mips; // MIPS architecture
cs_ppc ppc; // PowerPC architecture
cs_sparc sparc; // Sparc architecture
cs_sysz sysz; // SystemZ architecture
cs_xcore xcore; // XCore architecture
};
} cs_detail;
is_cs_cflow_ins中调用is_cs_cflow_group，检查指令是否为跳转、调用、返回和中断。
bool is_cs_cflow_group(uint8_t g)
{
return (g == CS_GRP_JUMP) || (g == CS_GRP_CALL)
|| (g == CS_GRP_RET) || (g == CS_GRP_IRET);
}
经过上述的一系列判断，如果发现尚未被处理过的控制流指令，则要进一步解析控制流目标地址。如下函数负责获取地址，但只能作用于直接寻址。
uint64_t get_cs_ins_immediate_target(cs_insn *ins)
{
cs_x86_op *cs_op;
for (size_t i=0; i < ins->detail->groups_count; i++) {
if (is_cs_cflow_group(ins->detail->groups[i])) {
for (size_t j = 0; j < ins->detail->x86.op_count;j++) {
cs_op = &ins->detail->x86.operands[j];
if (cs_op->type == X86_OP_IMM) {
return cs_op->imm;
}
}
}
}
return 0;
}
该函数要检查指令的操作数，而每种指令体系中都有自己的一套操作数类型，因此无法采用通用的解析方法。
访问detail中x86.operands数组，获取指令操作数，类型为cs_x86_op结构体:
// Instruction operand
typedef struct cs_x86_op {
x86_op_type type; // operand type
union {
x86_reg reg; // register value for REG operand
int64_t imm; // immediate value for IMM operand
double fp; // floating point value for FP operand
x86_op_mem mem; // base/index/scale/disp value for MEM operand
};
// size of this operand (in bytes).
uint8_t size;
// AVX broadcast type, or 0 if irrelevant
x86_avx_bcast avx_bcast;
// AVX zero opmask {z}
bool avx_zero_opmask;
} cs_x86_op;
遍历这个数组，判断类型，如果为IMM指令(立即数)，则直接访问imm成员，获取操作数
终端执行命令: g++ -I . recursive.cpp loader.cpp -o recursive -lbfd -lcapstone
$ ./recursive ./hello
entry point: 0x0000000000401040
function symbol: 0x0000000000401080
function symbol: 0x00000000004010b0
function symbol: 0x00000000004010f0
function symbol: 0x0000000000401120
function symbol: 0x00000000004011c0
function symbol: 0x0000000000401160
function symbol: 0x0000000000401070
function symbol: 0x0000000000401040
function symbol: 0x0000000000401133
function symbol: 0x0000000000401122
0x00000000004011c1: c3 ret
