PE文件动态加载执行过程

最新推荐文章于 2024-05-15 09:54:59 发布
最新推荐文章于 2024-05-15 09:54:59 发布
阅读量1k 收藏 7
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mentally_slow/article/details/108311931
版权

主要步骤：

1.将要加载的文件读取到内存中(简称为文内)，检查文件格式无误后，根据可选PE头(简称op头)的SizeOfImage，申请出一块空间用于存储该文件加载到内存后展开的数据(简称为内内)。记得先全部初始化为0，免去后续拷贝中对齐补0的步骤。

2.将文件数据拷贝到申请出来内存空间中(模仿PE加载器将文件装载到虚拟内存中)，先根据op头的SizeOfHeaders，将文件的各种头数据先拷贝过来(因为各种头数据是线性存储的，在静态动态都是相同的存放顺序)，随后复制节表数据，遍历每个节表，如果当前节表在文内长度时为0，则说明该节在内存中仅做对齐用，并没有实际数据，遍历下一节，将数据从文起复制文长的数据到内起中，由于前面申请空间时已初始化，所以无需在填0对齐。

3.进行重定位，如果当前加载到内存当中的基址与op的IB一样，即在理想基址中展开了，或重定位表data[5]的长度为0，则无需要重定位。否则获取到重定位表的块数据后，根据他的(块长度-8)/2得到该块的地址数量，前8字节存放着该块的偏移和大小，每个占4字节，一个重定位地址占2字节，通过块地址+8+(2i)取出需要重定位的地址，与0x3000进行异或，如果首位为3，则后12位为地址偏移，则重定位地址=后12位(块中偏移)+块的起始位置+内存起始位置 重定位则为重定位地址=重定位地址+(理想基址和实际基址的偏移) 即*重定位地址+=(实际基址-理想基址)。如果首位为0，则说明该偏移为对齐使用，遍历下一个(当前块基址+当前块长度)。将全部块遍历重定位完后，将op的IB也替换成当前加载到内存的基址。

4.构建导入表：通过偏移+内存基址，获取导入表第一个dll的数据，按照导入的dll逐个遍历，直到当前导入表的OriginalFirstThunk为0，即遍历完毕。 先通过GetModuleHandleA函数获取当前DLL的句柄，如果返回为NULL，则当前进程还未加载该DLL，loadlibary进来，获得句柄。通过内存基址+OriginalFirstThunk获得INT(输入名字表)，内存基址+FirstThunk获得IAT(输入地址表)。检查INT的Ordinal是否为0，为0则遍历完当前DLL，如果不为0，检查第32位是否为1(&0x80000000),为1则为序号导入，Ordinal的后16位为序号取出(&0xFFFF),GetProcAddress得到函数地址，并赋值给IAT表的Function。如果第32位为0，则说明按名称导入，此时先通过内存基址+AddressOfData获得函数名，再用GetProcAddress得到函数地址，并赋值给IAT表的Function，循环遍历各个DLL即可。

导出表在PE文件加载到内存时并不会使用到

5.通过VirtualProtect修改整个内存内容的保护属性，修改为PAGE_EXECUTE_READWRITE(执行读写)。

6.定义一个指向DLL加载函数类型的函数指针，typedef BOOL(WINAPI *DllProcEntry)(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved);

随后声明该函数指针的实例，并将(当前内存基址+op的AddressOfEntryPoint)的函数地址赋值给它，随后调用该入口函数。

DllProcEntry ProcAddr = (DllProcEntry)(g_pFileBuffer + pNtHead->OptionalHeader.AddressOfEntryPoint);//定义函数入口地址

bool bRetval = (*ProcAddr)((HINSTANCE)g_pFileBuffer, DLL_PROCESS_ATTACH, 0);//调用入口函数

#include<iostream>
#include<Windows.h>
#include <winnt.h>
using namespace std;
 
char *g_pFileSrc = NULL;//文件内容
char *g_pFileBuffer = NULL;//虚拟内存空间
int g_iFileBufferLen = 0;//虚拟内存空间大小
 
//定义一个函数指针   指向DLL加载的入口函数类型的函数
typedef BOOL(WINAPI *DllProcEntry)(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved);
 
