驱动开发：内核实现进程汇编与反汇编

在笔者上一篇文章《驱动开发：内核MDL读写进程内存》简单介绍了如何通过MDL映射的方式实现进程读写操作，本章将通过如上案例实现远程进程反汇编功能，此类功能也是ARK工具中最常见的功能之一，通常此类功能的实现分为两部分，内核部分只负责读写字节集，应用层部分则配合反汇编引擎对字节集进行解码，此处我们将运用capstone引擎实现这个功能。

首先是实现驱动部分，驱动程序的实现是一成不变的，仅仅只是做一个读写功能即可，完整的代码如下所示；

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
5. #include <ntifs.h>
6. #include <windef.h>
8. #define READ_PROCESS_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
9. #define WRITE_PROCESS_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)
11. #define DEVICENAME L"\\Device\\ReadWriteDevice"
12. #define SYMBOLNAME L"\\??\\ReadWriteSymbolName"
14. typedef struct
15. {
16.         DWORD pid;       // 进程PID
17.         UINT64 address;  // 读写地址
18.         DWORD size;      // 读写长度
19.         BYTE* data;      // 读写数据集
20. }ProcessData;
22. // MDL读取封装
23. BOOLEAN ReadProcessMemory(ProcessData* ProcessData)
24. {
25.         BOOLEAN bRet = TRUE;
26.         PEPROCESS process = NULL;
28.         // 将PID转为EProcess
29.         PsLookupProcessByProcessId(ProcessData->pid, &process);
30.         if (process == NULL)
31.         {
32.                 return FALSE;
33.         }
35.         BYTE* GetProcessData = NULL;
36.         __try
37.         {
38.                 // 分配堆空间 NonPagedPool 非分页内存
39.                 GetProcessData = ExAllocatePool(NonPagedPool, ProcessData->size);
40.         }
41.         __except (1)
42.         {
43.                 return FALSE;
44.         }
46.         KAPC_STATE stack = { 0 };
47.         // 附加到进程
48.         KeStackAttachProcess(process, &stack);
50.         __try
51.         {
52.                 // 检查进程内存是否可读取
53.                 ProbeForRead(ProcessData->address, ProcessData->size, 1);
55.                 // 完成拷贝
56.                 RtlCopyMemory(GetProcessData, ProcessData->address, ProcessData->size);
57.         }
58.         __except (1)
59.         {
60.                 bRet = FALSE;
61.         }
63.         // 关闭引用
64.         ObDereferenceObject(process);
66.         // 解除附加
67.         KeUnstackDetachProcess(&stack);
69.         // 拷贝数据
70.         RtlCopyMemory(ProcessData->data, GetProcessData, ProcessData->size);
72.         // 释放堆
73.         ExFreePool(GetProcessData);
74.         return bRet;
75. }
77. // MDL写入封装
78. BOOLEAN WriteProcessMemory(ProcessData* ProcessData)
79. {
80.         BOOLEAN bRet = TRUE;
81.         PEPROCESS process = NULL;
83.         // 将PID转为EProcess
84.         PsLookupProcessByProcessId(ProcessData->pid, &process);
85.         if (process == NULL)
86.         {
87.                 return FALSE;
88.         }
90.         BYTE* GetProcessData = NULL;
91.         __try
92.         {
93.                 // 分配堆
94.                 GetProcessData = ExAllocatePool(NonPagedPool, ProcessData->size);
95.         }
96.         __except (1)
97.         {
98.                 return FALSE;
99.         }
101.         // 循环写出
102.         for (int i = 0; i < ProcessData->size; i++)
103.         {
104.                 GetProcessData[i] = ProcessData->data[i];
105.         }
107.         KAPC_STATE stack = { 0 };
109.         // 附加进程
110.         KeStackAttachProcess(process, &stack);
112.         // 分配MDL对象
113.         PMDL mdl = IoAllocateMdl(ProcessData->address, ProcessData->size, 0, 0, NULL);
114.         if (mdl == NULL)
115.         {
116.                 return FALSE;
117.         }
119.         MmBuildMdlForNonPagedPool(mdl);
121.         BYTE* ChangeProcessData = NULL;
123.         __try
124.         {
125.                 // 锁定地址
126.                 ChangeProcessData = MmMapLockedPages(mdl, KernelMode);
128.                 // 开始拷贝
129.                 RtlCopyMemory(ChangeProcessData, GetProcessData, ProcessData->size);
130.         }
131.         __except (1)
132.         {
133.                 bRet = FALSE;
134.                 goto END;
135.         }
137.         // 结束释放MDL关闭引用取消附加
138. END:
139.         IoFreeMdl(mdl);
140.         ExFreePool(GetProcessData);
141.         KeUnstackDetachProcess(&stack);
142.         ObDereferenceObject(process);
144.         return bRet;
145. }
147. NTSTATUS DriverIrpCtl(PDEVICE_OBJECT device, PIRP pirp)
148. {
149.         PIO_STACK_LOCATION stack;
150.         stack = IoGetCurrentIrpStackLocation(pirp);
151.         ProcessData* ProcessData;
153.         switch (stack->MajorFunction)
154.         {
156.         case IRP_MJ_CREATE:
157.         {
158.                 break;
159.         }
161.         case IRP_MJ_CLOSE:
162.         {
163.                 break;
164.         }
166.         case IRP_MJ_DEVICE_CONTROL:
167.         {
168.                 // 获取应用层传值
169.                 ProcessData = pirp->AssociatedIrp.SystemBuffer;
171.                 DbgPrint("进程ID: %d | 读写地址: %p | 读写长度: %d \n", ProcessData->pid, ProcessData->address, ProcessData->size);
173.                 switch (stack->Parameters.DeviceIoControl.IoControlCode)
174.                 {
175.                 // 读取函数
176.                 case READ_PROCESS_CODE:
177.                 {
178.                         ReadProcessMemory(ProcessData);
179.                         break;
180.                 }
181.                 // 写入函数
182.                 case WRITE_PROCESS_CODE:
183.                 {
184.                         WriteProcessMemory(ProcessData);
185.                         break;
186.                 }
188.                 }
190.                 pirp->IoStatus.Information = sizeof(ProcessData);
191.                 break;
192.         }
194.         }
196.         pirp->IoStatus.Status = STATUS_SUCCESS;
197.         IoCompleteRequest(pirp, IO_NO_INCREMENT);
198.         return STATUS_SUCCESS;
199. }
201. VOID UnDriver(PDRIVER_OBJECT driver)
202. {
203.         if (driver->DeviceObject)
204.         {
205.                 UNICODE_STRING SymbolName;
206.                 RtlInitUnicodeString(&SymbolName, SYMBOLNAME);
208.                 // 删除符号链接
209.                 IoDeleteSymbolicLink(&SymbolName);
210.                 IoDeleteDevice(driver->DeviceObject);
211.         }
212. }
214. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
215. {
216.         NTSTATUS status = STATUS_SUCCESS;
217.         PDEVICE_OBJECT device = NULL;
218.         UNICODE_STRING DeviceName;
220.         DbgPrint("[LyShark] hello lyshark.com \n");
222.         // 初始化设备名
223.         RtlInitUnicodeString(&DeviceName, DEVICENAME);
225.         // 创建设备
226.         status = IoCreateDevice(Driver, sizeof(Driver->DriverExtension), &DeviceName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &device);
227.         if (status == STATUS_SUCCESS)
228.         {
229.                 UNICODE_STRING SymbolName;
230.                 RtlInitUnicodeString(&SymbolName, SYMBOLNAME);
232.                 // 创建符号链接
233.                 status = IoCreateSymbolicLink(&SymbolName, &DeviceName);
235.                 // 失败则删除设备
236.                 if (status != STATUS_SUCCESS)
237.                 {
238.                         IoDeleteDevice(device);
239.                 }
240.         }
242.         // 派遣函数初始化
243.         Driver->MajorFunction[IRP_MJ_CREATE] = DriverIrpCtl;
244.         Driver->MajorFunction[IRP_MJ_CLOSE] = DriverIrpCtl;
245.         Driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DriverIrpCtl;
247.         // 卸载驱动
248.         Driver->DriverUnload = UnDriver;
250.         return STATUS_SUCCESS;
251. }

