Kendy--从内存中加载并启动一个exe

1、Kendy-从内存中加载并启动一个exe    .style1 FONT-WEIGHT: bold; FONT-SIZE: 12px; COLOR: #ff6699 .yjx BORDER-RIGHT: #f0f0f0 0px solid; BORDER-TOP: #f0f0f0 0px solid; BORDER-LEFT: #f0f0f0 0px solid; BORDER-BOTTOM: #f0f0f0 0px solid     Delphi从内存中加载并启动一个exe   &

2、#160;作者：Idle_ (阿呆)   来源：CSND windows似乎只提供了一种启动进程的方法：即必须从一个可执行文件中加载并启动。而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法。用途嘛, 也许可以用来保护你的exe，你可以对要保护的 exe 进行任意切分、加密、存储，只要运行时能将exe的内容正确拼接到一块内存中，就可以直接从内存中启动，而不必不安全地去生成一个临时文件再从临时文件启动进程。另外这段代码也提供了一种自己写exe外壳的简单途径，如果能配合其它各种外壳技术就更好地保护你的exe文件。 原理很简单：就是“借尸还魂”，启动一个僵尸进程（

3、NT下可以是自身程序启动的另一个进程），然后在它运行前将其整个替换成内存中的exe内容，待正式运行后执行的就是你的目标代码了。 不过代码中还有一些不尽人意的地方，比如在98下运行会留一个僵尸程序的壳在硬盘上（其实那个僵尸程序本身就是一个完整的可执行程序，直接运行的话只显示一条错误信息然后就退出了）。另外由于客观条件限制，代码没有经过充分测试，只在XP下进行了一些初步测试：普通exe都能正常运行，upx压缩过的exe绝大多数情况下都能运行，只有在不能卸载僵尸外壳时才有问题（upx压缩过的exe没有重定向表，无法加载到其它地址运行）。 如果有bug望告之，如果有更好的方法特别是能解决98下的遗留尾

4、巴的话希望不吝赐教。     * *                 从内存中加载并运行exe               * * * 参数：          

5、;                                      * Buffer: 内存中的exe地址         

6、60;                     * Len: 内存中exe占用长度                          

7、60;     * CmdParam: 命令行参数(不包含exe文件名的剩余命令行参数） * ProcessId: 返回的进程Id                               * 返回值： 如果成功则返回进程的Handle(ProcessHan

8、dle),               如果失败则返回INVALID_HANDLE_VALUE           * unit PEUnit; interface uses windows; function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardin

9、al): Cardinal; implementation $R ExeShell.res   / 外壳程序模板(98下使用) type  TImageSectionHeaders = array 0.0 of TImageSectionHeader;  PImageSectionHeaders = TImageSectionHeaders; 计算对齐后的大小 function GetAlignedSize(Origin, Alignment: Cardinal): Cardinal;begin  result := (Origin + Ali

10、gnment - 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 

11、 计算pe头的大小  result := GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment);   计算所有节的大小  for i := 0 to peH.FileHeader.NumberOfSections - 1 do    if peSecHi.PointerToRawData + peSecHi.SizeOfRawData > FileLen then  / 超出文件范围 

12、0;  begin      result := 0;      exit;    end    else if peSecHi.VirtualAddress <> 0 then  /计算对齐后某节的大小      if peSecHi.Misc.VirtualSize <> 0 then    

13、0;   result := GetAlignedSize(peSecHi.VirtualAddress + peSecHi.Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment)      else        result := GetAlignedSize(peSecHi.VirtualAddress + peSecHi.SizeOfRawData, PeH.OptionalHeader.Sec

14、tionAlignment)    else if peSecHi.Misc.VirtualSize < peSecHi.SizeOfRawData then      result := result + GetAlignedSize(peSecHi.SizeOfRawData, peH.OptionalHeader.SectionAlignment)    else      result := result + GetAli

