PE文件解析
什么是PE文件？
PE文件是在windows平台可执行的文件。
包括：.exe可执行文件，.dll动态链接库,.sys驱动程序
DOS头：
struct _IMAGE_DOS_HEADER{
WORD e_magic;
.....
DWORD e_lfanew;
}
这个结构体的大小是64个字节,但是对我们来说最重要的两个字段就是这两个。
e_magic是一个标志，表示这是一个PE文件，DOS头。
e_lfanew保存了距离PE头的偏移。
#include
#include
int main() {
HANDLE hFile = CreateFileA(
"crackme0032.exe",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
DWORD realRead = 0;
// 获取文件的大小
DWORD fileSize = GetFileSize(hFile, NULL);
// 根据文件大小创建缓冲区
CHAR* fileBuff = new CHAR[fileSize];
// 把PE文件读取到内存里面
BOOL bSuccess = ReadFile(hFile, fileBuff, fileSize, &realRead, NULL);
CloseHandle(hFile);
// 解析PE文件
if (bSuccess) {
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)fileBuff;
if (pDosHeader->e_magic != 0x5A4D) {
printf("不是一个有效的PE文件\n");
delete[] fileBuff;
system("pause");
return 0;
}
printf("距离PE头的偏移：%x\n", pDosHeader->e_lfanew);
}
// 释放内存
delete[] fileBuff;
// 暂停窗口
system("pause");
return 0;
}
PE头解析
PE头又叫做NT头，它是我们这个PE文件真正的头部，DOS头只是为了兼容以前的DOS系统。
PE头位于DOS Stub后面，是以PE00为起始标志，就是以0X4550为标志。
NT/PE头：
typedef struct _IMAGE_NT_HEADERS{
DWORD Signature; // PE标志0X4550
IMAGE_FILE_HEADER FileHeader; // 文件头
IMAGE_OPTIONAL_HEADER OptinalHeader; // 可选PE头
}
文件头：
typedef struct _IMAGE_FILE_HEADER {
WORD Machine; // 程序允许的CPU型号 0表示能在任何CPU上运行
WORD NumberOfSections; // 文件中存在的区段的数量
.......
WORD SizeOfOptionalHeader; // 可选PE头的大小 32位pe默认E0,64位默认F0
WORD Characteristics; // 文件属性不同位含义不同
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
#include
#include
int main() {
// crackme0032.exe
HANDLE hFile = CreateFileA(
"crackme0032.exe",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
DWORD realRead = 0; // 实际读取的大小
DWORD fileSize = GetFileSize(hFile, 0);
CHAR* fileBuff = new CHAR[fileSize];
BOOL bSuccess = ReadFile(hFile, fileBuff, fileSize, &realRead, 0);
CloseHandle(hFile);
if (bSuccess) {
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)fileBuff;
if(pDosHeader->e_magic != 0x5A4D){
printf("不是一个有效的pe文件\n");
delete[] fileBuff;
system("pause");
return 0;
}
printf("距离PE头的偏移：%x\n",pDosHeader->e_lfanew);
// 解析PE头
PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(fileBuff + (DWORD)pDosHeader->e_lfanew);
if (pNtHeader->Signature != 0x4550) {
printf("不是一个有效的pe文件\n");
delete[] fileBuff;
system("pause");
return 0;
}
// 那么就可以解析标准文件头和可选文件头
PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)&pNtHeader->FileHeader;
printf("支持的CPU型号：%x\n",pFileHeader->Machine);
printf("区段的数量：%d\n",pFileHeader->NumberOfSections);
printf("可选PE头的大小：%x\n",pFileHeader->SizeOfOptionalHeader);
printf("当前PE文件的属性：%x\n",pFileHeader->Characteristics);
}
delete[] fileBuff;
// 暂停窗口
system("pause");
return 0;
}
可选PE头解析
可选PE头：
typedef struct _IMAGE_OPTIONAL_HEADER {
WORD Magic; 表示是32位的PE文件还是64位的PE文件 10B 20B
DWORD AddressOfEntryPoint; 程序的入口偏移 OEP
DWORD ImageBase; 内存镜像地址,即起始位置[关闭随机基址后]
DWORD SectionAlignment; 内存对齐大小 默认1000H
DWORD FileAlignment; 文件对齐大小 默认200H
DWORD SizeOfImage; 文件在内存中的大小，按照内存对齐
DOS头+NT头+标准PE头+可选PE头+区段头，按照文件对齐之后的大小
DWORD SizeOfHeaders;
WORD DllCharacteristics; pe文件属性
DWORD NumberOfRvaAndSizes; 数据目录表的个数
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; 数据目录表
} IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;
区段头
有多少个区段就有多少个区段头。
typedef struct _IMAGE_SECTION_HEADER{
BYTE Name[8]; 区段的名称 和字符串不同 不会以0结尾
union{
DWORD PhysicalAddress;
DWORD VirtualSize;
}Misc; 区段在内存中的真实大小，未对齐
DWORD VirtualAddress; // 区段在内存中的偏移地址 + ImageBase为真正地址
DWORD SizeOfRawData; // 区段在文件中对齐的大小
DWORD PointerToRawData; // 区段在文件中的偏移地址
WORD Characteristics; // 属性
....
}
#include "CPeParseUtils.h"
#include
/*
@function 加载PE文件
@param path PE文件的路径
@return 是否加载成功
*/
BOOL CPeParseUtils::LoadFile(const char* path)
{
HANDLE hFile = CreateFileA(
path,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
this->m_fileSize = GetFileSize(hFile, 0);
this->m_fileBuff = new CHAR[this->m_fileSize]{0};
DWORD realRead = 0;
BOOL bSuccess = ReadFile(hFile, this->m_fileBuff, this->m_fileSize, &realRead, 0);
if (!bSuccess) {
return FALSE;
}
CloseHandle(hFile);
if (!InitPeInfo()) {
return FALSE;
}
return TRUE;
}
/*
@function 遍历区段头
*/
void CPeParseUtils::PrintSectionsHeader()
{
// 通过可选PE头的起始位置+可选PE头的大小我们就可以找到第一个区段头
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(this->m_pNtHeader);
// 在标准的文件头里面有区段的个数
CHAR strName[9] = {0};
for (size_t i = 0; i < this->m_pFileHeader->NumberOfSections; i++) {
memcpy_s(strName,9, pSectionHeader->Name, 8);
printf("当前区段头的名字：%s\n",strName);
pSectionHeader++; // 移动到下一个区段头
}
}
/*
@function 载入PE文件的信息
@param 返回是否载入成功
*/
BOOL CPeParseUtils::InitPeInfo()
{
this->m_pDosHeader = (PIMAGE_DOS_HEADER)this->m_fileBuff;
if (this->m_pDosHeader->e_magic != 0x5A4D) {
return FALSE; // 不是一个有效的PE文件
}
this->m_pNtHeader = (PIMAGE_NT_HEADERS)(this->m_fileBuff + this->m_pDosHeader->e_lfanew);
if (this->m_pNtHeader->Signature != 0x4550) {
return FALSE; // 不是一个有效的PE文件
}
this->m_pFileHeader = (PIMAGE_FILE_HEADER)&this->m_pNtHeader->FileHeader;
this->m_pOptionalHeader = (PIMAGE_OPTIONAL_HEADER)&this->m_pOptionalHeader;
return TRUE;
}
CPeParseUtils::CPeParseUtils()
{
this->m_fileSize = 0;
this->m_fileBuff = nullptr;
this->m_pDosHeader = nullptr;
this->m_pNtHeader = nullptr;
this->m_pFileHeader = nullptr;
this->m_pOptionalHeader = nullptr;
}
CPeParseUtils::~CPeParseUtils()
{
if (this->m_fileBuff != nullptr) {
delete[] this->m_fileBuff;
this->m_fileBuff = nullptr;
}
this->m_fileSize = 0;
this->m_pDosHeader = nullptr;
this->m_pNtHeader = nullptr;
this->m_pFileHeader = nullptr;
this->m_pOptionalHeader = nullptr;
}
导出表
typedef struct _IMAGE_DATA_DIRECTORY{
DWORD VirtualAddress; // 内存中的偏移RVA内存偏移
FOA FOA + FileBuff = 导出表的地址。
DWORD Size
}
// 导出表结构体
typedef struct _IMAGE_EXPORT_DIRECTORY{
DWORD Name; // 导出表的文件名的RVA偏移地址
DWORD Base; // 导出函数的起始序号
DWORD NumberFunctions; // 导出函数的个数【最大的导出序号-最小的到处序号+1】
DWORD NumberOfName; // 以名称导出函数的个数
DWORD AddressOfFunctions; // 导出函数地址表的RVA
DWORD AddressOfName; // 导出函数名称表的RVA
DWORD AddressOfNameOrdinals; // 导出函数序号表的RVA
}
函数名称表和函数序号表是一一对应的。
然后函数序号表中保存的值是地址表的索引。
反过来就是我们可以通过函数地址表的索引去找到对应的函数序号，然后就可以找到对应的函数名
RVA转FOA，是针对区段的，因为前面DOS头那些加载到内存里面并没有发生变化。
找到属于哪个区段以后
RVA - 区段在内存中的起始偏移位置 = FOA - 区段在文件中的起始偏移位置
即他们距离区段的起始位置的偏移应该是一样的
那么FOA = RVA - 区段在内存中的起始偏移位置 + 区段在文件中的起始偏移位置
#pragma once
#include
class CPeParseUtils
{
public:
CPeParseUtils();
~CPeParseUtils();
BOOL LoadFile(const char* path);
void PrintSectionsHeader(); // 遍历区段头
void GetExportTable();// 解析导出表
private:
BOOL InitPeInfo();
// FOA = RVA - 区段在内存中的起始偏移位置 + 区段在文件中的起始偏移位置
DWORD RvaToFoa(DWORD rva);
private:
CHAR* m_fileBuff;
DWORD m_fileSize;
PIMAGE_DOS_HEADER m_pDosHeader;
PIMAGE_NT_HEADERS m_pNtHeader;
PIMAGE_FILE_HEADER m_pFileHeader;
PIMAGE_OPTIONAL_HEADER m_pOptionalHeader;
};
#include "CPeParseUtils.h"
#include
CPeParseUtils::CPeParseUtils() {
this->m_fileBuff = nullptr;
this->m_fileSize = 0;
this->m_pDosHeader = nullptr;
this->m_pNtHeader = nullptr;
this->m_pFileHeader = nullptr;
this->m_pOptionalHeader = nullptr;
}
CPeParseUtils::~CPeParseUtils() {
if (this->m_fileBuff) {
delete[] this->m_fileBuff;
this->m_fileBuff = nullptr;
}
this->m_fileSize = 0;
this->m_pDosHeader = nullptr;
this->m_pNtHeader = nullptr;
this->m_pFileHeader = nullptr;
this->m_pOptionalHeader = nullptr;
}
// 加载pe文件
BOOL CPeParseUtils::LoadFile(const char* filePath) {
HANDLE hFile = CreateFileA(filePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
// 那么我们就要获取文件大小
this->m_fileSize = GetFileSize(hFile, NULL);
this->m_fileBuff = new char[this->m_fileSize]{0};
if (this->m_fileBuff == nullptr) {
CloseHandle(hFile);
return FALSE;
}
// 接着就是从硬盘加载到内存
DWORD readRead = 0;
if (!ReadFile(hFile, this->m_fileBuff, this->m_fileSize, &readRead, NULL)) {
// 如果读取失败
CloseHandle(hFile);
return FALSE;
}
// 读取成功 那么去解析
if (!InitPeInfo()) {
CloseHandle(hFile);
return FALSE;
}
CloseHandle(hFile);
return TRUE;
}
// 打印区段头信息
void CPeParseUtils::PrintSectionsHeader() {
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(this->m_pNtHeader);
for (int i = 0; i < this->m_pFileHeader->NumberOfSections; i++) {
char sectioName[9]{ 0 };
memcpy(sectioName, pSectionHeader->Name,8);
printf("区段头名称：%s\n", sectioName);
pSectionHeader++; // 每次移动一个Header大小
}
}
// FOA = 数据的RVA - 区段的RVA + 区段的FOA
// 获得导出表
void CPeParseUtils::GetExportTable() {
IMAGE_DATA_DIRECTORY dataDict = this->m_pOptionalHeader->DataDirectory[0];
PIMAGE_EXPORT_DIRECTORY pExPortDict = (PIMAGE_EXPORT_DIRECTORY)(RvaToFoa(dataDict.VirtualAddress) + this->m_fileBuff);
char* dllName = (RvaToFoa(pExPortDict->Name) + this->m_fileBuff);
printf("导出表文件名字%s\n", dllName);
// 这个个数不准确的 最大序号-最小序号+1
printf("导出表导出函数的个数%d\n", pExPortDict->NumberOfFunctions);
// 这里拿到的是函数地址表的地址 里面的内容也就是第一个函数的地址
DWORD* funAddr = (DWORD*)(RvaToFoa(pExPortDict->AddressOfFunctions) + this->m_fileBuff);
// 同理我们去取得函数的名称表的地址
DWORD* nameAddr = (DWORD*)(RvaToFoa(pExPortDict->AddressOfNames) + this->m_fileBuff);
// 同理拿到序号表 拿到的序号表是一个word类型的数组
WORD* ordinalsAddr = (WORD*)(RvaToFoa(pExPortDict->AddressOfNameOrdinals) + this->m_fileBuff);
for (int i = 0; i < pExPortDict->NumberOfFunctions; i++) {
printf("函数地址为：%x\n",funAddr[i]);
// 然后遍历序号表 有没有对应的函数地址的索引
for (int j = 0; j < pExPortDict->NumberOfNames; j++) {
if (ordinalsAddr[j] == i) {
// 如果序号表中保存了地址表的索引 那么这个函数就有名称
char* funName = (RvaToFoa(nameAddr[j]) + this->m_fileBuff);
printf("函数名：%s\n", funName);
}
}
}
}
// 解析pe文件
BOOL CPeParseUtils::InitPeInfo() {
// 通过前面我们已经拿到了数据段缓冲区 那么这个数据段最开始就是DOS头部
this->m_pDosHeader = (PIMAGE_DOS_HEADER)this->m_fileBuff;
if (this->m_pDosHeader->e_magic != 0x5A4D) {
return FALSE; // 不是一个有效的PE文件
}
// 那么通过偏移我们就可以拿到我们的pe头
this->m_pNtHeader = (PIMAGE_NT_HEADERS)(this->m_fileBuff + this->m_pDosHeader->e_lfanew);
if (this->m_pNtHeader->Signature != 0x4550) {
return FALSE; // 不是一个有效的pe文件
}
// 那么我们就可以通过pe头拿到文件头和可选pe头
// 文件头有 NumberOfSections 去段的数量
// SizeOfOptionalHeader 可选pe头的大小
this->m_pFileHeader = (PIMAGE_FILE_HEADER)&this->m_pNtHeader->FileHeader;
// AddressOfEntryPoint 程序的入口
// BaseOfCode 程序开始的位置 固定基址
// SectionAlignment在内存中对齐的大小
// FileAlignment在硬盘中对齐的大小
// DataDirectory数据目录表
this->m_pOptionalHeader = (PIMAGE_OPTIONAL_HEADER)&this->m_pNtHeader->OptionalHeader;
return TRUE;
}
// RVA转FOA
DWORD CPeParseUtils::RvaToFoa(DWORD RVA) {
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(this->m_pNtHeader);
// 获取第一个区段头
pSectionHeader = IMAGE_FIRST_SECTION(this->m_pNtHeader);
for (int i = 0; i < this->m_pFileHeader->NumberOfSections;i++) {
if (RVA >= pSectionHeader->VirtualAddress &&
RVA < (pSectionHeader->VirtualAddress + pSectionHeader->Misc.VirtualSize)) {
return (RVA - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData);
}
pSectionHeader++;
}
return 0;
}
导入表
导入表的准备知识点：
1.调用dll文件函数原理
-程序在调用dll文件函数的时候，不是把dll文件函数的代码编译到当前文件中。而是把dll文件对应的函数地址保存到了当前文件中
2.一个进程空间中的exe，ell文件如何被加载到内存
3.exe文件调用的动态链接库在内存中与硬盘中有什么不同
-运行起来的时候我们发现调用dll的函数是通过一个函数地址去调用的
-但是我们发现在文件当中对应的函数地址部分存储的是函数名称
-因为dll加载进去内存的时候所记载的地址不是固定的，不一定可以占到自己想要的位置，所以在还没有加载进去内存的时候我们无法确定函数的地址。
-所以我们进行保存函数的名字，当dll被加载进入内存的时候，我们再把函数的名字修复为函数的地址。
总结：
-1.LoadLibraryA加载dll文件到2个G的内存中，首先程序会加载进来exe文件，然后看exe文件调用了那些dll，然后把这些dll加载进来内存
-2.然后可以拿到一个HMODULE，也就是IMAGEBASE
-3.我们知道在文件中保存的是dll的名字，然后这个时候有了IMAGEBASE就可以通过GetProcessAddr，把函数的名称修复为函数的地址了
导出表只有一份，但是导入表有很多份，因为一个exe可能使用了很多个dll
typedef struct _IMAGE_IMPORT_DESCRIPTOR{
union{
DWORD Characteristics;
DWORD OriginalFirstTunk; // 输入名称表的结构体数组
};
......
DWORD Name; // dll的名字的Rva
DWORD FirstThunk; // 输入地址表的的结构体数组，在文件中的时候也是名称
};
指向IMAGE_THUNK_DATA结构的数组
最高位如果为1就是序号导入，剩下31位就是真正的序号
typedef struct _IMAGE_THUNK_DATA32{
union{
DWORD ForwarderString;
DWORD Function; // 函数地址
DWORD Ordinal; // 函数序号
DWORD AddressOfData; // 名字指向PIMAGE_IMPORT_BY_NAME rva
}ul;
}
typedef struct _IMAGE_IMPORT_BY_NAME{
WORD Hint; // 导入函数索引
CHAR Name[1]
}
#pragma once
#include
class CPeParseUtils
{
public:
CPeParseUtils();
~CPeParseUtils();
BOOL LoadFile(const char* path);
void PrintSectionsHeader(); // 遍历区段头
void GetExportTable();// 解析导出表
void GetImportTables();// 解析导入表
private:
BOOL InitPeInfo();
// FOA = RVA - 区段在内存中的起始偏移位置 + 区段在文件中的起始偏移位置
DWORD RvaToFoa(DWORD rva);
private:
CHAR* m_fileBuff;
DWORD m_fileSize;
PIMAGE_DOS_HEADER m_pDosHeader;
PIMAGE_NT_HEADERS m_pNtHeader;
PIMAGE_FILE_HEADER m_pFileHeader;
PIMAGE_OPTIONAL_HEADER m_pOptionalHeader;
};
重定位表
全局变量在编译的时候就确定了地址，但是我们前面有说PE文件加载到内存中的位置是不确定的。不一定可以占到想要的地址。
那么如果占用不到想要的地址，那么全局变量的地址不就存在问题了。
操作系统在编译的时候会观察我们有多少个这样写死的地址，然后会创建多张表，叫做重定位表。
这些表就用来存放这些写死的地址的数据位置。那么有了这些数据的位置，我们根据加载的位置对其进行地址的修复，那不就可以正常使用了。
重定位表在数据目录表中的第5项。
typedef struct _IMAGE_BASE_RELOCATION{
DWORD VirtualAddress; // 大的偏移位置
DWORD SizeOfBlock; // 整个颜色的大小
}
整个颜色的大小 - 0x8 = 剩下所有小块的大小
剩下所有小块的大小 / 2 就是有多少个小块
同一个颜色块只存放偏移0x1000，超过了就存在另一个块里面。
不过有的地址不一定有效，我们怎么判断一个地址是否是要修复的。
16位里面如果高4位 = 0x3的话，那么就是要修复的地址。如果不等于3就不是要修复的地址，是无效的地址。
然后低12位就是我们真正要修复的地址的偏移。
#pragma once
#include
class CPeParseUtils
{
public:
CPeParseUtils();
~CPeParseUtils();
BOOL LoadFile(const char* path);
void PrintSectionsHeader(); // 遍历区段头
void GetExportTable();// 解析导出表
void GetImportTables();// 解析导入表
void GetReloadcation(); // 解析重定位表
private:
BOOL InitPeInfo();
// FOA = RVA - 区段在内存中的起始偏移位置 + 区段在文件中的起始偏移位置
DWORD RvaToFoa(DWORD rva);
private:
CHAR* m_fileBuff;
DWORD m_fileSize;
PIMAGE_DOS_HEADER m_pDosHeader;
PIMAGE_NT_HEADERS m_pNtHeader;
PIMAGE_FILE_HEADER m_pFileHeader;
PIMAGE_OPTIONAL_HEADER m_pOptionalHeader;
};
TLS
什么是TLS？
TLS是Thread Local Storage的缩写，线程局部存储。主要是为了解决多线程中变量同步的问题。
TLS的意义？
进程中的全局变量与函数内定义的静态变量，是各个线程都可以访问的共享变量。在一个线程修改的内存内容，对所有线程都生效。
这是一个优点也是一个缺点。说它是优点，线程的数据交换变得非常敏捷，说它是缺点，多个线程访问共享数据，需要昂贵的同步开销，也容易产生同步的BUG。
如果需要在一个线程内部的各个函数调用都能访问，但其他线程不能访问的变量（static memory local to a thread），就需要TLS来实现。
简单的说TLS变量是各个线程互相独立的变量，一方的修改不会影响另一方。
如何创建TLS变量呢？
__declspec(thread) 数据类型 变量名 = 值;
#include
#include
__declspec(thread) int g_number = 100;
HANDLE hEvent;
DWORD WINAPI threadProc1(LPVOID args) {
g_number = 200;
printf("threadProc1 g_number = %d\n", g_number);
SetEvent(hEvent); // 线程1执行完毕之后 设置事件为有状态，那么线程2的Wait就等到了信号可以执行了
return 0;
}
DWORD WINAPI threadProc2(LPVOID args) {
WaitForSingleObject(hEvent, INFINITE);
printf("threadProc2 g_number = %d\n", g_number);
return 0;
}
int main() {
// 是否自动重置FALSE 初始是否有状态 FALSE
hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
// 创建两个线程
HANDLE hThread1 = CreateThread(NULL, 0, threadProc1, NULL, 0, NULL);
HANDLE hThread2 = CreateThread(NULL, 0, threadProc2, NULL, 0, NULL);
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(hEvent);
system("pause");
return 0;
}
TLS除了用于线程同步的问题之外，在安全领域,TLS常被用来处理反调试，抢占执行等操作。
TLS回调函数：
1.首先加上编译选项：
#pragma comment(linker,"/INCLUDE:__tls_used")
2.注册TLS函数
#pragma data_seg(".CRT$XLX")
// 存储回调函数的地址 以0结尾
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = {0};
#pragma data_seg()
TLS函数啥时候被调用：
-进程创建的的时候
-线程创建的时候
-线程销毁的时候
-进程销毁的时候
#include
#include
// TLS编译选项
#pragma comment(linker,"/INCLUDE:__tls_used")
VOID NTAPI tlsProc(
PVOID DllHandle,
DWORD Reason,
PVOID Reserved
) {
if (Reason == DLL_PROCESS_ATTACH) {
BOOL result = FALSE;
HANDLE hNewHandle = 0;
DuplicateHandle(GetCurrentProcess(),
GetCurrentProcess(),
GetCurrentProcess(),
&hNewHandle,
NULL, NULL,
DUPLICATE_SAME_ACCESS);
if (result) {
MessageBoxA(0, "程序被调试了", "警告", MB_OK);
ExitProcess(0);
}
}
}
// 注册TLS回调函数
#pragma data_seg(".CRT$XLX")
// 存储回调函数的地址 以0结尾
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = {tlsProc,0};
#pragma data_seg()
int main() {
printf("main函数执行了\n");
system("pause");
return 0;
}
