从内存中加载并运行exe

1. {配合anskya的AnyWhereFileToPas效果不错}
2. { ******************************************************* }
3. { *                 从内存中加载并运行exe               * }
4. { ******************************************************* }
5. { * 参数：                                                }
6. { * Buffer: 内存中的exe地址                               }
7. { * Len: 内存中exe占用长度                                }
8. { * CmdParam: 命令行参数(不包含exe文件名的剩余命令行参数）}
9. { * ProcessId: 返回的进程Id                               }
10. { * 返回值： 如果成功则返回进程的Handle(ProcessHandle),   }
11. {            如果失败则返回INVALID_HANDLE_VALUE           }
12. { ******************************************************* }
14. unit PEUnit;
16. interface
18. uses windows;
20. function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardinal): Cardinal;
22. implementation
24. {.$R ExeShell.res}   // 外壳程序模板(98下使用)
26. type
27. TImageSectionHeaders = array [0..0] of TImageSectionHeader;
28. PImageSectionHeaders = ^TImageSectionHeaders;
30. { 计算对齐后的大小 }
31. function GetAlignedSize(Origin, Alignment: Cardinal): Cardinal;
32. begin
33. result := (Origin + Alignment - 1) div Alignment * Alignment;
34. end;
36. { 计算加载pe并对齐需要占用多少内存，未直接使用OptionalHeader.SizeOfImage作为结果是因为据说有的编译器生成的exe这个值会填0 }
37. function CalcTotalImageSize(MzH: PImageDosHeader; FileLen: Cardinal; peH: PImageNtHeaders;
38.     peSecH: PImageSectionHeaders): Cardinal;
39. var
40. i: Integer;
41. begin
42. {计算pe头的大小}
43. result := GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment);
45. {计算所有节的大小}
46. for i := 0 to peH.FileHeader.NumberOfSections - 1 do
47.     if peSecH[i].PointerToRawData + peSecH[i].SizeOfRawData > FileLen then // 超出文件范围
48.     begin
49.       result := 0;
50.       exit;
51.     end
52.     else if peSecH[i].VirtualAddress <> 0 then //计算对齐后某节的大小
53.       if peSecH[i].Misc.VirtualSize <> 0 then
54.         result := GetAlignedSize(peSecH[i].VirtualAddress + peSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment)
55.       else
56.         result := GetAlignedSize(peSecH[i].VirtualAddress + peSecH[i].SizeOfRawData, PeH.OptionalHeader.SectionAlignment)
57.     else if peSecH[i].Misc.VirtualSize < peSecH[i].SizeOfRawData then
58.       result := result + GetAlignedSize(peSecH[i].SizeOfRawData, peH.OptionalHeader.SectionAlignment)
59.     else
60.       result := result + GetAlignedSize(peSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment);
62. end;
64. { 加载pe到内存并对齐所有节 }
65. function AlignPEToMem(const Buf; Len: Integer; var PeH: PImageNtHeaders;
66.     var PeSecH: PImageSectionHeaders; var Mem: Pointer; var ImageSize: Cardinal): Boolean;
67. var
68. SrcMz: PImageDosHeader;            // DOS头
69. SrcPeH: PImageNtHeaders;           // PE头
70. SrcPeSecH: PImageSectionHeaders;   // 节表
71. i: Integer;
72. l: Cardinal;
73. Pt: Pointer;
74. begin
75. result := false;
76. SrcMz := @Buf;
77. if Len < sizeof(TImageDosHeader) then exit;
78. if SrcMz.e_magic <> IMAGE_DOS_SIGNATURE then exit;
79. if Len < SrcMz._lfanew+Sizeof(TImageNtHeaders) then exit;
80. SrcPeH := pointer(Integer(SrcMz)+SrcMz._lfanew);
81. if (SrcPeH.Signature <> IMAGE_NT_SIGNATURE) then exit;
82. if (SrcPeH.FileHeader.Characteristics and IMAGE_FILE_DLL <> 0) or
83.       (SrcPeH.FileHeader.Characteristics and IMAGE_FILE_EXECUTABLE_IMAGE = 0)
84.       or (SrcPeH.FileHeader.SizeOfOptionalHeader <> SizeOf(TImageOptionalHeader)) then exit;
85. SrcPeSecH := Pointer(Integer(SrcPeH)+SizeOf(TImageNtHeaders));
86. ImageSize := CalcTotalImageSize(SrcMz, Len, SrcPeH, SrcPeSecH);
87. if ImageSize = 0 then
88.     exit;
89. Mem := VirtualAlloc(nil, ImageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE); // 分配内存
90. if Mem <> nil then
91. begin
92.     // 计算需要复制的PE头字节数
93.     l := SrcPeH.OptionalHeader.SizeOfHeaders;
94.     for i := 0 to SrcPeH.FileHeader.NumberOfSections - 1 do
95.       if (SrcPeSecH[i].PointerToRawData <> 0) and (SrcPeSecH[i].PointerToRawData < l) then
96.         l := SrcPeSecH[i].PointerToRawData;
97.     Move(SrcMz^, Mem^, l);
98.     PeH := Pointer(Integer(Mem) + PImageDosHeader(Mem)._lfanew);
99.     PeSecH := Pointer(Integer(PeH) + sizeof(TImageNtHeaders));
101.     Pt := Pointer(Cardinal(Mem) + GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment));
102.     for i := 0 to PeH.FileHeader.NumberOfSections - 1 do
103.     begin
104.       // 定位该节在内存中的位置
105.       if PeSecH[i].VirtualAddress <> 0 then
106.         Pt := Pointer(Cardinal(Mem) + PeSecH[i].VirtualAddress);
108.       if PeSecH[i].SizeOfRawData <> 0 then
109.       begin
110.         // 复制数据到内存
111.         Move(Pointer(Cardinal(SrcMz) + PeSecH[i].PointerToRawData)^, pt^, PeSecH[i].SizeOfRawData);
112.         if peSecH[i].Misc.VirtualSize < peSecH[i].SizeOfRawData then
113.           pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecH[i].SizeOfRawData, PeH.OptionalHeader.SectionAlignment))
114.         else
115.           pt := pointer(Cardinal(pt) + GetAlignedSize(peSecH[i].Misc.VirtualSize, peH.OptionalHeader.SectionAlignment));
116.         // pt 定位到下一节开始位置
117.       end
118.       else
119.         pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment));
120.     end;
121.     result := True;
122. end;
123. end;
125. type
126. TVirtualAllocEx = function (hProcess: THandle; lpAddress: Pointer;
127.                                   dwSize, flAllocationType: DWORD; flProtect: DWORD): Pointer; stdcall;
129. var
130. MyVirtualAllocEx: TVirtualAllocEx = nil;
132. function IsNT: Boolean;
133. begin
134. result := Assigned(MyVirtualAllocEx);
135. end;
137. { 生成外壳程序命令行 }
138. function PrepareShellExe(CmdParam: string; BaseAddr, ImageSize: Cardinal): string;
139. var
140. r, h, sz: Cardinal;
141. p: Pointer;
142. fid, l: Integer;
143. buf: Pointer;
144. peH: PImageNtHeaders;
145. peSecH: PImageSectionHeaders;
146. begin
147. if IsNT then
148. { NT 系统下直接使用自身程序作为外壳进程 }
149.     result := ParamStr(0)+CmdParam
150. else begin
151. // 由于98系统下无法重新分配外壳进程占用内存,所以必须保证运行的外壳程序能容纳目标进程并且加载地址一致
152. // 此处使用的方法是从资源中释放出一个事先建立好的外壳程序,然后通过修改其PE头使其运行时能加载到指定地址并至少能容纳目标进程
153.     r := FindResource(HInstance, 'SHELL_EXE', RT_RCDATA);
154.     h := LoadResource(HInstance, r);
155.     p := LockResource(h);
156.     l := SizeOfResource(HInstance, r);
157.     GetMem(Buf, l);
158.     Move(p^, Buf^, l);   // 读到内存
159.     FreeResource(h);
160.     peH := Pointer(Integer(Buf) + PImageDosHeader(Buf)._lfanew);
161.     peSecH := Pointer(Integer(peH) + sizeof(TImageNtHeaders));
162.     peH.OptionalHeader.ImageBase := BaseAddr;    // 修改PE头重的加载基址
163.     if peH.OptionalHeader.SizeOfImage < ImageSize then // 目标比外壳大,修改外壳程序运行时占用的内存
164.     begin
165.       sz := Imagesize - peH.OptionalHeader.SizeOfImage;
166.       Inc(peH.OptionalHeader.SizeOfImage, sz);    // 调整总占用内存数
167.       Inc(peSecH[peH.FileHeader.NumberOfSections-1].Misc.VirtualSize, sz);   // 调整最后一节占用内存数
168.     end;
170.     // 生成外壳程序文件名, 为本程序改后缀名得到的
171.     // 由于不想 uses SysUtils (一旦 use 了程序将增大80K左右), 而且偷懒，所以只支持最多运行11个进程，后缀名为.dat, .da0~.da9
172.     result := ParamStr(0);
173.     result := copy(result, 1, length(result) - 4) + '.dat';
174.     r := 0;
175.     while r < 10 do
176.     begin
177.       fid := CreateFile(pchar(result), GENERIC_READ or GENERIC_WRITE, 0, nil, Create_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
178.       if fid < 0 then
179.       begin
180.         result := copy(result, 1, length(result)-3)+'da'+Char(r+Byte('0'));
181.         inc(r);
182.       end
183.       else begin
184.         //SetFilePointer(fid, Imagesize, nil, 0);
185.         //SetEndOfFile(fid);
186.         //SetFilePointer(fid, 0, nil, 0);
187.         WriteFile(fid, Buf^, l, h, nil); // 写入文件
188.         CloseHandle(fid);
189.         break;
190.       end;
191.     end;
192. //    result := result + CmdParam; // 生成命令行
193.     result   := '"'+result+'"'+CmdParam ;
194.     FreeMem(Buf);
195. end;
196. end;
198. { 是否包含可重定向列表 }
199. function HasRelocationTable(peH: PImageNtHeaders): Boolean;
200. begin
201. result := (peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress <> 0)
202.       and (peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size <> 0);
203. end;
205. type
206. PImageBaseRelocation= ^TImageBaseRelocation;
207. TImageBaseRelocation = packed record
208.     VirtualAddress: cardinal;
209.     SizeOfBlock: cardinal;
210. end;
212. { 重定向PE用到的地址 }
213. procedure DoRelocation(peH: PImageNtHeaders; OldBase, NewBase: Pointer);
214. var
215. Delta: Cardinal;
216. p: PImageBaseRelocation;
217. pw: PWord;
218. i: Integer;
219. begin
220. Delta := Cardinal(NewBase) - peH.OptionalHeader.ImageBase;
221. p := pointer(cardinal(OldBase) + peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
222. while (p.VirtualAddress + p.SizeOfBlock <> 0) do
223. begin
224.     pw := pointer(Integer(p) + Sizeof(p^));
225.     for i := 1 to (p.SizeOfBlock - Sizeof(p^)) div 2 do
226.     begin
227.       if pw^ and $F000 = $3000 then
228.         Inc(PCardinal(Cardinal(OldBase) + p.VirtualAddress + (pw^ and $0FFF))^, Delta);
229.       inc(pw);
230.     end;
231.     p := Pointer(pw);
232. end;
233. end;
235. type
236. TZwUnmapViewOfSection = function (Handle, BaseAdr: Cardinal): Cardinal; stdcall;
238. { 卸载原外壳占用内存 }
239. function UnloadShell(ProcHnd, BaseAddr: Cardinal): Boolean;
240. var
241. M: HModule;
242. ZwUnmapViewOfSection: TZwUnmapViewOfSection;
243. begin
244. result := False;
245. m := LoadLibrary('ntdll.dll');
246. if m <> 0 then
247. begin
248.     ZwUnmapViewOfSection := GetProcAddress(m, 'ZwUnmapViewOfSection');
249.     if assigned(ZwUnmapViewOfSection) then
250.       result := (ZwUnmapViewOfSection(ProcHnd, BaseAddr) = 0);
251.     FreeLibrary(m);
252. end;
253. end;
255. { 创建外壳进程并获取其基址、大小和当前运行状态 }
256. function CreateChild(Cmd: string; var Ctx: TContext; var ProcHnd, ThrdHnd, ProcId, BaseAddr, ImageSize: Cardinal): Boolean;
257. var
258. si: TStartUpInfo;
259. pi: TProcessInformation;
260. Old: Cardinal;
261. MemInfo: TMemoryBasicInformation;
262. p: Pointer;
263. begin
264. FillChar(si, Sizeof(si), 0);
265. FillChar(pi, SizeOf(pi), 0);
266. si.cb := sizeof(si);
267. result := CreateProcess(nil, PChar(Cmd), nil, nil, False, Create_SUSPENDED, nil, nil, si, pi); // 以挂起方式运行进程
268. if result then
269. begin
270.     ProcHnd := pi.hProcess;
271.     ThrdHnd := pi.hThread;
272.     ProcId := pi.dwProcessId;
274.     { 获取外壳进程运行状态，[ctx.Ebx+8]内存处存的是外壳进程的加载基址，ctx.Eax存放有外壳进程的入口地址 }
275.     ctx.ContextFlags := CONTEXT_FULL;
276.     GetThreadContext(ThrdHnd, ctx);
277.     ReadProcessMemory(ProcHnd, Pointer(ctx.Ebx+8), @BaseAddr, SizeOf(Cardinal), Old); // 读取加载基址
278.     p := Pointer(BaseAddr);
280.     { 计算外壳进程占有的内存 }
281.     while VirtualQueryEx(ProcHnd, p, MemInfo, Sizeof(MemInfo)) <> 0 do
282.     begin
283.       if MemInfo.State = MEM_FREE then
284.         break;
285.       p := Pointer(Cardinal(p) + MemInfo.RegionSize);
286.     end;
287.     ImageSize := Cardinal(p) - Cardinal(BaseAddr);
288. end;
289. end;
291. { 创建外壳进程并用目标进程替换它然后执行 }
292. function AttachPE(CmdParam: string; peH: PImageNtHeaders; peSecH: PImageSectionHeaders;
293.     Ptr: Pointer; ImageSize: Cardinal; var ProcId: Cardinal): Cardinal;
294. var
295. s: string;
296. Addr, Size: Cardinal;
297. ctx: TContext;
298. Old: Cardinal;
299. p: Pointer;
300. Thrd: Cardinal;
301. begin
302. result := INVALID_HANDLE_VALUE;
303. s := PrepareShellExe(CmdParam, peH.OptionalHeader.ImageBase, ImageSize);
304. if CreateChild(s, ctx, result, Thrd, ProcId, Addr, Size) then
305. begin
306.     p := nil;
307.     if (peH.OptionalHeader.ImageBase = Addr) and (Size >= ImageSize) then // 外壳进程可以容纳目标进程并且加载地址一致
308.     begin
309.       p := Pointer(Addr);
310.       VirtualProtectEx(result, p, Size, PAGE_EXECUTE_READWRITE, Old);
311.     end
312.     else if IsNT then // 98 下失败
313.     begin
314.       if UnloadShell(result, Addr) then // 卸载外壳进程占有内存
315.         // 重新按目标进程加载基址和大小分配内存
316.         p := MyVirtualAllocEx(Result, Pointer(peH.OptionalHeader.ImageBase), ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);
317.       if (p = nil) and hasRelocationTable(peH) then // 分配内存失败并且目标进程支持重定向
318.       begin
319.         // 按任意基址分配内存
320.         p := MyVirtualAllocEx(result, nil, ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);
321.         if p <> nil then
322.           DoRelocation(peH, Ptr, p); // 重定向
323.       end;
324.     end;
325.     if p <> nil then
326.     begin
327.       WriteProcessMemory(Result, Pointer(ctx.Ebx+8), @p, Sizeof(DWORD), Old); // 重置目标进程运行环境中的基址
328.       peH.OptionalHeader.ImageBase := Cardinal(p);
329.       if WriteProcessMemory(Result, p, Ptr, ImageSize, Old) then // 复制PE数据到目标进程
330.       begin
331.         ctx.ContextFlags := CONTEXT_FULL;
332.         if Cardinal(p) = Addr then
333.           ctx.Eax := peH.OptionalHeader.ImageBase + peH.OptionalHeader.AddressOfEntryPoint // 重置运行环境中的入口地址
334.         else
335.           ctx.Eax := Cardinal(p) + peH.OptionalHeader.AddressOfEntryPoint;
336.         SetThreadContext(Thrd, ctx); // 更新运行环境
337.         ResumeThread(Thrd);           // 执行
338.         CloseHandle(Thrd);
339.       end
340.       else begin // 加载失败,杀掉外壳进程
341.         TerminateProcess(Result, 0);
342.         CloseHandle(Thrd);
343.         CloseHandle(Result);
344.         Result := INVALID_HANDLE_VALUE;
345.       end;
346.     end
347.     else begin // 加载失败,杀掉外壳进程
348.       TerminateProcess(Result, 0);
349.       CloseHandle(Thrd);
350.       CloseHandle(Result);
351.       Result := INVALID_HANDLE_VALUE;
352.     end;
353. end;
354. end;
356. function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardinal): Cardinal;
357. var
358. peH: PImageNtHeaders;
359. peSecH: PImageSectionHeaders;
360. Ptr: Pointer;
361. peSz: Cardinal;
362. begin
363. result := INVALID_HANDLE_VALUE;
364. if alignPEToMem(ABuffer, Len, peH, peSecH, Ptr, peSz) then
365. begin
366.     result := AttachPE(CmdParam, peH, peSecH, Ptr, peSz, ProcessId);
367.     VirtualFree(Ptr, peSz, MEM_DECOMMIT);
368.     //VirtualFree(Ptr, 0, MEM_RELEASE);
369. end;
370. end;
372. initialization
373. MyVirtualAllocEx := GetProcAddress(GetModuleHandle('Kernel32.dll'), 'VirtualAllocEx');
375. end.