15、gnedSize(peSecHi.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: PImageDosHeade

16、r;            / DOS头  SrcPeH: PImageNtHeaders;           / PE头  SrcPeSecH: PImageSectionHeaders;   / 节表  i: Integer;  l: Cardinal;  Pt: Pointer;begin  resu

17、lt := 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 &l

18、t;> 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 <>

19、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_REA

20、DWRITE);  / 分配内存  if Mem <> nil then  begin    / 计算需要复制的PE头字节数    l := SrcPeH.OptionalHeader.SizeOfHeaders;    for i := 0 to SrcPeH.FileHeader.NumberOfSections - 1 do      if (SrcPeSecHi.PointerToRawData <&

21、gt; 0) and (SrcPeSecHi.PointerToRawData < l) then        l := SrcPeSecHi.PointerToRawData;    Move(SrcMz, Mem, l);    PeH := Pointer(Integer(Mem) + PImageDosHeader(Mem)._lfanew);    PeSecH := Pointer(Integer(PeH) + si

22、zeof(TImageNtHeaders);     Pt := Pointer(Cardinal(Mem) + GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment);    for i := 0 to PeH.FileHeader.NumberOfSections - 1 do    begin      / 定位该节在内存中的位置

23、60;     if PeSecHi.VirtualAddress <> 0 then        Pt := Pointer(Cardinal(Mem) + PeSecHi.VirtualAddress);       if PeSecHi.SizeOfRawData <> 0 then      begin    &#

24、160;   / 复制数据到内存        Move(Pointer(Cardinal(SrcMz) + PeSecHi.PointerToRawData), pt, PeSecHi.SizeOfRawData);        if peSecHi.Misc.VirtualSize < peSecHi.SizeOfRawData then       &#

25、160;  pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecHi.SizeOfRawData, PeH.OptionalHeader.SectionAlignment)        else          pt := pointer(Cardinal(pt) + GetAlignedSize(peSecHi.Misc.VirtualSize, peH.OptionalHe

26、ader.SectionAlignment);        / pt 定位到下一节开始位置      end      else        pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecHi.Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment);

27、    end;    result := True;  end;end; type  TVirtualAllocEx = function (hProcess: THandle; lpAddress: Pointer;                         

28、         dwSize, flAllocationType: DWORD; flProtect: DWORD): Pointer; stdcall; var  MyVirtualAllocEx: TVirtualAllocEx = nil; function IsNT: Boolean;begin  result := Assigned(MyVirtualAllocEx);end; 生成外壳程序命令行 function PrepareShellExe(CmdParam: string;

29、BaseAddr, ImageSize: Cardinal): string;var  r, h, sz: Cardinal;  p: Pointer;  fid, l: Integer;  buf: Pointer;  peH: PImageNtHeaders;  peSecH: PImageSectionHeaders;begin  if IsNT then  NT 系统下直接使用自身程序作为外壳进程     result := ParamStr(0)+CmdParam 

30、 else begin  / 由于98系统下无法重新分配外壳进程占用内存,所以必须保证运行的外壳程序能容纳目标进程并且加载地址一致  / 此处使用的方法是从资源中释放出一个事先建立好的外壳程序,然后通过修改其PE头使其运行时能加载到指定地址并至少能容纳目标进程    r := FindResource(HInstance, SHELL_EXE, RT_RCDATA);    h := LoadResource(HInstance, r);    p := LockResource(h)