DWORD RVAtoFA(DWORD dwRVA)   //rva转文件地址
{
    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;     //dos头
    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);       //NT头
    PIMAGE_FILE_HEADER pFileHead = (PIMAGE_FILE_HEADER)&pNtHead->FileHeader;     //PE头
    PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHead);      //节表
    int dwSectionCount = pFileHead->NumberOfSections;//获得节表数量
    for (int iNum = 0; iNum < dwSectionCount; iNum++)
    {
        if (dwRVA >= pSection->VirtualAddress && dwRVA < (pSection->VirtualAddress + pSection->Misc.VirtualSize))//如果RVA的值落在当前节点的范围内
        {
            return (DWORD)g_pFileSrc + ((dwRVA - pSection->VirtualAddress) + pSection->PointerToRawData);
            /*则文件地址=映射基址 + 文件偏移地址（ RVA- VirtualAddress + RawAddress）
            = 映射基址 + RVA - VirtualAddress + RawAddress*/
        }
        pSection++;//指向下一个节表
    }
    return 0;
}
bool LoadFile(char *pFileName)  //读取文件
{
    //读取文件内容
    FILE* fp = fopen(pFileName, "rb");
    if (!fp)
    {
        cout << "打开文件失败" << endl;
        return false;
    }
    fseek(fp, 0, SEEK_END);
    int iFileSize = ftell(fp);
    g_pFileSrc = (char*)malloc(iFileSize);
    //DWORD dwBufferSize = *(int*)((DWORD)g_pFileSrc - 16);//这种方法可以取出这段空间的长度
    if (!g_pFileSrc)
    {
        cout << "分配内存失败" << endl;
        return false;
    }
    memset(g_pFileSrc, 0, iFileSize);
    rewind(fp);
    fread(g_pFileSrc, 1, iFileSize, fp);
 
    //检查文件格式
    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
    if (pDosHead->e_magic != 0x5A4D)
    {
        cout << "该文件不是可执行文件" << endl;
        return false;
    }
    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
    if (pNtHead->Signature != 0x4550)
    {
        cout << "该文件不是PE文件" << endl;
        return false;
    }
 
    PIMAGE_OPTIONAL_HEADER pOptionalHead = (PIMAGE_OPTIONAL_HEADER)&pNtHead->OptionalHeader;
 
    g_pFileBuffer = (char*)malloc(pOptionalHead->SizeOfImage);
    if (!g_pFileBuffer)
    {
        cout << "分配模虚拟内存失败" << endl;
        return false;
    }
    memset(g_pFileBuffer, 0, pOptionalHead->SizeOfImage);
    cout << "读取文件成功，by:阿怪   2020.7.9" << endl;
    return true;
}
 
bool CopyContent()//拷贝数据
{
 
    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;     //dos头
    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);       //NT头
    PIMAGE_FILE_HEADER pFileHead = (PIMAGE_FILE_HEADER)&pNtHead->FileHeader;     //PE头
    PIMAGE_OPTIONAL_HEADER pOptionalHead = (PIMAGE_OPTIONAL_HEADER)&pNtHead->OptionalHeader;     //可选PE头
    PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHead);      //节表
    int iSection = pFileHead->NumberOfSections;//节数量
 
    memcpy(g_pFileBuffer, g_pFileSrc, pOptionalHead->SizeOfHeaders);//复制各种头数据
    //  //pSection->PointerToRawData;//文件中节的起始地址         pSection->SizeOfRawData;//文件中节的长度
    //  //pSection->VirtualAddress;//虚拟内存中节的起始地址     pSection->Misc.VirtualSize;//虚拟内存中节的长度
    for (int num = 0; num < iSection; num++)
    {
        if (pSection->SizeOfRawData == 0) //如果在文件中这个节的长度为0，证明该节为未被初始化的静态内存区
        {
            pSection++;
            continue;
        }
        memcpy(g_pFileBuffer + pSection->VirtualAddress,
            g_pFileSrc + pSection->PointerToRawData,
            pSection->SizeOfRawData
            );
        pSection++;
    }
    cout << "从文件拷贝数据到内存完毕，by:阿怪   2020.7.9" << endl;
    return true;
}
 