复制代码

上方的驱动程序很简单关键部分已经做好了备注，此类驱动换汤不换药没啥难度，接下来才是本节课的重点，让我们开始了解一下Capstone这款反汇编引擎吧，Capstone是一个轻量级的多平台、多架构的反汇编框架。Capstone旨在成为安全社区中二进制分析和反汇编的终极反汇编引擎，该引擎支持多种平台的反汇编，非常推荐使用。

• 反汇编引擎下载地址：https://cdn.lyshark.com/sdk/capstone_msvc12.zip
  

这款反汇编引擎如果你想要使用它则第一步就是调用cs_open()官方对其的解释是打开一个句柄，这个打开功能其中的参数如下所示；

• 参数1：指定模式 CS_ARCH_X86 表示为Windows平台
  
• 参数2：执行位数 CS_MODE_32为32位模式，CS_MODE_64为64位
  
• 参数3：打开后保存的句柄&dasm_handle
  

第二步也是最重要的一步，调用cs_disasm()反汇编函数，该函数的解释如下所示；

• 参数1：指定dasm_handle反汇编句柄
  
• 参数2：指定你要反汇编的数据集或者是一个缓冲区
  
• 参数3：指定你要反汇编的长度 64
  
• 参数4：输出的内存地址起始位置 0x401000
  
• 参数5：默认填充为0
  
• 参数6：用于输出数据的一个指针
  

这两个函数如果能搞明白，那么如下反汇编完整代码也就可以理解了。