31、;    l := SizeOfResource(HInstance, r);    GetMem(Buf, l);    Move(p, Buf, l);   / 读到内存    FreeResource(h);    peH := Pointer(Integer(Buf) + PImageDosHeader(Buf)._lfanew);    peSecH := Pointer(Integer

32、(peH) + sizeof(TImageNtHeaders);    peH.OptionalHeader.ImageBase := BaseAddr;    / 修改PE头重的加载基址    if peH.OptionalHeader.SizeOfImage < ImageSize then  / 目标比外壳大,修改外壳程序运行时占用的内存    begin      sz := Imagesize - p

33、eH.OptionalHeader.SizeOfImage;      Inc(peH.OptionalHeader.SizeOfImage, sz);    / 调整总占用内存数      Inc(peSecHpeH.FileHeader.NumberOfSections-1.Misc.VirtualSize, sz);   / 调整最后一节占用内存数    end;     / 生成

34、外壳程序文件名, 为本程序改后缀名得到的    / 由于不想 uses SysUtils (一旦 use 了程序将增大80K左右), 而且偷懒，所以只支持最多运行11个进程，后缀名为.dat, .da0.da9    result := ParamStr(0);    result := copy(result, 1, length(result) - 4) + .dat;    r := 0;    while r < 10 do

35、0;   begin      fid := CreateFile(pchar(result), GENERIC_READ or GENERIC_WRITE, 0, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);      if fid < 0 then      begin        result :

36、= copy(result, 1, length(result)-3)+da+Char(r+Byte(0);        inc(r);      end      else begin        /SetFilePointer(fid, Imagesize, nil, 0);      &#

37、160; /SetEndOfFile(fid);        /SetFilePointer(fid, 0, nil, 0);        WriteFile(fid, Buf, l, h, nil);  / 写入文件        CloseHandle(fid);        break; 

38、;     end;    end;    result := result + CmdParam;  / 生成命令行    FreeMem(Buf);  end;end; 是否包含可重定向列表 function HasRelocationTable(peH: PImageNtHeaders): Boolean;begin  result := (peH.OptionalHeader.DataDirectoryIMAGE_DIRECTO

39、RY_ENTRY_BASERELOC.VirtualAddress <> 0)      and (peH.OptionalHeader.DataDirectoryIMAGE_DIRECTORY_ENTRY_BASERELOC.Size <> 0);end; type  PImageBaseRelocation= TImageBaseRelocation;  TImageBaseRelocation = packed record    VirtualAddress: c

40、ardinal;    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.Imag

41、eBase;  p := pointer(cardinal(OldBase) + peH.OptionalHeader.DataDirectoryIMAGE_DIRECTORY_ENTRY_BASERELOC.VirtualAddress);  while (p.VirtualAddress + p.SizeOfBlock <> 0) do  begin    pw := pointer(Integer(p) + Sizeof(p);    for i := 1 to (p.SizeOfBlo

42、ck - 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;  &

43、#160; 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;

44、  m := LoadLibrary(ntdll.dll);  if m <> 0 then  begin    ZwUnmapViewOfSection := GetProcAddress(m, ZwUnmapViewOfSection);    if assigned(ZwUnmapViewOfSection) then      result := (ZwUnmapViewOfSection(ProcHnd, BaseAddr) = 0)

45、;    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: TMemoryB

46、asicInformation;  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  

47、  ProcHnd := pi.hProcess;    ThrdHnd := pi.hThread;    ProcId := pi.dwProcessId;     获取外壳进程运行状态，ctx.Ebx+8内存处存的是外壳进程的加载基址，ctx.Eax存放有外壳进程的入口地址     ctx.ContextFlags := CONTEXT_FULL;    GetThreadContext(ThrdHnd, ctx); &

48、#160;  ReadProcessMemory(ProcHnd, Pointer(ctx.Ebx+8), BaseAddr, SizeOf(Cardinal), Old);  / 读取加载基址    p := Pointer(BaseAddr);     计算外壳进程占有的内存     while VirtualQueryEx(ProcHnd, p, MemInfo, Sizeof(MemInfo) <> 0 do    begin 

49、;     if MemInfo.State = MEM_FREE then        break;      p := Pointer(Cardinal(p) + MemInfo.RegionSize);    end;    ImageSize := Cardinal(p) - Cardinal(BaseAddr);  end;end; 创建外壳进程并用目标进

50、程替换它然后执行 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;  Thr

51、d: 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

52、) and (Size >= ImageSize) then  / 外壳进程可以容纳目标进程并且加载地址一致    begin      p := Pointer(Addr);      VirtualProtectEx(result, p, Size, PAGE_EXECUTE_READWRITE, Old);    end    else if IsNT then  / 98

53、下失败    begin      if UnloadShell(result, Addr) then  / 卸载外壳进程占有内存        / 重新按目标进程加载基址和大小分配内存        p := MyVirtualAllocEx(Result, Pointer(peH.OptionalHeader.ImageBase), ImageSize, MEM_

54、RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);      if (p = nil) and hasRelocationTable(peH) then  / 分配内存失败并且目标进程支持重定向      begin        / 按任意基址分配内存        p := MyVirtualAllo

55、cEx(result, nil, ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);        if p <> nil then          DoRelocation(peH, Ptr, p);  / 重定向      end;    end; 

56、;   if p <> nil then    begin      WriteProcessMemory(Result, Pointer(ctx.Ebx+8), p, Sizeof(DWORD), Old);  / 重置目标进程运行环境中的基址      peH.OptionalHeader.ImageBase := Cardinal(p);      if WritePr

57、ocessMemory(Result, p, Ptr, ImageSize, Old) then  / 复制PE数据到目标进程      begin        ctx.ContextFlags := CONTEXT_FULL;        if Cardinal(p) = Addr then        

58、60; ctx.Eax := peH.OptionalHeader.ImageBase + peH.OptionalHeader.AddressOfEntryPoint  / 重置运行环境中的入口地址        else          ctx.Eax := Cardinal(p) + peH.OptionalHeader.AddressOfEntryPoint;        SetThreadContext(Thrd, ctx);  / 更新运行环境        ResumeThread(Thrd);           / 执行