bool Relocation()  //进行重定位并修改基址
{
    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileBuffer;      //dos头
    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);       //NT头
    PIMAGE_OPTIONAL_HEADER pOptional = (PIMAGE_OPTIONAL_HEADER)&(pNtHead->OptionalHeader);
    DWORD dwRelocationRVA = pOptional->DataDirectory[5].VirtualAddress;//重定位表RVA
    int iRelocationSize = pOptional->DataDirectory[5].Size;//重定位表长度
    DWORD dwImageBaseGap = (DWORD)g_pFileBuffer - pOptional->ImageBase;  //计算加载后的基址与原先预想的基址的距离
    if ((dwImageBaseGap == 0) || (iRelocationSize == 0))
    {
        cout << "该程序无需重定位" << endl;
        return false;
    }
    PIMAGE_BASE_RELOCATION pBaseRelocation = (PIMAGE_BASE_RELOCATION)RVAtoFA(dwRelocationRVA);//重定位表当前块
    while ((pBaseRelocation->VirtualAddress != 0) && (pBaseRelocation->SizeOfBlock != 0))  //遍历到重定位表末尾为止
    {
        for (int i = 0; i < ((pBaseRelocation->SizeOfBlock - 8) / 2); i++)   //块首地址-8(前4为块偏移，后4为块长度)/2=块中需重定位地址数量
        {
            WORD pRelocationAddr = *(WORD*)((DWORD)pBaseRelocation + 8 + (2 * i));//在块中，每个重定位地址占2字节(WORD类型)
            if (pRelocationAddr != 0)  //为0时，说明该位置数据为对齐而填充
            {
                DWORD dwRVA = (pRelocationAddr ^ 0x3000) + pBaseRelocation->VirtualAddress;//需要重定位的偏移
                PDWORD dwFileAddr = (DWORD*)(dwRVA + g_pFileBuffer);//重定位地址=当前程序基址+当前块基址+当前目标偏移
                *dwFileAddr += dwImageBaseGap;
            }
        }
        pBaseRelocation = (PIMAGE_BASE_RELOCATION)((DWORD)pBaseRelocation + pBaseRelocation->SizeOfBlock);  //下个块文件地址=当前块文件地址+当前块长度
    }
    pOptional->ImageBase = (DWORD)g_pFileBuffer;  //将当前文件的基址改为加载到内存后的基址
 
    cout << "程序重定位并修改基址成功，by:阿怪   2020.7.9" << endl;
    return true;
 
}
 
bool ImportList()  //导入表
{
    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileBuffer;      //dos头
    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);       //NT头
    PIMAGE_OPTIONAL_HEADER pOptional = (PIMAGE_OPTIONAL_HEADER)&(pNtHead->OptionalHeader);
    DWORD dwImportListRVA = pOptional->DataDirectory[1].VirtualAddress;//导入表RVA
    int dwImportListSize = pOptional->DataDirectory[1].Size;//导入表长度
    PIMAGE_IMPORT_DESCRIPTOR pImpotrList = (PIMAGE_IMPORT_DESCRIPTOR)(dwImportListRVA + g_pFileBuffer); //获取导入表第一个导入的dll
 
    while (pImpotrList->OriginalFirstThunk != 0)  //只有该结构中有一个成员内容为0，即遍历完了导入表了
    {
        char* szDllName = (char*)(g_pFileBuffer + pImpotrList->Name);//获取当前DLL的名字
        HMODULE hDllImageBase = LoadLibrary(szDllName);//先将当前dll加载到程序中
        if (!hDllImageBase)
        {
            int iError = GetLastError();
            cout << "加载当前dll失败，错误代码:" << iError << endl;
            return false;
        }
 
        PIMAGE_THUNK_DATA pDllINT = (PIMAGE_THUNK_DATA)(g_pFileBuffer + pImpotrList->OriginalFirstThunk);//获取当前DLL导入的函数的输入名称表(INT)
        PIMAGE_THUNK_DATA pDllIAT = (PIMAGE_THUNK_DATA)(g_pFileBuffer + pImpotrList->FirstThunk);//获取当前DLL导入的函数的输入地址表(IAT) 当前IAT和INT指向同一内容
 
        for (int i = 0; pDllINT->u1.Ordinal; i++)  //当当前DLL导入的函数Ordinal为0时，即遍历完当前DLL所有函数
        {
            if (pDllINT->u1.Ordinal & 0x80000000)  //如果当前结构信息的序数Ordinal的第32位为1  则当前dll的函数由序号导入
            {
                DWORD dwFuncNum = pDllINT->u1.AddressOfData & 0xFFFF;//后16位为导入序号
                //dwDllIAT->u1.Function = (DWORD)hDllImageBase + dwFuncNum;
                pDllIAT->u1.Function = (DWORD)GetProcAddress(hDllImageBase, (LPCSTR)dwFuncNum);
            }
            else   //不为1则由函数名字导入
            {
                PIMAGE_IMPORT_BY_NAME szFuncName = (PIMAGE_IMPORT_BY_NAME)(g_pFileBuffer +pDllINT->u1.AddressOfData);  //获得函数名
                pDllIAT->u1.Function = (DWORD)GetProcAddress(hDllImageBase, szFuncName->Name);    //通过dll和函数名  获得当前函数在内存中的地址
            }
            pDllINT++;
            pDllIAT++;
        }
        pImpotrList++;
    }
    cout << "构建IAT成功，by:阿怪   2020.7.9" << endl;
    return true;
    }
 
 
