逆向三剑客：keystone，capstone，unicorn

简介

keystone 是一个汇编器，能够将汇编代码转换成硬编码。
capstone 是一个反汇编器，能够将硬编码转换为汇编代码。
unicorn 是一个模拟器，能够模拟cpu执行汇编指令。
通过这3个工具，能够帮助我们逆向模拟分析代码，绕过动态的反调试，简化静态的vm和混淆的困扰。
环境安装

1. pip install keystone-engine capstone unicorn

复制代码

这3个工具用法极其简单，下面通过示例来演示其用法。
Keystone

示例

1. from keystone import *
3. CODE = b"INC ECX; ADD EDX, ECX"
5. try:
6.     ks = Ks(KS_ARCH_X86, KS_MODE_64)
7.    
8.     encoding, count = ks.asm(CODE)
9.    
10.     print(f"汇编指令数量: {count}")
11.     print(f"机器码 (十进制): {encoding}")
12.     print(f"机器码 (Hex): {''.join(f'{x:02x}' for x in encoding)}")
14. except KsError as e:
15.     print(f"ERROR: {e}")

复制代码

代码解释

代码流程十分简单：
初始化keystone->编译代码->输出结果
初始化keystone

1. ks = Ks(KS_ARCH_X86, KS_MODE_64)

复制代码

初始化keystone引擎：

• 第一个参数：选择指令架构例如：x86，arm......
  
• 第二个参数：选择模式，例如：64位，32位，小端序......
  

编译代码

将汇编转换为16进制的shellcode

1. encoding, count = ks.asm(CODE)

复制代码

• 第一个返回值：机器码指令的数组
  
• 第二个返回值：汇编指令数量
  

Capstone

capstone的用法和keystone差不多。
示例

1. from capstone import *
3. CODE = b"\xff\xc1\x01\xca"
5. md = Cs(CS_ARCH_X86, CS_MODE_64)
7. print("地址\t\t指令\t\t操作数")
8. print("-" * 30)
10. for i in md.disasm(CODE, 0x1000):
11.     print(f"0x{i.address:x}:\t{i.mnemonic}\t{i.op_str}")

复制代码

代码解释

代码流程跟keystone差不多：
初始化capstone->反编译代码->输出结果
初始化capstone

1. md = Cs(CS_ARCH_X86, CS_MODE_64)

复制代码

初始化capstone引擎：

• 第一个参数：选择指令架构例如：x86，arm......
  
• 第二个参数：选择模式，例如：64位，32位，小端序......
  

反编译代码

1. for i in md.disasm(CODE, 0x1000):
2.     print(f"0x{i.address:x}:\t{i.mnemonic}\t{i.op_str}")

复制代码

使用方法disasm反汇编：

• 第一个参数：机器码
  
• 第二个参数：第一条指令的基地址
  
• 返回：一个包含指令对象的数组
  

unicorn

unicorn提供的方法使用也不复杂，但需要一定的内存基础知识。
下面用一个案例解释。
示例

情景模拟： 我逆向过程中发现一个xor加密代码，我需要通过模拟执行，对密文进行解密。
根据汇编代码可以得知：
0x20000存放密文
0x30000存放结果
0x10000中读取密钥key

