【第49节】windows平台下反汇编和汇编引擎的使用实践

目录

引言

一、XEDParse：汇编指令生成Opcode的利器

二、BeaEngine：强大的反汇编引擎

三、Capstone：高效的反汇编工具

四、Keystone：便捷的汇编引擎

引言

        在汇编语言的开发领域，掌握相关工具的使用对于深入理解计算机底层运作、优化代码性能以及进行逆向工程等工作至关重要。本文将通过具体的代码示例，详细介绍XEDParse、BeaEngine、Capstone和Keystone这几种常用工具在实际编程中的应用。

一、XEDParse：汇编指令生成Opcode的利器

代码示例解析：

// XEDParse.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"

//1. 导入头文件
#include "XEDParse/XEDParse.h"

#ifdef _WIN64
#pragma comment (lib,"XEDParse/x64/XEDParse_x64.lib")
#else
#pragma comment (lib,"XEDParse/x86/XEDParse_x86.lib")
#endif // _WIN64

// 打印opcode
void printOpcode(const unsigned char* pOpcode, int nSize) {
    for (int i = 0; i < nSize; ++i) {
        printf("%02X ", pOpcode[i]);
    }
}

int _tmain(int argc, _TCHAR* argv[]) {
    XEDPARSE xed = { 0 };

    printf("地址：");

    // 接受生成opcode的的初始地址
    scanf_s("%x", &xed.cip);
    getchar();

    do {
        // 接收指令
        printf("指令：");
        gets_s(xed.instr, XEDPARSE_MAXBUFSIZE);

        // xed.cip, 汇编带有跳转偏移的指令时,需要配置这个字段
        if (XEDPARSE_OK != XEDParseAssemble(&xed)) {
            printf("指令错误：%s\n", xed.error);
            continue;
        }

        // 打印汇编指令所生成的opcode
        printf("%08X : ", xed.cip);
        printOpcode(xed.dest, xed.dest_size);
        printf("\n");

        // 将地址增加到下一条指令的首地址
        xed.cip += xed.dest_size;
    } while (*xed.instr);

    return 0;
}

        在这段代码中，首先导入了`XEDParse`的头文件，并根据平台（32位或64位）链接相应的库文件。`printOpcode`函数用于以十六进制格式打印操作码（opcode）。在`_tmain`函数中，通过用户输入的地址和汇编指令，利用`XEDParseAssemble`函数将汇编指令转换为opcode，并打印出opcode以及对应的地址。这个工具对于研究汇编指令与机器码之间的转换关系非常有帮助，在开发编译器、反编译器以及进行底层代码优化时都可能用到。

二、BeaEngine：强大的反汇编引擎

代码示例剖析：

// BeaEngine反汇编引擎使用示例.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

// 添加以下宏
#define BEA_ENGINE_STATIC
#define BEA_USE_STDCALL
// 1. 包含BegEngine的头文件
//    Win32 是32位平台的程序可以使用的头文件
//    Win64 是64位平台的程序可以使用的头文件
#ifndef _WIN64
#include "BeaEngine_4.1/Win32/headers/BeaEngine.h"
//2. 包含对应版本的静态库
#pragma comment (lib, "BeaEngine_4.1/Win32/Win32/Lib/BeaEngine.lib")
#else
#include "BeaEngine_4.1/Win64/headers/BeaEngine.h"
//2. 包含对应版本的静态库
#pragma comment (lib, "BeaEngine_4.1/Win64/Win64/Lib/BeaEngine.lib")
#endif

// 防止编译错误。
#pragma comment(linker, "/NODEFAULTLIB:\"crt.lib\"")

// 打印opcode
// const unsigned char* pOpcode ： opcode 的缓冲区首地址
// nSize ： opcdoe的字节数
void printOpcode(const unsigned char* pOpcode, int nSize) {
    for (int i = 0; i < nSize; ++i) {
        printf("%02X ", pOpcode[i]);
    }
}

