DLL-Injector?!

temp := VirtualAllocEX(pid,neededmemory);
if target <> nil then
begin
 temp := virtualalloc(nil,neededmemory,MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
 if temp <> nil then
 begin
  CopyMemory(.....); //halt den Call für LoadLibraryA an den allocierten Speicher kopieren
  WriteProcessMemory(......) // und anschließend in den Target Process schreiben.
 end;
end;

function InjectLibrary(dwProcessID: Cardinal; pLibraryName: PChar): Pointer; stdcall;

 {Temporary code which will be injected in the target process.}
 procedure AsmTempBegin; assembler;
 asm
  PUSH $12345678         // PUSH offset library name
  CALL DWORD PTR [$00000000]   // CALL LoadLibraryA
  RET
 end;
 procedure AsmTempEnd; assembler; begin end;

var
 dwProcessID2: DWord;
 dwBytesWritten: DWord;
 dwAsmSize: DWord;
 dwMemoryNeeded: DWord;

 pMemoryTarget: Pointer;
 pMemoryTemp: Pointer;
 pLoadLibraryA: Pointer;

 nChange: PDWord;

 s: String;
Begin
 Result := nil;

 pLoadLibraryA := GetProcAddress(LoadLibrary('kernel32.dll'), 'LoadLibraryA');
 if (pLoadLibraryA = nil) then
  Exit; {Cant get offset of API LoadLibraryA.}

 dwProcessID2 := OpenProcess(PROCESS_ALL_ACCESS, False, dwProcessID);
 if (dwProcessID2 = 0) then
  Exit; {Cant open the target process with all access rights.}

 s := pLibraryName;
 dwAsmSize := DWord(@AsmTempEnd) - DWord(@AsmTempBegin);
 dwMemoryNeeded := DWord(Length(s)) + 1 + dwAsmSize + 4;

 pMemoryTarget := VirtualAllocExX(dwProcessID2, dwMemoryNeeded);
 if (pMemoryTarget = nil) then
 begin
  CloseHandle(dwProcessID2);
  Exit; {Cant get memory for our injectioncode inside the target process.}
 end;

 pMemoryTemp := VirtualAlloc(nil, dwMemoryNeeded, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
 if (pMemoryTemp = nil) then
 begin
  VirtualFreeExX(dwProcessID2,pMemoryTarget,dwMemoryNeeded,MEM_RELEASE);
  CloseHandle(dwProcessID2);
  Exit; {Cant get memory in our process for temporary used memory.}
 end;

 CopyMemory(pMemoryTemp, @AsmTempBegin, dwAsmSize);

 {Setting the correct Adresses for the inject Code.}
 nchange := Pointer(DWord(pMemoryTemp) + 1);
 nchange^ := DWord(pMemoryTarget) + dwAsmSize + 4;
 nchange := Pointer(DWord(pMemoryTemp) + 7);
 nchange^ := DWord(pMemoryTarget) + dwAsmSize;
 nchange := Pointer(DWord(pMemoryTemp) + dwAsmSize);
 nchange^ := DWord(pLoadLibraryA);

 {Writing the LoadLibraryA code from temporary memory into target memory.
  If success then create a thread on target memory.
  Return the address of the target memory.}
 CopyMemory(Pointer(Cardinal(pMemoryTemp) + dwAsmSize + 4), @S[1], Length(S));
 If WriteProcessMemory(dwProcessID2, pMemoryTarget, pMemoryTemp, dwMemoryNeeded, dwBytesWritten) And
   CreateRemoteThreadX(dwProcessID, pMemoryTarget) Then
  Result := pMemoryTarget;

 VirtualFree(pMemoryTemp, dwMemoryNeeded, MEM_DECOMMIT);
 CloseHandle(dwProcessID2);
end;

library testdll

uses
 SysUtils,
 windows,
 Classes;

{$R *.res}

var
 cAppPath: array [0..MAX_PATH] of char;
 szAppName : String;
begin
 GetModuleFileName(0, @cAppPath, SizeOf(cAppPath));
 szAppName := ExtractFileName(cAppPath);
 MessageBoxA(0,PChar(szAppName),'',MB_OK);
end.