运用Capstone实现64位进程钩子扫描

进程钩子扫描是一种安全技术和分析方法,用于检测和分析进程内的指令是否被篡改或注入了恶意功能。钩子(Hook)技术允许开发人员在执行特定系统调用或函数时插入自定义代码。虽然进程钩子在调试和软件功能扩展中发挥了重要作用,但该技术也可以被恶意软件用来拦截和修改程序行为,从而隐藏其活动或进行其他恶意操作。本章将通过Capstone引擎实现64位进程钩子的扫描,读者可使用此段代码检测目标进程内是否被挂了钩子。

通过进程钩子扫描,安全研究人员和开发人员可以检测进程中是否存在未授权的钩子,并分析这些钩子的行为。这有助于识别和防止恶意软件的活动,确保系统和应用程序的完整性和安全性。

在编写代码之前,读者需要自行下载并配置Capstone反汇编引擎,配置参数如下所示;

20240813162356

在之前的PeView命令行解析工具中笔者介绍了如何扫描32位进程内的钩子,由于32位进程需要重定位所以在扫描时需要考虑到对内存地址的修正,而64位进程则无需考虑重定位的问题,其钩子扫描原理与32位保持一致,均通过将磁盘和内存中的代码段进行反汇编,并逐条比较它们的机器码和反汇编结果。如果存在差异,则表示该代码段在内存中被篡改或挂钩。

定义头文件

首先引入capstone.h头文件,并引用capstone64.lib静态库,通过定义PeTextInfo来存储每个PE文件中节的文件偏移及大小信息,通过ModuleInfo用于存放进程内的模块信息,而DisassemblyInfo则用来存放反汇编信息,底部则定义PE结构的全局变量用于存储头指针。

#include <windows.h>
#include <TlHelp32.h>
#include <tchar.h>
#include <iostream>
#include <atlconv.h>
#include <vector>
#include <inttypes.h>
#include <capstone/capstone.h>

#pragma comment(lib,"capstone64.lib")

using namespace std;

// 存放PE信息段
struct PeTextInfo
{
DWORD64 virtualAddress; // 节区在内存的偏移
DWORD64 pointerToRawData; // 节区在文件中的偏移
DWORD64 size; // 大小
};

// 存放进程内所有模块信息
typedef struct
{
char modulePath[256]; // 模块路径
char moduleName[128]; // 模块名
long long moduleBase; // 模块基址
}ModuleInfo;

// 存放反汇编数据
typedef struct
{
int opCodeSize; // 机器码长度
int opStringSize; // 反汇编长度
unsigned long long address;// 相对地址
unsigned char opCode[16]; // 机器码
char opString[256]; // 反汇编
}DisassemblyInfo;

// 全局PE结构
IMAGE_DOS_HEADER* dosHeader; // DOS头
IMAGE_NT_HEADERS* ntHeader; // NT头
IMAGE_FILE_HEADER* fileHeader; // 标准PE头
IMAGE_OPTIONAL_HEADER64* optionalHeader; // 可选PE头
IMAGE_SECTION_HEADER* sectionHeader; // 节表

进程与线程

在进程与线程处理模块中,我们定义了三个函数:GetProcessHandleByNameGetProcessIDByNameGetModuleInfoByProcessNameGetProcessHandleByName函数接收一个进程名并返回该进程的句柄,方便后续的进程操作;GetProcessIDByName函数通过进程名获取其对应的PID(进程标识符),用于标识特定进程;GetModuleInfoByProcessName函数接收一个进程名并返回该进程内所有模块的信息,包括模块路径、模块名和模块基址,便于对进程内的模块进行分析和处理。

// -----------------------------------------------------------------------------------
// 进程线程部分
// -----------------------------------------------------------------------------------