1. #define _CRT_SECURE_NO_WARNINGS
2. #include <Windows.h>
3. #include <iostream>
4. #include <inttypes.h>
5. #include <capstone/capstone.h>
7. #pragma comment(lib,"capstone64.lib")
9. #define READ_PROCESS_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
10. #define WRITE_PROCESS_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)
12. typedef struct
13. {
14.         DWORD pid;
15.         UINT64 address;
16.         DWORD size;
17.         BYTE* data;
18. }ProcessData;
20. int main(int argc, char* argv[])
21. {
22.         // 连接到驱动
23.         HANDLE handle = CreateFileA("\\??\\ReadWriteSymbolName", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
25.         ProcessData data;
26.         DWORD dwSize = 0;
28.         // 指定需要读写的进程
29.         data.pid = 6932;
30.         data.address = 0x401000;
31.         data.size = 64;
33.         // 读取机器码到BYTE字节数组
34.         data.data = new BYTE[data.size];
35.         DeviceIoControl(handle, READ_PROCESS_CODE, &data, sizeof(data), &data, sizeof(data), &dwSize, NULL);
36.         for (int i = 0; i < data.size; i++)
37.         {
38.                 printf("0x%02X ", data.data[i]);
39.         }
41.         printf("\n");
43.         // 开始反汇编
44.         csh dasm_handle;
45.         cs_insn *insn;
46.         size_t count;
48.         // 打开句柄
49.         if (cs_open(CS_ARCH_X86, CS_MODE_32, &dasm_handle) != CS_ERR_OK)
50.         {
51.                 return 0;
52.         }
54.         // 反汇编代码
55.         count = cs_disasm(dasm_handle, (unsigned char *)data.data, data.size, data.address, 0, &insn);
57.         if (count > 0)
58.         {
59.                 size_t index;
60.                 for (index = 0; index < count; index++)
61.                 {
62.                         /*
63.                         for (int x = 0; x < insn[index].size; x++)
64.                         {
65.                                 printf("机器码: %d -> %02X \n", x, insn[index].bytes[x]);
66.                         }
67.                         */
69.                         printf("地址: 0x%"PRIx64" | 长度: %d 反汇编: %s %s \n", insn[index].address, insn[index].size, insn[index].mnemonic, insn[index].op_str);
70.                 }
71.                 cs_free(insn, count);
72.         }
73.         cs_close(&dasm_handle);
75.         getchar();
76.         CloseHandle(handle);
77.         return 0;
78. }

复制代码

通过驱动加载工具加载WinDDK.sys然后在运行本程序，你会看到正确的输出结果，反汇编当前位置处向下64字节。

说完了反汇编接着就需要讲解如何对内存进行汇编操作了，汇编引擎这里采用了XEDParse该引擎小巧简洁，著名的x64dbg就是在运用本引擎进行汇编替换的，本引擎的使用非常简单，只需要向XEDParseAssemble()函数传入一个规范的结构体即可完成转换，完整代码如下所示。

• 汇编引擎下载地址：https://cdn.lyshark.com/sdk/XEDParse.zip
  

1. #define _CRT_SECURE_NO_WARNINGS
2. #include <Windows.h>
3. #include <iostream>
5. extern "C"
6. {
7. #include "D:/XEDParse/XEDParse.h"
8. #pragma comment(lib, "D:/XEDParse/XEDParse_x64.lib")
9. }
11. using namespace std;
13. #define READ_PROCESS_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ALL_ACCESS)
14. #define WRITE_PROCESS_CODE CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_ALL_ACCESS)
16. typedef struct
17. {
18.         DWORD pid;
19.         UINT64 address;
20.         DWORD size;
21.         BYTE* data;
22. }ProcessData;
24. int main(int argc, char* argv[])
25. {
26.         // 连接到驱动
27.         HANDLE handle = CreateFileA("\\??\\ReadWriteSymbolName", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
29.         ProcessData data;
30.         DWORD dwSize = 0;
32.         // 指定需要读写的进程
33.         data.pid = 6932;
34.         data.address = 0x401000;
35.         data.size = 0;
37.         XEDPARSE xed = { 0 };
38.         xed.x64 = FALSE;
40.         // 输入一条汇编指令并转换
41.         scanf_s("%llx", &xed.cip);
42.         gets_s(xed.instr, XEDPARSE_MAXBUFSIZE);
43.         if (XEDPARSE_OK != XEDParseAssemble(&xed))
44.         {
45.                 printf("指令错误: %s\n", xed.error);
46.         }
48.         // 生成堆
49.         data.data = new BYTE[xed.dest_size];
51.         // 设置长度
52.         data.size = xed.dest_size;
54.         for (size_t i = 0; i < xed.dest_size; i++)
55.         {
56.                 // 替换到堆中
57.                 printf("%02X ", xed.dest[i]);
58.                 data.data[i] = xed.dest[i];
59.         }
61.         // 调用控制器，写入到远端内存
62.         DeviceIoControl(handle, WRITE_PROCESS_CODE, &data, sizeof(data), &data, sizeof(data), &dwSize, NULL);
64.         printf("[LyShark] 指令集已替换. \n");
65.         getchar();
66.         CloseHandle(handle);
67.         return 0;
68. }

复制代码

通过驱动加载工具加载WinDDK.sys然后在运行本程序，你会看到正确的输出结果，可打开反内核工具验证是否改写成功。

打开反内核工具，并切换到观察是否写入了一条mov eax,1的指令集机器码，如下图已经完美写入。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！