bool DynamicLoad(char *pDllName)
{
    if (!LoadFile(pDllName)) //获取文件内容、检查文件格式、分配2块内存(存放文件数据和虚拟内存空间)
    {
        return false;
    }
    if (!CopyContent()) //将文件数据装载到虚拟内容中
    {
        return false;
    }
 
    Relocation(); //重定位并修改基址(并非所有PE结构都需要重定位)
 
    if (!ImportList()) //通过导入表构建IAT
    {
        return false;
    }
 
 
    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileBuffer;
    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 
    DWORD dwOldProtect = 0;
    if (FALSE == VirtualProtect(g_pFileBuffer, pNtHead->OptionalHeader.SizeOfImage, PAGE_EXECUTE_READWRITE, &dwOldProtect))
    {
        printf("设置页属性失败\n");
        return NULL;
    }
     
    DllProcEntry ProcAddr = (DllProcEntry)(g_pFileBuffer + pNtHead->OptionalHeader.AddressOfEntryPoint);//定义函数入口地址
    MessageBoxA(0, 0, 0, 0);
    bool bRetval = (*ProcAddr)((HINSTANCE)g_pFileBuffer, DLL_PROCESS_ATTACH, 0);//调用入口函数
 
    cout << "加载完成"<<endl<<"by:阿怪   2020.7.9" << endl;
 
    return true;
}

在这里插入图片描述
需要调试的位置调用messagebox 随后可在调试器(OD,MDbug)中定位到关键点，方便调试。

踩坑点：

1.节数据赋值时的对齐，如果不按照上面的步骤，也可通过对齐值，求得当前节在虚拟内存中的对齐后的大小，用该值-当前节在文件中的大小，可得用0补齐的长度。以及如何去复制各种头文件(各种头文件为线性的，可直接复制)，当第一个节在文件大小为0时该怎么处理。

2.重定位的重定位地址为当前内存基址+当前重定位块基址+当前重定位偏移，重定位后的值应该赋值给重定位，即重定位地址=重定位地址+(预先理想的基址与当前内存基址的距离)

3.在静态文件到动态加载到内存时，导入表是通过INT表，把所导入的函数的地址装载到IAT表，全部加载完后，INT表就没用了，通过IAT表就可以找到相应的函数地址。且在取相应的地址时，应该是由导入表的成员的RVA+内存基址，而不是通过RVAtoFA去取值。

导入表相关文章： https://www.sohu.com/a/278971010_653604

导出表相关文章：https://www.write-bug.com/article/1926.html 　　https://www.cnblogs.com/Madridspark/p/WinPEFile.html

模拟PE解析器工作原理：https://www.cnblogs.com/onetrainee/p/12938085.html

感谢以上资料作者带来的启发与借鉴，在这也是分享自己在做这个动态加载时的感受，如有不足之处也希望大家不吝赐教，指点出来。谢谢。

有什么问题或看法欢迎评论