// 通过进程名获取进程句柄
// 参数:
// processName - 进程名
// 返回值:
// 进程句柄
HANDLE GetProcessHandleByName(PCHAR processName)
{
// 初始化进程快照
PROCESSENTRY32 processEntry;
processEntry.dwSize = sizeof(PROCESSENTRY32);

// 获得快照句柄
HANDLE processSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

// 获取第一个进程
Process32First(processSnap, &processEntry);
do
{
USES_CONVERSION;
if (strcmp(processName, W2A(processEntry.szExeFile)) == 0)
{
// 关闭快照句柄,避免内存泄漏
CloseHandle(processSnap);

// 返回句柄
return OpenProcess(PROCESS_ALL_ACCESS, FALSE, processEntry.th32ProcessID);
}
} while (Process32Next(processSnap, &processEntry));

// 关闭快照句柄,避免内存泄漏
CloseHandle(processSnap);
return (HANDLE)NULL;
}

// 根据进程名获取PID
// 参数:
// processName - 进程名
// 返回值:
// 进程ID
DWORD64 GetProcessIDByName(LPCTSTR processName)
{
DWORD64 processID = 0xFFFFFFFF;
HANDLE snapshot = INVALID_HANDLE_VALUE;
PROCESSENTRY32 processEntry;
processEntry.dwSize = sizeof(PROCESSENTRY32);

snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, NULL);
Process32First(snapshot, &processEntry);
do
{
if (!_tcsicmp(processName, (LPCTSTR)processEntry.szExeFile))
{
processID = processEntry.th32ProcessID;
break;
}
} while (Process32Next(snapshot, &processEntry));

CloseHandle(snapshot);
return processID;
}

// 获取进程内所有模块信息
// 参数:
// processName - 进程名
// 返回值:
// 包含模块信息的向量
std::vector<ModuleInfo> GetModuleInfoByProcessName(CHAR* processName)
{
// 读取进程中的模块信息
MODULEENTRY32 moduleEntry;
USES_CONVERSION;
DWORD64 processID = GetProcessIDByName(A2W(processName));

// 存放模块路径
std::vector<ModuleInfo> moduleInfos = {};

// 在使用这个结构前,先设置它的大小
moduleEntry.dwSize = sizeof(MODULEENTRY32);

// 获取模块快照
HANDLE moduleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processID);

// INVALID_HANDLE_VALUE表示无效的句柄
if (moduleSnap == INVALID_HANDLE_VALUE)
{
return{};
}

BOOL hasMoreModules = Module32First(moduleSnap, &moduleEntry); // 获取第一个模块信息
char* modulePath = NULL; // 模块路径
char* moduleName = NULL; // 模块名
DWORD64 moduleBase = NULL; // 模块基址

while (hasMoreModules)
{
ModuleInfo moduleInfo;

USES_CONVERSION;

// W2A 将wchar转ascii
modulePath = W2A(moduleEntry.szExePath);
moduleBase = (DWORD64)moduleEntry.modBaseAddr;
moduleName = W2A(moduleEntry.szModule);

// printf("模块路径: %s -> 模块基地址: %x -> 模块名: %s \n", ModulePath, ModuleBase, ModuleName);

strcpy_s(moduleInfo.modulePath, modulePath);
strcpy_s(moduleInfo.moduleName, moduleName);
moduleInfo.moduleBase = moduleBase;

// 放入容器内
moduleInfos.push_back(moduleInfo);
hasMoreModules = Module32Next(moduleSnap, &moduleEntry);
}

CloseHandle(moduleSnap);
return moduleInfos;
}

PE文件操作

如下代码实现了PE(Portable Executable)文件的读取、解析和扩展功能。我们定义了三个主要函数:ReadPEFile用于从磁盘读取PE文件数据,ParsePEHeaders用于解析PE文件的头信息,ExpandPEImageBuffer用于将PE文件扩展为内存中加载后的形式,并复制文件中的各个节(section)到内存中。最后,GetCodeSectionInfo函数获取了PE文件中代码段的起始地址和大小信息。

// -----------------------------------------------------------------------------------
// PE文件读写部分
// -----------------------------------------------------------------------------------

