逆向基础-PE文件结构

最新推荐文章于 2024-03-12 16:47:46 发布

Star_WPF上位机开发

最新推荐文章于 2024-03-12 16:47:46 发布

阅读量338

点赞数 1

分类专栏：逆向文章标签： c++ 开发语言安全

本文链接：https://blog.csdn.net/AppWhite_Star/article/details/126073406

版权

逆向专栏收录该内容

10 篇文章 5 订阅

订阅专栏

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 <iostream>
#include <Windows.h>

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 <iostream>
#include <Windows.h>

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 <iostream>

/*
	@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 <Windows.h>

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 <stdio.h>

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 <Windows.h>

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 <Windows.h>

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 <Windows.h>
#include <iostream>

__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 <Windows.h>
#include <iostream>

// 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;
}