int _tmain(int argc, _TCHAR* argv[]) {
    DISASM disAsm = { 0 };
    /*
    typedef struct _Disasm
    {
        UIntPtr EIP;    // opcode所在的地址
        UInt64 VirtualAddr; // 保存opcode的缓冲区的首地址
        UInt32 SecurityBlock;
        char CompleteInstr[ INSTRUCT_LENGTH ]; // 转换出来的汇编指令
        UInt32 Archi; // 处理器的架构，可以是32位CPU，或是64位的CPU
        UInt64 Options;
        INSTRTYPE Instruction;
        ARGTYPE Argument1;
        ARGTYPE Argument2;
        ARGTYPE Argument3;
        PREFIXINFO Prefix;
        UInt32 Reserved_[ 40 ];
    } DISASM, *PDISASM, *LPDISASM;
    */

    unsigned char opcode[] = {
        "\x68\xE5\x30\x40\x00\x68\xE2\x30\x40\x00\xFF\x15\x08\x20\x40\x00\x83\xC4\x08\x68\x1A\x30\x40\x00\x68\xE2\x30\x40\x00\xFF\x15\x00\x20\x40\x00\x83\xC4\x08"
    };

    // 3. 配置结构体，初始化反汇编的opcode
    disAsm.EIP = (UIntPtr)opcode; // 保存opcode的缓冲区首地址
    disAsm.VirtualAddr = 0x401080; // opcode 指令的地址
    disAsm.Archi = 0; // 0 => 32, 1 => 64
    disAsm.Options = 0x000; // masm 汇编指令格式

    int nOpcodeSize = sizeof(opcode); // opcode的字节数

    int nCount = 0;// 用于记录在循环当中，反汇编了多少个字节
    int nLen = 0; // 用于记录当前的汇编指令的字节数

    // 调用Disasm（）进行反汇编，
    while (nCount < nOpcodeSize) {
        nLen = Disasm(&disAsm); // 每次只反汇编一条汇编指令， 并且返回当前得到的汇编指令的长度
        unsigned int uAddr = disAsm.VirtualAddr;

        printf("%08X | ", uAddr); // 打印地址
        printOpcode((const unsigned char*)disAsm.EIP, nLen); // 打印opcode
        printf(" | %s\n", disAsm.CompleteInstr); // 打印反汇编指令

        nCount += nLen; // 累加已经反汇编的字节数
        disAsm.EIP += nLen; // 定位到下一条汇编指令
        disAsm.VirtualAddr += nLen; // 设置到下一条汇编指令的地址
    }

    return 0;
}

        这段代码展示了BeaEngine反汇编引擎的使用。首先，根据平台导入相应的头文件和链接库，并定义了`printOpcode`函数用于打印opcode。在`_tmain`函数中，创建了`DISASM`结构体并进行初始化，指定要反汇编的opcode缓冲区、地址、处理器架构和指令格式等信息。通过循环调用`Disasm`函数，逐行反汇编给定的opcode，并打印出地址、opcode以及反汇编后的汇编指令。BeaEngine在逆向工程、代码分析以及理解现有二进制代码的逻辑方面发挥着重要作用。

三、Capstone：高效的反汇编工具

代码示例解读：

// capstoneTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "capstone/include/capstone.h"

//1. 包含头文件
#ifdef _WIN64 // 64位平台编译器会自动定义这个宏
#pragma
comment(lib,"capstone/lib/capstone_x64.lib")
#else
#pragma comment(lib,"capstone/lib/capstone_x86.lib")
#endif // _64

int _tmain(int argc, _TCHAR* argv[]) {
    csh handle;  // 反汇编引擎句柄
    cs_err err; // 错误信息
    cs_insn* pInsn; // 保存反汇编得到的指令的缓冲区首地址
    unsigned int count = 0; // 保存得到的反汇编的指令条数

    //初始化反汇编器句柄,(x86_64架构,32位模式,句柄)
    err = cs_open(CS_ARCH_X86,  /*x86指令集*/
                  CS_MODE_32, /*使用32位模式解析opcode*/
                  &handle /*输出的反汇编句柄*/
    );

    if (err != CS_ERR_OK) {
        printf("初始化反汇编器句柄失败:%s\n", cs_strerror(err));
        return 0;
    }

    unsigned char szOpcode[] = { "\x53\x83\xEC\x18\x83\x3D\x20\x20\x48\x00\x02\x8B\x44\x24\x24" };

    // 开始反汇编.
    // 函数会返回总共得到了几条汇编指令
    count = cs_disasm(handle,/*反汇编器句柄,从cs_open函数得到*/
                      szOpcode,/*需要反汇编的opcode的缓冲区首地址*/
                      sizeof(szOpcode), /*opcode的字节数*/
                      0x401000, /*opcode的所在的内存地址*/
                      0, /*需要反汇编的指令条数,如果是0,则反汇编出全部*/
                      &pInsn/*反汇编输出*/
    );

    size_t j;
    for (j = 0; j < count; j++) {
        printf("0x%08X | %s %s\n",
               (int)pInsn[j].address, /*指令地址*/
               pInsn[j].mnemonic,/*指令操作码*/
               pInsn[j].op_str/*指令操作数*/
        );
    }

    // 释放保存指令的空间
    cs_free(pInsn, count);

    // 关闭句柄
    cs_close(&handle);
    return 0;
}

        Capstone的代码示例中，首先包含了头文件并根据平台链接相应的库。在`_tmain`函数中，通过`cs_open`函数初始化反汇编引擎句柄，指定使用x86指令集和32位模式。然后定义了要反汇编的opcode数组，调用`cs_disasm`函数进行反汇编，该函数返回反汇编得到的指令条数。最后，通过循环遍历反汇编结果，打印出每条指令的地址、操作码和操作数。Capstone以其高效、准确的反汇编能力，在二进制代码分析、漏洞检测以及恶意软件研究等领域得到广泛应用。

