x64 main-thread hook mittels dll

**Clowdy**

Hallo,

ich versuche zur Zeit den main-thread einer Anwendung zu hooken.
Hierfür injecte ich die Dll ganz normal über CreateRemoteThread und rufe eine exportierte Funktion meiner Dll als Einstieg auf.

Die Dll versucht dann in den main-thread zu gelangen. Das funktioniert soweit auch, aber ab und an friert die Anwendung einfach ein, obwohl an der dll selber nichts verändert wurde.

Ich vermute das es Probleme mit dem Stack gibt.

Um in den main-thread zu gelangen verwende ich zunächst folgende 2 Funktionen, letztere ist sicher nicht perfekt vermute hier aber nicht den Fehler:

markieren

Code:

			function GetMainThreadId: Cardinal;

var

  ThreadEntry: THREADENTRY32;

  hThreadSnapShot: THandle;

  dwProcessId: Cardinal;

begin

  result := 0;

  dwProcessId := GetCurrentProcessId();

  ThreadEntry.dwSize := SizeOf(THREADENTRY32);

  hThreadSnapShot := CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, dwProcessID);

  if (Thread32First(hThreadSnapShot, ThreadEntry)) then

  begin

    repeat

      if (ThreadEntry.th32OwnerProcessID = dwProcessID) then

      begin

        CloseHandle(hThreadSnapShot);

        result := ThreadEntry.th32ThreadID;

        exit;

      end;

    until Thread32Next(hThreadSnapshot, ThreadEntry) = false;

    CloseHandle(hThreadSnapShot);

  end;

end;

function HookThread(pFunction: Pointer; var OldEIP: NativeUInt): Boolean;

var

  hThread: THandle;

  dwMainThreadId: Cardinal;

  ctx: TContext;

const

  THREAD_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or $3FF;

begin

  dwMainThreadId := GetMainThreadId();

  if (dwMainThreadId = 0) then

    exit(false);

  hThread := OpenThread(THREAD_ALL_ACCESS, false, dwMainThreadId);

  if (hThread = 0) then

    exit(false);

  if (SuspendThread(hThread) = Cardinal(-1)) then

  begin

    CloseHandle(hThread);

    exit(false);

  end;

  ctx.ContextFlags := CONTEXT_CONTROL;

  if not (GetThreadContext(hThread, ctx)) then

  begin

    ResumeThread(hThread);

    CloseHandle(hThread);

    exit(false);

  end;

  OldEIP := ctx.Rip;

  ctx.Rip := NativeUInt(pFunction);

  if (SetThreadContext(hThread, ctx)) then

  begin

    ResumeThread(hThread);

    CloseHandle(hThread);

    result := true;

  end else

    result := false;

end;

Direkt nach dem injizieren wird mittels der beiden Funktionen dann folgender Assembler Code aufgerufen:

zusammenfalten · markieren

Delphi-Quellcode:

			procedure AsmLoader; assembler;

asm

  sub     RSP, 8h

  push    RAX

  push    RBX

  push    RCX

  push    RDX

  push    RDI

  push    RSI

  push    RSP

  push    RBP

  push    R8

  push    R9

  push    R10

  push    R11

  push    R12

  push    R13

  push    R14

  push    R15

  mov RAX, _rip

  mov [RSP+128], RAX

  call _Load

  pop R15

  pop R14

  pop R13

  pop R12

  pop R11

  pop R10

  pop R9

  pop R8

  pop RBP

  pop RSP

  pop RSI

  pop RDI

  pop RDX

  pop RCX

  pop RBX

  pop RAX

end;

Load Funktion:

zusammenfalten · markieren

Delphi-Quellcode:

			procedure _Load;

begin

  // sobald hier etwas aufgerufen wird kann es krachen

  GetCurrentThreadId();

end;

// Exported function

procedure Load(pArgs: Pointer);

begin

  if not (HookThread(@AsmLoader, _rip)) then

    ExitProcessMessage('Basic init failed');

end;

_rip ist ein NativeUint.

Den Assembler Code um die Register zu sichern und anschließend meine Funktion aufzurufen habe ich aus einem C++ Forum, der andere Part stammt von mir.

Ich bin bei x64 komplett neu, wäre nett wenn da mal jemand nachschauen könnte ob das alles so korrekt ist, und mir ggf. noch mitteilen kann wieso weshalb warum

Es frieren übrigens alle Anwendungen ab und zu ein welche ich als Ziel benutze, kann auch das Notepad sein.

Grüße

x64 main-thread hook mittels dll

x64 main-thread hook mittels dll

Forumregeln