SetWindowsHookEx innerhalb der DLL selbst

[zeras]

Du solltest keine Messages aufrufen zum Test. Bei mir mache ich das in der Statusbar, dass ich einen Zähler hochzähle. Geht bei dir nicht so, weil du eine DLL hast. Versuche aber mal, den Status irgendwo anders anzuzeigen.

[Aphton]

Hihhi ^^

Ich hatte auch Probleme beim Hooken *sigh

Es gibt zwei Ursachen:
- du hast eine 32 Bit Dll auf ein 64 Bit System - nur 32 Bit Anwendungen werden gehookt
- deine Anwendung hookt nur Prozesse, die auch von Sicherheitsgrad gleichhoch oder geringer sind! Dh. du kannst Anwendungen, die im Admin-Kontext laufen, nicht aus einem niederwertigeren Kontext hooken! EDIT: Ich glaube sogar, man kann sich nur im gleichen Kontext bewegen.. kA, teste einfach!

Edit:
Zum Test - "Wir sind im Hook" soltle auf jeden Fall erscheinen, wenn deine eigene Anwendung (der Hooker) im Vordergrund ist / Fokus hat und du eine Taste drückst!

Edit 2:
Achja, bzgl MainHook := ... der Code ab dieser Stelle sollte in einer Funktion ausgelagert werden, die veröffentlicht und nur einmal per Hooker aufgerufen wird - da sonst rekursiv bei jedem Hook (und somit bei jedem Laden) global gehookt wird. Sofern Windows das nicht berücksichtigt, dürfte es zum Systemabsturz- oder Instabilität kommen!

[hedie]

Hallo

Danke für deine Antwort.

Dies könnten wirklich gründe dafür sein.


Um mal zu teste, ob die DLL korrekt geladen wurde, möchte ich aus meiner Anwendung heraus, eine DLL Funktion aufrufen.

Folgendes Szenario:

Meine App_A injiziert eine DLL mit exportierten Funktionen in eine zweite App_B von mir.
Nun möchte ich, nachdem die DLL in App_B geladen wurde von App_A heraus eine Funktion der DLL aufrufen, welch in App_B ist.
Doch die frage, wie geht sowas?

Ist dies einfacher über Messages zu lösen?

[hedie]

Habe eine Idee wie dies funktionieren könnte...

1: Dll in externe App injizieren und den Speicheraddressen beginn merken (dllAddressExtern)
2: Nun die DLL in den eigenen Prozess laden und ebenfalls die Startaddresse speichern (dllAddressIntern)
3: Nun mit GetProcAddress die Addresse der Funktion innerhalb der in den eigenen Prozess geladenen DLL finden und speichern.
4: Die Adresse von GetProcAddress abzüglich die Startaddresse ergibt unseren Offset.
5: Diesen Offset zu dllAddressExtern addieren und schon haben wir die Addresse der Funktion in der Zielapp.

Ich habe nun versucht einer internen Funktion den Pointer von eben dieser Adresse zu geben und aufzurufen.
Aber im nachhinein ist mir aufgefallen, das dies ja nur für den eigenen Speicherbereich klappt.

Leider weiss ich also nicht wie ich nun die Externe funktion aufrufen kann...

Habe nun folgenden Code zusammen:

Delphi-Quellcode:

TestMyApp := GetProcAddress(th,pchar('TestMyApp'));
  writeln;
  write('Dll Adresse extern: ');
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  write(integer(pdllname));
  dllAddrExtern := integer(pdllname);
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);
  writeln;

  dllAddressIntern := LoadLibrary(pchar(ExtractFilePath(paramstr(0)) + 'InjectedDll.dll'));    //Interne DLL Adresse holen
  dllOffset := integer(GetProcAddress(dllAddressIntern,'TestMyApp')) - dllAddressIntern;

  write('Dll Adresse intern: ');
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  write(inttostr(dllAddressIntern));
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);
  writeln;

  write('Dll Adresse Offset: ');
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  write(inttostr(dllOffset));
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);
  writeln;

  TestMyApp := Pointer(dllAddrExtern + dllOffset);

  write('Dll Funktions Addresse: ');
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
  write(inttostr(dllAddrExtern + dllOffset));
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);
  writeln;
  writeln('Versuche nun die Funktion auszuführen!');
  readln(myInput);
  readln(myInput);
  TestMyApp;

[Aphton]

Deine Methode mag zu 95% aller Fälle klappen aber leider nicht immer! Der ImageBase Wert einer PE Datei (exe, dll) ist nur ein Richtwert - also nichts absolutes.
Stell dir mal vor, das wäre nicht so - was passiert dann, wenn zwei Dlls als ImageBase $200000 (den gleichen Wert) hätten? Dann würden sie sich im Speicher überschreiben.
Der PE Loader von Windows determiniert zu Beginn, ob es an die "gewünschte" Stelle geladen werden kann, sonst berechnet er eben eine andere Adresse.

Somit kannste es so vergessen.

Es geht jedoch anders. In der Classes Unit gibts die Funktion "AllocateHWnd()". Damit kannst du ganz einfach (unsichtbare) Dummy-Fenster erstellen, die du hauptsächlich für den Nachrichtenaustausch (Windows Messages) brauchen wirst.
Hast du das mal hingekriegt, kannst du nun von der Anwendung A ein Message-Broadcast abschicken (HWND_BROADCAST als Fenster-Handle) und das Dummy-Fenster in der Dll, das ja Nachrichten nun empfangen kann (dafür benötigst du evt {sofern der Hauptthread dies nicht tut} einen Thread, der dies bewerkstelligt [also ein GetMessage()->TranslateMessage()/DispatchMessage()], kann darauf reagieren und bestimmte Dinge, die du definierst/programmierst, durchführen.

Btw. Sorry für Klammerception!

Edit: Achja, aus deinem Code kann ich noch ein Blödsinn erkennen -> du versucht, Code in fremden Prozessen auszuführen. So geht das leider nicht. Der Prozessspeicher ist getrennt. Du hast zwar Zugriff auf dieselbe Adresse, jedoch befindet sich dort nicht die Funktion des anderen Prozessees. Das ganze klappt durch Paging usw.
Benütz da lieber die WinApi -> "CreateRemoteThread()" die kann in fremden Prozessen an beliebiger Stelle einen Thread starten!