// 读取硬盘PE文件数据
// 参数:
// filePath - 文件路径
// fileBuffer - 文件缓冲区指针
// 返回值:
// 文件大小
DWORD64 ReadPEFile(LPSTR filePath, LPVOID* fileBuffer)
{
FILE* file = NULL;

fopen_s(&file, filePath, "rb");
if (file == NULL)
{
return 0;
}
else
{
// 计算文件大小
fseek(file, 0, SEEK_END);
long long fileSize = ftell(file);
fseek(file, 0, SEEK_SET);

// 开辟指定大小的内存
LPVOID buffer = malloc(sizeof(char) * fileSize);
if (buffer == NULL)
{
fclose(file);
return 0;
}
// 将文件数据拷贝到缓冲区
size_t bytesRead = fread(buffer, sizeof(char), fileSize, file);
if (!bytesRead)
{
free(buffer);
fclose(file);
return 0;
}
*fileBuffer = buffer;
buffer = NULL;

fclose(file);
return fileSize;
}
return 0;
}

// 读取PE头信息
// 参数:
// fileBuffer - 文件缓冲区指针
// 返回值:
// 成功返回1,失败返回0
DWORD64 ParsePEHeaders(LPVOID fileBuffer)
{
if (fileBuffer == NULL)
{
// 缓冲区指针无效
return 0;
}

// 判断是否是有效的MZ标记
if (*((PWORD)fileBuffer) != IMAGE_DOS_SIGNATURE)
{
return 0;
}

dosHeader = (IMAGE_DOS_HEADER*)fileBuffer;

// 判断是否是有效的pe标志
if (*((PDWORD)((DWORD64)fileBuffer + dosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE)
{
return 0;
}

ntHeader = (IMAGE_NT_HEADERS*)((DWORD64)fileBuffer + dosHeader->e_lfanew); // NT头赋值
fileHeader = (IMAGE_FILE_HEADER*)((DWORD64)ntHeader + 4); // 标准PE头赋值
optionalHeader = (IMAGE_OPTIONAL_HEADER64*)((DWORD64)fileHeader + IMAGE_SIZEOF_FILE_HEADER); // 可选PE头赋值,标准PE头地址+标准PE头大小
sectionHeader = (IMAGE_SECTION_HEADER*)((DWORD64)optionalHeader + fileHeader->SizeOfOptionalHeader); // 第一个节表 可选PE头地址+可选PE头大小
return 1;
}

// 拉伸PE结构
// 参数:
// fileBuffer - 硬盘状态的PE数据指针
// imageBuffer - 用来存放拉伸后的PE数据的指针
// 返回值:
// PE镜像大小
DWORD64 ExpandPEImageBuffer(LPVOID fileBuffer, LPVOID* imageBuffer)
{
if (fileBuffer == NULL)
{
return 0;
}

// 申请ImageBuffer所需的内存空间
LPVOID buffer = malloc(sizeof(char) * optionalHeader->SizeOfImage);
if (buffer == NULL)
{
return 0;
}

memset(buffer, 0, optionalHeader->SizeOfImage); // 将空间初始化为0
memcpy(buffer, fileBuffer, optionalHeader->SizeOfHeaders); // 把头+节表+对齐的内存复制过去

// 复制节
for (int i = 0; i < fileHeader->NumberOfSections; i++)
{
buffer = (LPVOID)((DWORD64)buffer + (sectionHeader + i)->VirtualAddress); // 定位这个节内存中的偏移
fileBuffer = (LPVOID)((DWORD64)fileBuffer + (sectionHeader + i)->PointerToRawData); // 定位这个节在文件中的偏移
memcpy(buffer, fileBuffer, (sectionHeader + i)->SizeOfRawData); // 复制节在文件中所占的内存过去
buffer = (LPVOID)((DWORD64)buffer - (sectionHeader + i)->VirtualAddress); // 恢复到起始位置
fileBuffer = (LPVOID)((DWORD64)fileBuffer - (sectionHeader + i)->PointerToRawData); // 恢复到起始位置
}

*imageBuffer = buffer;
buffer = NULL;
return optionalHeader->SizeOfImage;
}

// 获取本程序代码段在内存中的起始地址和大小
// 参数:
// textInfo - 存放代码段信息的结构体指针
// 返回值:
// 代码段的数量
DWORD64 GetCodeSectionInfo(PeTextInfo* textInfo)
{
int length = 0;
for (int i = 0; i < fileHeader->NumberOfSections; i++)
{
// 判断是否是可执行的代码
if (((sectionHeader + i)->Characteristics & 0x20000000) == 0x20000000)
{
(textInfo + length)->virtualAddress = (sectionHeader + i)->VirtualAddress;
(textInfo + length)->pointerToRawData = (sectionHeader + i)->PointerToRawData;
(textInfo + length)->size = (sectionHeader + i)->SizeOfRawData;
length++;
}
}
return length;
}

反汇编与扫描

反汇编部分通过定义DisassembleCode函数,该函数接收一个起始地址及代码长度,当执行结束后会将反汇编结果放入到DisassemblyInfo容器内返回给用户,具体的反汇编实现细节可自行参考代码学习。

// -----------------------------------------------------------------------------------
// 反汇编部分
// -----------------------------------------------------------------------------------

// 反汇编字符串
// 参数:
// startOffset - 起始地址
// size - 代码大小
// 返回值:
// 包含反汇编信息的向量

std::vector<DisassemblyInfo> DisassembleCode(unsigned char *startOffset, int size)
{
std::vector<DisassemblyInfo> disassemblyInfos = {};

csh handle;
cs_insn *insn;
size_t count;

// 打开句柄
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle) != CS_ERR_OK)
{
return{};
}

// 反汇编代码,地址从0x0开始,返回总条数
count = cs_disasm(handle, (unsigned char *)startOffset, size, 0x0, 0, &insn);

if (count > 0)
{
DWORD index;

// 循环反汇编代码
for (index = 0; index < count; index++)
{
// 清空
DisassemblyInfo disasmInfo;
memset(&disasmInfo, 0, sizeof(DisassemblyInfo));

// 循环拷贝机器码
for (int x = 0; x < insn[index].size; x++)
{
disasmInfo.opCode[x] = insn[index].bytes[x];
}

// 拷贝地址长度
disasmInfo.address = insn[index].address;
disasmInfo.opCodeSize = insn[index].size;

// 拷贝反汇编指令
strcpy_s(disasmInfo.opString, insn[index].mnemonic);
strcat_s(disasmInfo.opString, " ");
strcat_s(disasmInfo.opString, insn[index].op_str);

// 得到反汇编长度
disasmInfo.opStringSize = (int)strlen(disasmInfo.opString);

disassemblyInfos.push_back(disasmInfo);
}
cs_free(insn, count);
}
else
{
return{};
}
cs_close(&handle);
return disassemblyInfos;
}