四、Keystone：便捷的汇编引擎

代码示例阐释：

// Keystone汇编引擎的使用示例.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

//1. 包含头文件
#include "keystone/keystone.h"

//2. 包含静态库
#pragma comment (lib,"keystone/x86/keystone_x86.lib")

// 打印opcode
void printOpcode(const unsigned char* pOpcode, int nSize) {
    for (int i = 0; i < nSize; ++i) {
        printf("%02X ", pOpcode[i]);
    }
}

int _tmain(int argc, _TCHAR* argv[]) {
    ks_engine *pengine = NULL;
    if (KS_ERR_OK != ks_open(KS_ARCH_X86, KS_MODE_32, &pengine)) {
        printf("反汇编引擎初始化失败\n");
        return 0;
    }

    unsigned char* opcode = NULL; // 汇编得到的opcode的缓冲区首地址
    unsigned int nOpcodeSize = 0; // 汇编出来的opcode的字节数

    // 汇编指令
    // 可以使用分号，或者换行符将指令分隔开
    char asmCode[] = {
        "mov eax,ebx;mov eax,1;mov dword ptr ds:[eax],20"
    };

    int nRet = 0; // 保存函数的返回值，用于判断函数是否执行成功
    size_t stat_count = 0; // 保存成功汇编的指令的条数

    nRet = ks_asm(pengine, /* 汇编引擎句柄，通过ks_open函数得到*/
                  asmCode, /*要转换的汇编指令*/
                  0x401000, /*汇编指令所在的地址*/
                  &opcode,/*输出的opcode*/
                  &nOpcodeSize,/*输出的opcode的字节数*/
                  &stat_count /*输出成功汇编的指令的条数*/
    );

    // 返回值等于-1时反汇编错误
    if (nRet == -1) {
        // 输出错误信息
        // ks_errno 获得错误码
        // ks_strerror 将错误码转换成字符串，并返回这个字符串
        printf("错误信息：%s\n", ks_strerror(ks_errno(pengine)));
        return 0;
    }

    printf("一共转换了%d条指令\n", stat_count);

    // 打印汇编出来的opcode
    printOpcode(opcode, nOpcodeSize);

    // 释放空间
    ks_free(opcode);

    // 关闭句柄
    ks_close(pengine);

    return 0;
}

        在Keystone汇编引擎的示例中，先包含头文件和链接库。在`_tmain`函数中，通过`ks_open`函数初始化汇编引擎句柄，指定x86架构和32位模式。定义了要汇编的汇编指令字符串，调用`ks_asm`函数将汇编指令转换为opcode，并获取opcode的缓冲区地址、字节数以及成功汇编的指令条数。如果汇编过程出现错误，打印错误信息。最后，打印出汇编得到的opcode，并释放相关资源。Keystone使得从汇编代码生成机器码变得更加便捷，在开发自定义编译器、编写高效的底层代码以及对特定硬件平台进行编程时非常有用。

        通过对XEDParse、BeaEngine、Capstone和Keystone这几种工具的代码示例分析，我们深入了解了它们在汇编指令生成、反汇编以及汇编过程中的具体应用。这些工具为开发者在汇编语言编程领域提供了丰富的功能支持，无论是进行底层系统开发、代码优化还是逆向工程分析，都能借助它们提高开发效率和深入理解计算机底层原理。