Mentally_slow
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
PE loader (x86)
zylg
11-20 1046
#include <iostream> #include "PeLoader32.h" #include <fstream> using namespace std; string readFile(const string & _file_name) { fstream f(_file_name.data(), ios::in|ios::binary); f.seekg(0, ios::end); size_t len = f.tellg(); f.seekg(
PE文件格式详解
热门推荐
钞sir的博客
03-17 1万+
三千风雨三千雪 三千风雪我在写 流了一共三千血 你却始终不了解 简介 PE文件使用的是一个平面地址空间，所有的代码和数据都合并在一起，组成了一个很大的结构； 文件被分为不同的区块(Section，又成为区段或节等)，区块中包含代码和数据，各个区块按页边界对齐； 区块没有大小限制，是一个连续结构；每一个块都有其自己的属性，如是否包含代码，是否可读可写等； PE文件的构成 MS-DOS头部 每个...
题目：揭秘Amber：隐形的PE加载器
最新发布
gitblog_00030的博客
05-15 307
题目：揭秘Amber：隐形的PE加载器 项目地址:https://gitcode.com/EgeBalci/amber 1、项目介绍 在信息安全领域，隐藏并保护执行代码的技术是至关重要的。Amber是一个创新性的PE（Portable Executable）加载器，它能够实现PE文件（如EXE，DLL，SYS等）的内存中无痕执行。由Amber生成的反射性负载可以被远程服务器分阶段部署，或者直接在内...
PE执行流程
SXXYNHHXX的博客
09-01 263
PE介绍
反向进程注入及隐藏--动手做一个最简单的PELoader
08-16 1511
文章属性：原创文章提交：Luke0314 (msfocus_at_hotmail.com)动手做一个最简单的PELoaderLuke msfocus@hotmail.com一．废话最近因为公司的项目需要，顺带的学习了一点和PELoader相关的东西，恰见网上正在沸沸扬扬的谈论虚拟脱壳。本人不才，实在是没能力也没精力去写一个真正意义上的虚拟机，因此尝试做了一个简单而偷懒的PE加载器。这个PE加载器也
LoadPE工具
02-19
LoadPE工具
loadpe最新版豪华版中文
07-11
loadpe最新版豪华版中文2014.7.11无毒的
pe-loader:Windows PE格式的文件加载器
05-15
Windows可执行文件加载器这是Windows PE格式的文件加载器应用程序，提供与OS内部可执行文件加载器类似的功能，但从用户模式运行。 它将可执行文件映射到内存，打补丁并初始化几种机制，然后将控制流传递给加载的映像...
关于PE可执行文件的修改.rar_PE修改_pe_pe文件修改
09-23
PE（Portable Executable）可执行文件格式是Windows操作系统中用于存放程序代码、资源和元数据的标准格式。在Windows系统中，无论是.exe还是.dll文件，都遵循PE格式。本主题将深入探讨PE文件的结构以及如何对其进行...
PE文件结构详解
08-25
PE文件加载到内存后，内存中的版本称为模块（Module）。映射文件的起始地址称为模块句柄（hModule），也称为基地址（ImageBase）。文件数据一般512字节（1扇区）对齐，32位内存一般4k（1页）对齐。 DOS部分 DOS头...
PE文件节区添加并弹出简单的对话框
05-26
在Windows系统中，当我们谈论“添加节区”时，实际上是在修改PE文件头的节表，增加新的条目来指示操作系统加载新的内存区域。 为了自动添加节区，你需要熟悉PE文件的内部结构，特别是IMAGE_NT_HEADERS和IMAGE_...
loadpe工具（1-4）
06-25
好用的PE文件查看分析工具，能查看PE文件各段，各种文件信息。
易语言汇编PeLoader
07-22
易语言汇编PeLoader源码,汇编PeLoader,LoadMemLibrary,LoadMemLibraryEx1,LoadMemLibraryEx2,GetMemProcList,GetMemProcAddress,GetMemEntryPoint,FreeMemLibrary,调用子程序1_,调用子程序2_,指针到整数_
ParsePe_等价替换PE文件指令_解析PE文件_
10-03
5. **重定位和资源**：PE文件可能需要进行重定位，即根据加载时的内存地址调整代码和数据的位置。此外，资源表（Resource Table）包含图标、字符串、菜单等非代码元素。 等价指令替换是指在不改变程序行为的前提下...
PE文件：PE加载的过程
weixin_43742894的博客
03-31 2044
1、将PE文件从磁盘中读出 2、根据PE结构获取镜像大小，再申请一段可读可写可执行的内存，并填充为0 3、将读取的数据映射到内存中 4、修复导出导入入表 5、修复重定位 6、跳转到PE入口点进行执行 0x00 将PE文件从磁盘中读出 使用ReadFile()读取数据 。 0x01 根据PE结构获取镜像大小，再申请一段可读可写可执行的内存，并填充为0 //获取镜像大小 DWORD SizeOfIma...
模拟PE文件加载
qq_35289660的博客
08-10 751
PE重载 文章目录PE重载0.说明1.PE重载原理第一步：将exe映射至内存第二步：修正重定位表的地址第三步： 修正IAT表第四步：跳转运行至PE入口2.PE重载总结3.一个小问题4.源码 0.说明 观看滴水逆向视频总结（部分截图来自于滴水课件） 编译器：vc++6.0 编写语言：c 欢迎大家留言交流????^ __ ^ 可以加我qq一起学习：1245885144???????? 1.PE重载原理 模拟系统加载一个exe的过程， 通过pe重载的方法，可以将原有exe分割、加密、任意操作后，再通过pe重载的方
PE(dll、exe)文件内存加载（手动映射）小记
qq_31314583的博客
09-28 2197
前言 PE文件即Windos操作系统下的可执行文件的文件结构名称，其中包含但不限于.dll .exe .sys .ocx等等。内存加载PE顾名思义就是通过内存，而非文件。这里的内存指代的是直接加载源。 这个技术其实很早之前就有了，网上也有很多开源可参考的代码，但是仅做一个伸手党那是绝对不行的，首先这些历史悠久的代码存在或多或少的bug，或莫名的崩溃咯，或32和64不兼容咯，各种问题皆是。当然，这些前辈先贤的代码一定是具有非常大的参考和开拓意义的。 技术用途 ...
PE加载与反射式注入
qq_41861225的博客
02-01 856
一、PE加载 在PE结构非常熟系的情况下，往往我们都会想要实现一套PE加载器，其基本流程可以分为以下几点： 将PE文件从磁盘中读出 根据PE结构获取镜像大小，再申请一段可读可写可执行的内存并填充为0 将读取数据映射到内存中 修复导出导入入表 修复重定位 跳转到PE入口点进行执行 相信各位对以上流程都非常熟悉，而且只有实现了PE加载才能真正掌握PE结构，作为抛砖引玉下面我们就聊聊一种DLL注...
可执行文件结构：PE文件结构讲解
qq_46145027的博客
05-02 2371
我们使用电脑时肯定会接触各种各样的应用程序，有应用程序就会有对应的可执行文件，比如最常见的.exe文件。事实上，Windows平台下，所有的可执行文件（包括EXE、DLL、SYS、OCX、COM......)使用的都是同一种文件结构，也就是PE（Portable Executable）文件结构。所以说所有可执行文件究其本质都可以叫它PE文件。这里要注意一点：事实上，一个文件是否是PE文件与其扩展名无关，PE文件可以是任何扩展名。 下面就来结合事例详细介绍一下PE文件到底是个什么东西。
pe文件执行起来后调用的api和导入表里的api有什么区别啊
07-13
PE文件在执行过程中调用的API和导入表中的API有一些区别。 1. 调用的API：PE文件在执行过程中可以调用系统提供的API函数，例如Windows操作系统提供的函数，以完成特定的功能。这些API函数是通过链接器和加载器动态链接到PE文件中的。PE文件可以直接调用这些API函数，无需额外的步骤。 2. 导入表中的API：导入表是PE文件中的一部分，用于记录PE文件需要在运行时动态链接的外部函数。导入表中列出了PE文件将要使用的外部函数的名称和地址。在PE文件加载到内存后，加载器会遍历导入表，根据表中记录的函数名称去系统库中查找对应的函数地址，并将其填充到PE文件的导入表中。这样，当PE文件需要调用导入表中的API时，它会通过导入表中记录的函数地址来间接调用这些API。 总结起来，调用的API是PE文件直接调用的系统提供的函数，而导入表中的API是PE文件在运行时动态链接到的外部函数。导入表提供了一种灵活的方式来解决PE文件对外部函数的依赖性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值