最后我们在主函数中来实现反汇编比对逻辑,首先我们分别指定一个磁盘文件路径并将其放入到fullPath变量内,然后通过GetModuleInfoByProcessName得到进程内的所有加载模块信息,并对比进程内模块是否为Win32Project.exe也就是进程自身,当然此处也可被替换为例如user32.dll等模块,当磁盘与内存被读入后,通过ParsePEHeaders解析PE头信息,并将PE文件通过ExpandPEImageBuffer拉伸到内存中模拟加载后的状态。

随后,通过GetCodeSectionInfo获取代码节的地址和大小,将磁盘和内存中的代码段数据分别读取到缓冲区中。最后,通过Capstone反汇编库对磁盘和内存中的代码段进行反汇编,并逐条memcmp对比反汇编指令,以检测代码是否被篡改。整个过程包括文件读取、内存解析、反汇编和数据对比,最后输出检测结果并释放分配的内存资源。

int main(int argc, char *argv[])
{
DWORD64 fileSize = 0;
LPVOID fileBuffer = NULL;

// 从完整路径中获取文件名
CHAR fullPath[256] = { 0 };
CHAR fileName[64] = { 0 }, *p = NULL;

strcpy_s(fullPath, "d:\\Win32Project.exe");
strcpy_s(fileName, (p = strrchr(fullPath, '\\')) ? p + 1 : fullPath);

// 打开进程
HANDLE processHandle = GetProcessHandleByName(fileName);

// 循环输出所有模块信息
std::vector<ModuleInfo> moduleInfos = GetModuleInfoByProcessName(fileName);

for (int i = 0; i < moduleInfos.size(); i++)
{
if (strcmp(moduleInfos[i].moduleName, "Win32Project.exe") == 0)
{
printf("[*] 模块基地址: 0x%I64X | 模块路径: %s \n", moduleInfos[i].moduleBase, moduleInfos[i].modulePath);

// 读取磁盘PE文件
fileSize = ReadPEFile(moduleInfos[i].modulePath, &fileBuffer);

// 解析PE头
DWORD64 ref = ParsePEHeaders(fileBuffer);

// 拉伸PE
LPVOID imageBuffer = NULL;
DWORD64 sizeOfImage = ExpandPEImageBuffer(fileBuffer, &imageBuffer);

// 获取.text节地址
PeTextInfo textInfo;
DWORD64 textSectionCount = GetCodeSectionInfo(&textInfo);

// 读入磁盘数据
unsigned char *fileTextBuffer = NULL;
fileTextBuffer = (unsigned char *)malloc((textInfo.size));
memcpy(fileTextBuffer, (unsigned char *)((DWORD64)imageBuffer + textInfo.virtualAddress), textInfo.size);

// 读入内存数据
unsigned char *memoryTextBuffer = NULL;
DWORD64 protectTemp = NULL;

DWORD64 moduleBase = moduleInfos[i].moduleBase;

memoryTextBuffer = (unsigned char *)malloc(textInfo.size);

for (int j = 0; j < textInfo.size; j++)
{
ReadProcessMemory(processHandle, (LPVOID)(moduleBase + textInfo.virtualAddress), memoryTextBuffer, sizeof(char) * textInfo.size, NULL);
}

// 开始反汇编
std::vector<DisassemblyInfo> fileDisassembly = DisassembleCode(fileTextBuffer, textInfo.size);
std::vector<DisassemblyInfo> memoryDisassembly = DisassembleCode(memoryTextBuffer, textInfo.size);

for (int k = 0; k < fileDisassembly.size(); k++)
{
printf("0x%I64X | ", moduleBase + memoryDisassembly[k].address);
printf("文件汇编: %-45s | ", fileDisassembly[k].opString);
printf("内存汇编: %-45s | ", memoryDisassembly[k].opString);

// 开始对比
if (memcmp(fileDisassembly[k].opCode, memoryDisassembly[k].opCode, fileDisassembly[k].opCodeSize) != 0)
{
// 被挂钩
printf("文件=> ");
for (int l = 0; l < fileDisassembly[k].opCodeSize; l++)
{
printf("0x%02X ", fileDisassembly[k].opCode[l]);
}
printf(" 内存=> ");
for (int m = 0; m < memoryDisassembly[k].opCodeSize; m++)
{
printf("0x%02X ", memoryDisassembly[k].opCode[m]);
}
}
printf("\n");
}

// 释放
imageBuffer = NULL;
free(fileBuffer);
free(fileTextBuffer);
free(memoryTextBuffer);
}
}

system("pause");
return 0;
}

为了测试扫描效果,我们可以启动一个64位应用程序,此处为Win32Project.exe进程,通过x64dbg附加,并跳转到Win32Project.exe的程序领空,如下图所示;

20240813170238

此时我们随意找一处位置,这里就选择00007FF6973110E6处,并将其原始代码由int3修改为nop长度为6字节,如下图所示;

20240813170350

至此,我们编译并运行lyshark.exe程序,此时则可输出Win32Project.exe进程中的第一个模块也就是Win32project.exe的挂钩情况,输出效果如下图所示;

20240813171537