Delphi 在内存中运行EXE程序,从资源文件中加载

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