1. from unicorn import *
2. from unicorn.x86_const import *
3. import struct
4. from keystone import *
6. ASM_CODE = """
7.     MOV ECX, 5
8.     MOV ESI, 0x20000
9.     MOV EDI, 0x30000
10.     MOV BL, byte ptr [0x10000]
11. loop_start:
12.     LODSB
13.     XOR AL, BL
14.     STOSB
15.     LOOP loop_start
16. """
18. def get_code():
19.     ks = Ks(KS_ARCH_X86, KS_MODE_32)
20.     encoding, count = ks.asm(ASM_CODE)
21.     return bytes(encoding)
23. CODE = get_code()
25. ADDRESS_CODE = 0x400000    
26. ADDRESS_KEY  = 0x10000      
27. ADDRESS_IN   = 0x20000      
28. ADDRESS_OUT  = 0x30000      
29. REAL_KEY = 0x77            
31. CIPHER_TEXT = b"\x3F\x12\x1B\x1B\x18"
33. def hook_code(uc, access, address, size, value, user_data):
34.     if address == ADDRESS_KEY:
35.         key_value = uc.mem_read(address, size)
36.         print(f"key: {hex(key_value[0])}")
38. def start_emulation():
39.     try:
40.         print("初始化环境...")
41.         mu = Uc(UC_ARCH_X86, UC_MODE_32)
43.         mu.mem_map(0x0, 1 * 1024 * 1024)
44.         mu.mem_map(ADDRESS_CODE, 2 * 1024 * 1024)
46.         mu.mem_write(ADDRESS_CODE, CODE)
47.         mu.mem_write(ADDRESS_IN, CIPHER_TEXT)
48.         mu.mem_write(ADDRESS_KEY, struct.pack("B", REAL_KEY))
50.         mu.hook_add(UC_HOOK_MEM_READ, hook_code)
51.        
52.         mu.emu_start(ADDRESS_CODE, ADDRESS_CODE + len(CODE))
54.         decrypted_text = mu.mem_read(ADDRESS_OUT, 5)
55.         print(f"解密后的文本: {decrypted_text.decode()}")
57.     except UcError as e:
58.         print(f"模拟错误: {e}")
60. if __name__ == "__main__":
61.     start_emulation()

复制代码

代码解释

代码流程：
初始化环境->分配虚拟内存->写入数据->添加捕获操作->模拟执行指令->读取内存结果
初始化环境

这个跟上面的keystone和capstone一样，就不解释了

1. mu = Uc(UC_ARCH_X86, UC_MODE_32)

复制代码

分配虚拟内存

第一行是用于存放堆内存数据，第二行是用于存放执行的代码

1. mu.mem_map(0x0, 1 * 1024 * 1024)
2. mu.mem_map(ADDRESS_CODE, 2 * 1024 * 1024)

复制代码

mem_map用于初始化虚拟内存

• 第一个参数：内存的虚拟地址基址
  
• 第二个参数：内存的大小
  

内写入数据

第一行写入代码，第二行写入密文，第三行写入解密key

1. mu.mem_write(ADDRESS_CODE, CODE)
2. mu.mem_write(ADDRESS_IN, CIPHER_TEXT)
3. mu.mem_write(ADDRESS_KEY, struct.pack("B", REAL_KEY))

复制代码

mem_write用于写入虚拟内存

• 第一个参数：写入内存的地址
  
• 第二个参数：写入内存的数据
  

添加捕获操作

hook用于捕获数据，这里用于捕获key

1. def hook_code(uc, access, address, size, value, user_data):
2.     if address == ADDRESS_KEY:
3.         key_value = uc.mem_read(address, size)
4.         print(f"key: {hex(key_value[0])}")
5. mu.hook_add(UC_HOOK_MEM_READ, hook_code)

复制代码

hook_add添加hook

• 第一个参数：捕获模式，规定什么时候触发hook，例如：读取内存，中断捕获......
  
• 第二个参数：触发的回调函数，回调函数各个参数如下：
  

1. def hook_code(uc, access, address, size, value, user_data):

复制代码

• uc：模拟器对象
  
• access：当前访问类型：UC_MEM_READ，UC_MEM_WRITE......
  
• address：当前访问的虚拟地址
  
• size：当前访问数据大小
  
• value：access为UC_MEM_WRITE，则这里为要写入的值
  
• user_data：用户在add_hook时传进去的自定义数据
  

模拟执行指令

1. mu.emu_start(ADDRESS_CODE, ADDRESS_CODE + len(CODE))

复制代码

• 第一个参数：模拟执行的起始地址
  
• 第二个参数：模拟执行的代码大小
  

读取内存结果

1. decrypted_text = mu.mem_read(ADDRESS_OUT, 5)

复制代码

• 第一个参数：读取内存的地址
  
• 第二个参数：读取内存的大小
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！