Dll注入：修改PE文件 IAT注入

最新推荐文章于 2024-01-28 10:00:00 发布
最新推荐文章于 2024-01-28 10:00:00 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： C++


PE原理就不阐述了， 这个注入是PE感染的一种，通过添加一个新节注入，会改变PE文件的大小，将原有的导入表复制到新节中，并添加自己的导入表描述符，最后将数据目录项中指向的导入表的入口指向新节。

步骤：

1.添加一个新节;映射PE文件，判断是否可以加一个新节，找到节的尾部，矫正偏移，对齐RVA

填充新节PIMAGE_SECTION_HEADER，修改IMAGE_NT_HEADERS，将新节添加到文件尾部

 

2.修改导入表：判断是否使用了绑定导入表，往新节中拷贝原导入表内容，继续构造新的导入表描述符PIMAGE_IMPORT_DESCRIPTOR，构造IAT结构体PIMAGE_THUNK_DATA，填充PIMAGE_THUNK_DATA，将PIMAGE_IMPORT_DESCRIPTOR的OriginalFirstThunk和FirstThunk指向PIMAGE_THUNK_DATA，name指向DllName

最后修改导入表的VirtualAddress指向新节



#include <windows.h>
#include <iostream>
#include <exception>
#include <string>

using namespace std;

#define ERROR_MESSAGE(Msg) std::cout<<Msg<<std::endl;
BOOL    AddImportTable(const string& strTargetFile, const string& strInjectDllName, const string& strFunctionName);
BOOL    AddNewSection(const string& strTargetFile, ULONG ulNewSectionSize);
BOOL    AddNewImportDescriptor(const string& strTargetFile, const string& strInjectDllName, const string& strFunctionName);
DWORD   RVAToFOA(PIMAGE_NT_HEADERS pNtHeaders, DWORD dwRVA);
ULONG32 PEAlign(ULONG32 dwNumber, ULONG32 dwAlign);

DWORD secsize = 0;

int _tmain(int argc, _TCHAR* argv[])
{
	AddImportTable("D:\\Workspaces\\vs2013proj\\TestSome\\Debug\\chrome.dll", "twdll.dll", "func");

	system("pause");
	return true;
}

BOOL AddImportTable(const string& strTargetFile, const string& strInjectDllName, const string& strFunctionName)
{
	BOOL bOk = false;
	
	try
	{
		bOk = AddNewSection(strTargetFile, 256);
		if (!bOk)
		{
			ERROR_MESSAGE("AddImportTable:AddNewSection failed.");
			return false;
		}

		bOk = AddNewImportDescriptor(strTargetFile, strInjectDllName, strFunctionName);
		if (!bOk)
		{
			ERROR_MESSAGE("AddImportTable:AddNewImportDescriptor failed.");
			return false;
		}
	}
	catch (exception* e)
	{
		ERROR_MESSAGE((string("AddImportTable:") + e->what()).c_str());
		return false;
	}

	return true;
}

