Wie kann ich WinApi Funktionen "blocken"? Ich möchte z.b., dass die Funktion keybd_event() nicht auf meine Anwendung ausführbar ist. Ich kenne Programme die können das. Angeblich hooken sie Winapi calls und vereiteiln diese.

grob beschrieben:

-zielprozess öffnen
-code einschleusen der
-die addresse der funktion herrausfindet
-eigene funktion in den prozess injizieren
-ersten 5 bytes der funktion überschreiben (am besten auch irgentwo speichern)
mit einem far-jump zu der addresse (0xE9 xx xx xx xx (x = offset deiner funktion))
-fertig

google mal nach

FindWindow
GetWindowThreadProzessId
OpenProzess
virtualAllocEx
WriteProzessMemory
CreateRemoteThread

ja aber wozu soll das gut sein. ich sehe keinen sinnvollen grund soetwas zu tun.

hey wer klaut da mein nickname

Tobi5 schrieb:

das Problem ist jetzt, woher soll mal vorher wissen welchen Prozess man öffnen muss bzw. welcher Prozess schädliche WinApi calls machen würde?
Oder muss man dass dann in jeden Prozess machen der da ist?

eigentlich musst du jeden prozess infizieren, der diese funktion auf dein programm
aufrufen könnte.
kannst ja eine tabelle mit "harmlosen" prozessen anlegen z.b. explorer.exe oder
winlogon.exe

alles andere wird infiziert (guck mal hier für ein beispiel)

warum soll ers nicht hinkriegen nur weil er danach fragt?
so kann man das nie lernen, fragen ist gut !

da gibbet auchnoch einen guten Artikel in dem die grundlagen gut beschrieben sind.

MfG helferlein

schützen kannst du dich in dem du jede! funktion der api vor dem aufruf
auf einen sprung überprüfst, der ja mit dem opcode 0xE9 anfängt.

template <class T>
bool isFuncOk(T funcptr)
{
    char *addr = reinterpret_cast<char *>(funcptr);
    return *addr != 0xE9;
}

gibt aber bestimmt noch andere sprünge außer far-call die das selbe ermöglichen

das ganze klappt nicht bei jedem prozess und als nicht-admin bei nochweniger.

schützen kannst du dich in dem du jede! funktion der api vor dem aufruf
auf einen sprung überprüfst, der ja mit dem opcode 0xE9 anfängt.

template <class T>
bool isFuncOk(T funcptr)
{
    char *addr = reinterpret_cast<char *>(funcptr);
    return *addr != 0xE9;
}

gibt aber bestimmt noch andere sprünge außer far-call die das selbe ermöglichen

das ist doch quartsch es gibt jawoll viele möglichleiten api hooking zu betrieben stichwort IAT und viele andere

die ersten 5 byte der funktion wurde überschrieben und durch einen farcall
ersetzt, also dem opcode für den sprung an deine eigene funktion.

sämtliche funktionen der winapi nutzen die stdcall aufrufkonvention. diese
funktionen beginnen aufgrund der konvention immer mit den selben 5 bytes.

push ebp
mov ebp, esp
sub esp, xx

(xx steht für die größe aller lokalen variablen)

diese wurden überschrieben. um die funktion dennoch aufrufen zu können,
muss man diese selber ausführen, z.b. mit inline-assembler

__declspec(naked) DWORD callfunc(void * func) // verhindert dass der kompiler den funktionsprolog hinzufügt
{
    char *addr = reinterpret_cast<char *>(func) + 5; // 5 bytes weiter
    __asm
    {
        mov ebx, addr // hier speichern wir die addresse
        push ebp
        mov ebp, esp
        sub esp, xx // !!
        jmp ebx
    }
}

hier haben wir allerdings ein problem, denn wir wissen nicht wieviele variablen
die funktion auf den stack legt.

wenn wir zuwenig nehmen überschreiben wir die rücksprungaddresse und den framepointer.
wenn wir zuviel nehmen, kann es sein dass das selbe problem auftrifft,
es kann aber auch sein, dass der wert von ebp genommen wird statt die selbe
größe wieder auf den esp zu addieren. hier weiß ich nicht genau wie die
winapi das macht, ich befürchte beide versionen gibt es.

lässt sich bestimmt auch lösen, aber dazu müsste man die funktion
disassemblieren und ....

aber ich weiß nicht ob dir das viel bringt, da du die grundlagen verstanden
haben musst. was dein letzer post nur bestätigt.

guck dir mal die links an und versuch alles zu verstehen.

edit:

klempfner schrieb:

es gibt jawoll viele möglichleiten api hooking zu betrieben stichwort IAT und viele andere

es war nur ein beispiel. natürlich gibt es noch viele andere möglichkeiten

sämtliche funktionen der winapi nutzen die stdcall aufrufkonvention. diese
funktionen beginnen aufgrund der konvention immer mit den selben 5 bytes.

push ebp
mov ebp, esp
sub esp, xx

(xx steht für die größe aller lokalen variablen)

Aber dann hät ich da mal ne Frage:

Warum hat dann z.B. FindNextFileW diese ersten 12Bytes:

6A 2C             PUSH 2C
68 C8F0807C       PUSH kernel32.7C80F0C8
E8 0035FFFF       CALL kernel32.7C8024D6

Zumindestens laut Olly?

Gruß Pingu

#include <windows.h>
#include <iostream>

using namespace std;

BOOL WINAPI __stdcall SetCursorPosA(int x, int y);
DWORD DLLFunc;

int main()
{
	Sleep(2000);
	HINSTANCE hInst = LoadLibrary(TEXT("user32.dll"));
    DLLFunc = (DWORD)GetProcAddress(hInst, "SetCursorPos") + 5;  
	bool somebool = SetCursorPosA(0, 0);

	return 0;
}

BOOL WINAPI __stdcall SetCursorPosA(int x, int y)
{
   __asm
   {
      mov  edi, edi
      push ebp
      mov  ebp, esp
      jmp [DLLFunc]
   }
}

Warum crashed das programm?

BOOL WINAPI __stdcall SetCursorPosA(int x, int y)
{
   __asm
   {
      mov  edi, edi
      push ebp
      mov  ebp, esp
      jmp [DLLFunc]
   }
}

Warum crashed das programm?

Hi,
ich würd behaupten das, dass Problem is das du bei jmp ein Offset angeben musst und nicht die Adresse die du z.B. von GetProcAddress() bekommts.
Und das Offset wäre: Ziel-Absprung.
Desweiteren wird doch ,wenn du das so machst, der Prolog deiner Funktion + der Prolog von SetCursorPos aufgerufen. Das sollte au nicht so gut sein.
Schreib lieber statt:

BOOL WINAPI __stdcall SetCursorPosA(int x, int y)

was zumal sowieso komisch is da ja WINAPI nur ein #define für __stdcall ist,

BOOL __declspec(naked) SetCursorPosA(int x, int y)

Somit haste kein Prolog und es sollte funktionieren.

Gruß Pingu

Es funktioniert jetzt, die Funktion wird ausgeführt, aber danach Crashed das Programm noch

ich würd behaupten das, dass Problem is das du bei jmp ein Offset angeben musst und nicht die Adresse die du z.B. von GetProcAddress() bekommts.
Und das Offset wäre: Ziel-Absprung.

!!

was meinst du mit Ziel- Absprung? Ich verstehe nicht ganz was gemeint ist

00411113 /E9 D8060000       JMP muh.mainCRTStartup //dieser Jump springt von 0x00411113 nach 0x004117F0 und nicht nach D8060000
....
004117F0 \8BFF              MOV EDI,EDI

Sprich:
Offset = Ziel - Absprung

Also musst du das Offset angeben das im "Little-Endian-Format" angegeben ist, was ich auch erst vor ein paar Tagen erfahren hab ;).

Gruß Pingu

danke, ich verstehe wo das Problem liegt aber
Offset = Ziel - Absprung
Ziel = DLLFunc = (DWORD)GetProcAddress(hInst, "SetCursorPos") + 5;
Absprung = DLLFunc = (DWORD)GetProcAddress(hInst, "SetCursorPos");
Offset = DLLFunc = (DWORD)GetProcAddress(hInst, "SetCursorPos") + 5; - DLLFunc = (DWORD)GetProcAddress(hInst, "SetCursorPos");
ich denke nicht, dass das so gemeint war?

Noe nicht ganz.
Also Ziel ist korrekt, aber Absprung ist ja:
SetCursorPosA + länge der Opcodes bist jmp [DLLFunc] + 5 für die länge des Opcodes jmp

Deswegen is bei meinem Bspl.

Ziel: 004117F0
Absprung: 00411118

Offset: D8060000 //Little Endian

Wenn nicht klar dann schau mal den Thread hier an:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-230718.html

Gruß Pingu

Absprung = (DWORD)GetProcAddress(hInst, "SetCursorPosA") + opcodes + 5

was sind die länge der Opcodes?

In beiden Fällen rate ich dir lass es einfach!