BOOL AddNewSection(const string& strTargetFile, ULONG ulNewSectionSize)
{
	BOOL bOk = true;
	HANDLE TargetFileHandle = nullptr;
	HANDLE MappingHandle = nullptr;
	PVOID FileData = nullptr;

	try
	{
		// 打开文件
		TargetFileHandle = CreateFileA(strTargetFile.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if (TargetFileHandle == INVALID_HANDLE_VALUE)
		{
			ERROR_MESSAGE(string("AddNewSection:CreateFileA error with error code:" + GetLastError()).c_str());
			bOk = false;
			goto EXIT;
		}

		ULONG ulFileSize = GetFileSize(TargetFileHandle, NULL);

		// 映射文件
		MappingHandle = CreateFileMappingA(TargetFileHandle, NULL, PAGE_READWRITE, 0, ulFileSize, NULL);
		if (MappingHandle == NULL)
		{
			ERROR_MESSAGE(string("AddNewSection:CreateFileMapping error with error code:" + GetLastError()).c_str());
			bOk = false;
			goto EXIT;
		}

		// 得到缓存头
		FileData = MapViewOfFile(MappingHandle, FILE_MAP_ALL_ACCESS, 0, 0, ulFileSize);
		if (FileData == NULL)
		{
			ERROR_MESSAGE(string("AddNewSection:MapViewOfFile error with error code:" + GetLastError()).c_str());
			bOk = false;
			goto EXIT;
		}

		// 判断是否是PE文件
		if (((PIMAGE_DOS_HEADER)FileData)->e_magic != IMAGE_DOS_SIGNATURE)
		{
			ERROR_MESSAGE("AddNewSection:Target File is not a vaild file");
			bOk = false;
			goto EXIT;
		}

		PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((ULONG_PTR)FileData + ((PIMAGE_DOS_HEADER)FileData)->e_lfanew);
		if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
		{
			ERROR_MESSAGE("AddNewSection:Target File is not a vaild file");
			bOk = false;
			goto EXIT;
		}

		// 判断是否可以增加一个新节
		if ((pNtHeaders->FileHeader.NumberOfSections + 1) * sizeof(IMAGE_SECTION_HEADER) > pNtHeaders->OptionalHeader.SizeOfHeaders/*三个部分的总大小*/)
		{
			ERROR_MESSAGE("AddNewSection:There is not enough space to add a new section.");
			bOk = false;
			goto EXIT;
		}

		// 得到新节的起始地址， 最后的起始地址
		PIMAGE_SECTION_HEADER pNewSectionHeader = (PIMAGE_SECTION_HEADER)(pNtHeaders + 1) + pNtHeaders->FileHeader.NumberOfSections;
		PIMAGE_SECTION_HEADER pLastSectionHeader = pNewSectionHeader - 1;

		// 对齐RVA和偏移
		DWORD FileSize = PEAlign(ulNewSectionSize, pNtHeaders->OptionalHeader.FileAlignment);
		DWORD FileOffset = PEAlign(pLastSectionHeader->PointerToRawData + pLastSectionHeader->SizeOfRawData, pNtHeaders->OptionalHeader.FileAlignment);
		DWORD VirtualSize = PEAlign(ulNewSectionSize, pNtHeaders->OptionalHeader.SectionAlignment);
		DWORD VirtualOffset = PEAlign(pLastSectionHeader->VirtualAddress + pLastSectionHeader->Misc.VirtualSize, pNtHeaders->OptionalHeader.SectionAlignment);

		//mod
		secsize = FileSize;

		// 填充新节表
		memcpy(pNewSectionHeader->Name, "Inject", strlen("Inject"));
		pNewSectionHeader->VirtualAddress = VirtualOffset;
		pNewSectionHeader->Misc.VirtualSize = VirtualSize;
		pNewSectionHeader->PointerToRawData = FileOffset;
		pNewSectionHeader->SizeOfRawData = FileSize;
		pNewSectionHeader->Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;

		// 修改IMAGE_NT_HEADERS
		pNtHeaders->FileHeader.NumberOfSections++;
		pNtHeaders->OptionalHeader.SizeOfImage += VirtualSize;
		pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;            // 关闭绑定导入
		pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;

		// 添加新节到文件尾部
		SetFilePointer(TargetFileHandle, 0, 0, FILE_END);
		PCHAR pNewSectionContent = new CHAR[FileSize];
		RtlZeroMemory(pNewSectionContent, FileSize);
		DWORD dwWrittenLength = 0;
		bOk = WriteFile(TargetFileHandle, pNewSectionContent, FileSize, &dwWrittenLength, nullptr);
		if (bOk == false)
		{
			ERROR_MESSAGE(string("AddNewSection:WriteFile error with error code:" + GetLastError()).c_str());
			bOk = false;
			goto EXIT;
		}
	}
	catch (exception* e)
	{
		ERROR_MESSAGE((string("AddNewSection:") + e->what()).c_str());
		bOk = false;
	}
EXIT:
	if (TargetFileHandle != NULL)
	{
		CloseHandle(TargetFileHandle);
		TargetFileHandle = nullptr;
	}
	if (FileData != NULL)
	{
		UnmapViewOfFile(FileData);
		FileData = nullptr;
	}
	if (MappingHandle != NULL)
	{
		CloseHandle(MappingHandle);
		MappingHandle = nullptr;
	}

	return bOk;
}

ULONG32 PEAlign(ULONG32 dwNumber, ULONG32 dwAlign)
{
	return(((dwNumber + dwAlign - 1) / dwAlign) * dwAlign);        //  想 dwAlign 对齐，加上 dwAlign - 1，这样就可以保证对齐后的值 >= dwNumber
}

BOOL AddNewImportDescriptor(const string& strTargetFile, const string& strInjectDllName, const string& strFunctionName)
{
	bool bOk = true;
	HANDLE TargetFileHandle = nullptr;
	HANDLE MappingHandle = nullptr;
	PVOID FileData = nullptr;
	PIMAGE_IMPORT_DESCRIPTOR pImportTable = nullptr;

	try
	{
		// 打开文件
		TargetFileHandle = CreateFileA(strTargetFile.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if (TargetFileHandle == INVALID_HANDLE_VALUE)
		{
			ERROR_MESSAGE(string("AddNewImportDescriptor:CreateFileA error with error code:" + GetLastError()).c_str());
			bOk = false;
			goto EXIT;
		}

		ULONG ulFileSize = GetFileSize(TargetFileHandle, NULL);

		// 映射文件
		MappingHandle = CreateFileMappingA(TargetFileHandle, NULL, PAGE_READWRITE, 0, ulFileSize, NULL);
		if (MappingHandle == NULL)
		{
			cout << "AddNewImportDescriptor:CreateFileMapping error with error code:" << std::to_string(GetLastError()).c_str();
			bOk = false;
			goto EXIT;
		}

		// 得到缓存头
		FileData = MapViewOfFile(MappingHandle, FILE_MAP_ALL_ACCESS, 0, 0, ulFileSize);
		if (FileData == NULL)
		{
			ERROR_MESSAGE(string("AddNewImportDescriptor:MapViewOfFile error with error code:" + GetLastError()).c_str());
			bOk = false;
			goto EXIT;
		}

		// 判断是否是PE文件
		if (((PIMAGE_DOS_HEADER)FileData)->e_magic != IMAGE_DOS_SIGNATURE)
		{
			ERROR_MESSAGE("AddNewImportDescriptor:Target File is not a vaild file");
			bOk = false;
			goto EXIT;
		}

		PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((ULONG_PTR)FileData + ((PIMAGE_DOS_HEADER)FileData)->e_lfanew);
		if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
		{
			ERROR_MESSAGE("AddNewImportDescriptor:Target File is not a vaild file");
			bOk = false;
			goto EXIT;
		}

		// 得到原导入表
		pImportTable = (PIMAGE_IMPORT_DESCRIPTOR)((ULONG_PTR)FileData + RVAToFOA(pNtHeaders, pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress));
		// 判断是否使用了绑定导入表
		bool bBoundImport = false;
		if (pImportTable->Characteristics == 0 && pImportTable->FirstThunk != 0)
		{
			// 桥一为0 桥二不是0 说明使用了绑定导入表
			bBoundImport = true;
			pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;    // 关闭绑定导入
			pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;
		}

		// 找到自己添加的新节
		PIMAGE_SECTION_HEADER pNewSectionHeader = (PIMAGE_SECTION_HEADER)(pNtHeaders + 1) + pNtHeaders->FileHeader.NumberOfSections - 1;
		PBYTE pNewSectionData = pNewSectionHeader->PointerToRawData + (PBYTE)FileData;
		memset(pNewSectionData, 0, secsize);
		PBYTE pNewImportDescriptor = pNewSectionData;
		// 往新节中拷贝原导入表内容
		int i = 0;
		while (pImportTable->FirstThunk != 0 || pImportTable->Characteristics != 0)
		{
			memcpy(pNewSectionData + i * sizeof(IMAGE_IMPORT_DESCRIPTOR), pImportTable, sizeof(IMAGE_IMPORT_DESCRIPTOR));
			pImportTable++;
			pNewImportDescriptor += sizeof(IMAGE_IMPORT_DESCRIPTOR);
			i++;
		}
		// 复制最后一个描述符
		//memcpy(pNewImportDescriptor, pNewImportDescriptor - sizeof(IMAGE_IMPORT_DESCRIPTOR), sizeof(IMAGE_IMPORT_DESCRIPTOR));

		//计算修正值
		DWORD dwDelt = pNewSectionHeader->VirtualAddress - pNewSectionHeader->PointerToRawData;

		// pNewImportDescriptor 当前指向要构造的新描述符 再空出一个空描述符作为导入表的结束符 所以是 2 * 
		PIMAGE_THUNK_DATA pNewThunkData = PIMAGE_THUNK_DATA(pNewImportDescriptor + 2 * sizeof(IMAGE_IMPORT_DESCRIPTOR));
		PBYTE pszDllName = (PBYTE)(pNewThunkData + 2);
		memcpy(pszDllName, strInjectDllName.c_str(), strInjectDllName.length());
		// 确定 DllName 的位置
		pszDllName[strInjectDllName.length() + 1] = 0;
		// 确定 IMAGE_IMPORT_BY_NAM 的位置 
		PIMAGE_IMPORT_BY_NAME pImportByName = (PIMAGE_IMPORT_BY_NAME)(pszDllName + strInjectDllName.length() + 1);
		// 初始化 IMAGE_THUNK_DATA
		pNewThunkData->u1.Ordinal = (DWORD_PTR)pImportByName - (DWORD_PTR)FileData + /*加上修正值 - 这里应该填充在内存中的地址*/dwDelt;
		// 初始化 IMAGE_IMPORT_BY_NAME
		pImportByName->Hint = 1;
		memcpy(pImportByName->Name, strFunctionName.c_str(), strFunctionName.length());
		pImportByName->Name[strFunctionName.length() + 1] = 0;
		// 初始化 PIMAGE_IMPORT_DESCRIPTOR
		if (bBoundImport)
		{
			((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->OriginalFirstThunk = 0;
		}
		else
		{
			((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->OriginalFirstThunk = dwDelt + (DWORD_PTR)pNewThunkData - (DWORD_PTR)FileData;
		}
		((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->FirstThunk = dwDelt + (DWORD_PTR)pNewThunkData - (DWORD_PTR)FileData;
		((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->Name = dwDelt + (DWORD_PTR)pszDllName - (DWORD_PTR)FileData;


		// 修改导入表入口
		pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = pNewSectionHeader->VirtualAddress;
		//pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = (i + 1) * sizeof(IMAGE_IMPORT_DESCRIPTOR);
	}
	catch (exception* e)
	{
		ERROR_MESSAGE((string("AddNewImportDescriptor:") + e->what()).c_str());
		bOk = false;
	}

EXIT:
	{
		if (TargetFileHandle != NULL)
		{
			CloseHandle(TargetFileHandle);
			TargetFileHandle = nullptr;
		}

		if (FileData != NULL)
		{
			UnmapViewOfFile(FileData);
			FileData = nullptr;
		}

		if (MappingHandle != NULL)
		{
			CloseHandle(MappingHandle);
			MappingHandle = nullptr;
		}
	}

	return bOk;
}

PIMAGE_SECTION_HEADER GetOwnerSection(PIMAGE_NT_HEADERS pNTHeaders, DWORD dwRVA)
{
	int i;
	PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)(pNTHeaders + 1);
	for (i = 0; i < pNTHeaders->FileHeader.NumberOfSections; i++)
	{
		if ((dwRVA >= (pSectionHeader + i)->VirtualAddress) && (dwRVA <= ((pSectionHeader + i)->VirtualAddress + (pSectionHeader + i)->SizeOfRawData)))
		{
			return ((PIMAGE_SECTION_HEADER)(pSectionHeader + i));
		}
	}
	return PIMAGE_SECTION_HEADER(NULL);
}

DWORD RVAToFOA(PIMAGE_NT_HEADERS pNTHeaders, DWORD dwRVA)
{
	DWORD _offset;
	PIMAGE_SECTION_HEADER section;
	// 找到偏移所在节
	section = GetOwnerSection(pNTHeaders, dwRVA);
	if (section == NULL)
	{
		return(0);
	}
	// 修正偏移
	_offset = dwRVA + section->PointerToRawData - section->VirtualAddress;
	return(_offset);
}

大法师Archmage
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PE文件本地DLL注入工具
10-26
本工具是通过修改PE文件的OEP位置，让它指向我们插入的代码（调用LoadLibrary函数），从而载入DLL进行程序注入，载入DLL后系统会自动调用DllMain函数，由于修改了OEP，使得我们的代码执行在被注入程序之前，且在同一地址空间里，简直可以为所欲为了。
PE输入表DLL注入
08-25 491
PE输入表DLL注入
注入技术--修改pe文件导入表进行注入
weixin_30849403的博客
03-13 436
1.修改导入表,即添加一个新的导入表描述符及其iat,int. 这样系统加载该pe文件时将自动加载添加的dll,从而实现dll注入 2.思路: 可以手工修改,但是复杂程度一点也不比写代码低,而且低效. 通过代码实现可以一劳永逸. 新增一个节来存储新的导入表. 其实也可以在原来的pe文件找空隙插入进去,但是又很难实现通用,因为不同的pe文件空隙位置大小不同.容易出错 新增的导入表描述符通过序...
[dll注入实现IAT勾取] 计算器显示中文
diheqiu3577的博客
09-10 857
勾取dll源码详解： 首先在创建时候来保存原始IAT地址到全局变量，然后通过Hook_iat函数来进行iat函数的勾取 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { switch( fdwReason ) { case D...
IAT.rar_IAT_iat 注入
09-21
本压缩包包含的"IAT注入.ec"文件很可能是一个实现了IAT注入功能的二进制代码，可能是一个DLL或者可执行文件，用于实际的注入操作。而"VC_ini_2.txt"可能是该代码的编译配置文件，或者是与之相关的说明文档，可能包含...
IAT 内核注入
09-16
1. `KeInject.cpp`：这是C++源代码文件，很可能包含了实现IAT注入的主要逻辑，包括注册回调、修改IAT表和注入DLL的代码。 2. `KeInject.h`：这是一个头文件，可能包含了IAT注入相关的函数声明和数据结构定义，供`...
改写PE文件导入表加载DLL
03-18
在Windows操作系统中，PE（Portable Executable）文件格式是用于存放可执行程序、动态链接库（DLL）等的二进制文件。理解PE文件结构及其导入表对于逆向工程、软件安全分析和恶意软件研究至关重要。本文将深入探讨...
修改exe PE格式中的IAT API钩子 通过修改IAT表实现 截获API调用,替换之.zip
01-19
6. 动态钩子与静态钩子：静态钩子是在PE文件本身进行修改，而动态钩子则是在程序运行时通过注入代码实现，两者各有优缺点，例如静态钩子不易被反作弊软件检测，但可能影响文件的可移植性。 在提供的文件列表中，`1...
DLL永久注入EXE 易语言源码实现 无需工具
10-10
4. **内存操作**：DLL注入涉及到读写目标进程的内存，包括找到进程的基地址，分配内存，拷贝DLL到内存，以及修改进程的导入地址表（IAT，Import Address Table）。 5. **API调用**：在易语言中，需要使用到如`...
易语言DLL注入工具
07-21
易语言DLL注入工具源码,DLL注入工具,释放进程内存,注入DLL,卸载DLL,取DLL函数地址,执行DLL函数,是否已注入,重载变量,申请内存_,释放内存_,写到内存_,读取内存_,写入内存数据_,调用子程序_,提升进程权限_,打开进程_,字节集_到整数,取线程返回值_,启动线程_Ret,
PE格式: 新建节并插入DLL
CSDN
07-26 4797
PE格式是 Windows下最常用的可执行文件格式,理解PE文件格式不仅可以了解操作系统的加载流程,还可以更好的理解操作系统对进程和内存相关的管理知识,而有些技术必须建立在了解PE文件格式的基础上,如文件加密与解密,病毒分析,外挂技术等。
PE文件本地DLL注入实现
flukeshen的博客
10-25 2202
本工具是通过修改PE文件的OEP位置，让它指向我们插入的代码（调用LoadLibrary函数），从而载入DLL进行程序注入，载入DLL后系统会自动调用DllMain函数，由于修改了OEP，使得我们的代码执行在被注入程序之前，且在同一地址空间里，简直可以为所欲为了。
Hook技术：通过Dll注入Hook IAT让计算器显示中文数字(附源码)
weixin_43742894的博客
05-09 2904
计算机的计算器是我们常用的一个小工具(小时候，总是计算机计算器分不开来，哈哈)。 众所周知，计算器在计算的过程中，显示的都是阿拉伯数字，因为阿拉伯数字是一个全世界通用的表示方法，那么如何让计算器显示中文数字"一、二、三......"呢？ 这里我们就可以使用Dll注入去hook关键API实现**计算器显示中文数字**。
系统本身的dll之间也有一大堆iat hook？
爱杀之爪的矩阵
08-23 618
<br /><br /> <br />kernel32.dll里面好多的函数其实都是直接转向ntdll.dll里面的<br />这样导致假如一个程序里面使用HeapFree这个函数了，然后在IAT表中这个函数对应的地址并不是在kernel.32中，<br />而是在ntdll.dll 里面的RtlFreeHeap这个函数<br /> <br />没啥意思
DLL劫持之IAT类型（Loadlibrary）
最新发布
星星我啊，已经很努力在学习了， 有人一起学习吗？Ziansec-1
01-28 319
标志相类似，因为系统只是将DLL映射到进程的地址空间中，就像它是数据文件一样。系统并不花费额外的时间来准备执行文件中的任何代码。: 这个标志用于告诉系统将DLL映射到调用进程的地址空间中，但是不调用DllMain并且不加载依赖Dll（只映射自己本身）。: 从%windows%\system32加载Dll和其依赖项。: 应用程序安装路径搜索Dll和其依赖项。设置的路径（保护Dll自己和依赖Dll）。跟到0环可以发现，在转换之后可以得到路径。，也就是说加载dll首先会加载锁，再调用。: 搜索路径的使用使用。
DLL 注入的三种方法详解
weixin_51409218的博客
02-27 3938
DLL注入的三种方式
DLL注入_修改导入表(1)
余韵
11-09 1435
PE文件分析 (一) 替换DLL函数 通过修改PE文件导入导出表来更改函数。单纯分析PE文件是一件比较无聊的事，通过修改可以更加灵活的利用和理解PE文件。这就像生活一样，总要有一些特别的事，才能更加有灵感。学习本身就是生活的一部分，如何让程序更加灵活，是一个比较值得去实践的事，可以更加接近计算机的一些思想。 (二) 环境 VC++ 6.0 为了减少复杂度，用VC++ 6.0编译sum.cpp su...
IAT表详解
cay22的专栏
02-05 7861
http://blog.163.com/ljm1113@126/blog/static/57984452201201485318443/   IAT表详解 IAT的全称是Import Address Table。 对于每一个引入的可执行文件（例如dll），有一个镜像引入描述符(IMAGE_IMPORT_DESCRIPTOR)。 typedef struct _IMAGE_IMPORT_D
深入解析PE文件格式
"PE文件结构祥解.pdf 是一本面向初学者的指南，深入解析了Windows NT3.1引入...通过学习本书，读者不仅可以理解PE文件的内部工作原理，还能掌握实际操作PE文件的技能，如使用提供的PEFILE.DLL库来提取和修改文件信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值