[C++] Eigene Detours Teil1

Ein dickes Hallo an alle :D,

Ich m�chte euch mit diesem Tutorial den Umgang mit Detours zeigen. Zu allererst kl�ren wir die spannende Frage, was ein Detour ist:

Ein Detour f�hrt eine bestimmte Funktion von dir aus, sobald eine andere Funktion, die von dir bestimmt wird, aufgerufen wird. So ruft man bei Trainer mit einem D3D-Men� immer dann die eigene Methode zum Zeichnen des Men�s auf, wenn die Funktion EndScene() aus der D3D.dll aufgerufen wird. Also brauchst du f�r ein Ingame-Men� ein Detour :)

Okay damit sollte hoffentlich klar sein, was ein Detour ist, wenn nicht, fragt einfach nochmal nach. So jetzt kommen wir zu der Theorie, wie der Detour funktionieren soll. Erstmal geh ich grob auf n�tiges Backgroundwissen ein, damit du verstehst, warum wir was machen. Jede Funktion nimmt im Speicher eines Prozesses eine bestimmte Adresse und Gr��e ein. Zum Beispiel kann eine Funktion an der Adresse 0x0040CCE1 beginnen und an der Adresse 0x0040CE00 enden. Weiterhin solltest du wissen, dass jede Adresse ein Byte speichert. Ein Byte nimmt die Werte von 0x00 bis 0xFF ein. Die Bytes werden auch OP-Codes genannt. Jetzt haben einige OP-Codes ein spezielle Bedeutung. Zum Beispiel bedeutet 0x90 NOP, d.h. die Adresse ist ohne Funktion. Das Byte 0xE8 ist ein CALL. Ein CALL ruft eine andere Funktion auf. Das Byte 0xE9 ist ein JMP (Jump). Ein Jump springt an eine gewisse Adresse im Adressenraum. Nat�rlich habe ich nicht zuf�llig diese drei OP-Codes n�her erl�utert ;) Diese sind besonders f�r unseren Detour sp�ter interessant, also solltest du dir deren Bedeutung gut merken. So nachdem du dir jetzt im schnell-Exkurs wichtiges Backgroundwissen angeeignet hast, k�nnen wir zur Theorie eines Detours �bergehen. Zuallererst brauchen wir die Start-Adresse der Funktion, die wir mit unserem Detour versehen wollen. Diese bekommen wir mithilfe eines Debuggers, zum Beispiel OllyDbg. Nun werden wir die Funktion so ver�ndern, dass sie unsere Funktion aufruft und dann erst ihren Ablauf abarbeitet. Und zwar ersetzen wir das erste Byte der Funktion durch 0xE8. Wie oben bereits erw�hnt steht 0xE8 f�r den CALL Befehl. Nach dem CALL-Befehl folgen vier Bytes, die die Adresse der Funktion angeben, die durch CALL aufgerufen werden soll. Das klingt nicht nur einfach, das ist auch einfach ;) Aber leider etwas zu einfach, denn es gibt ein Problem: Wenn wir die ersten f�nf Bytes der Funktion �berschreiben, dann geht der alte Code verloren. Wenn das jetzt wichtiger Code war, dann st�rzt das Programm ab. Darum m�ssen wir da Vorkehrungen treffen. Und zwar speichern wir zuvor die OP-Codes, die �berschrieben werden. Dann fordern wir neuen Speicher an und schreiben die �berschriebenen Bytes dorthin. Danach springen ( JMP ;] ) wir aus der alten Funktion zu den angeforderten Speicherblock, wo der urspr�ngliche (wichtige) Code ausgef�hrt wird und anschlie�end zur�ck zur alten Funktion. Ich hoffe du kommst noch mit :D

Zusammenfassend:

1. Adresse der Ur-Funktion, die umgeleitet werden soll herausfinden
2. Neuen Speicher anfordern
3. Alte OP-Codes im neuen Speicher sichern
4. Bytes der Ur-Funktion mit CALL auf neue Funktion �berschreiben
5. Bytes der Ur-Funktion mit JMP auf Sicherung �berschreiben
6. Ende des Speicherblocks mit JMP auf Ur-Funktion �berschreiben

So dann fangen wir mal an die n�tige Funktion daf�r zu programmieren:

Als erstes sollten wir �berlegen, welche Parameter wir brauchen. Zum einen brauchen wir die Adresse der Ur-Funktion, dann die Adresse der neuen Funktion und zu guter letzt die Anzahl an Bytes, die gesichert werden sollen:

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    return true;
}

Was war schritt 1 nochmal? *Oben nachgucken* Okay, f�r das Programmieren brauchen wir vorerst die Adresse der Ur-Funktion nicht (wird sp�ter als Parameter �bergeben), also fangen wir mit Schritt 2 an, das Anfordern von neuem Speicher. Daf�r gibt es die sch�ne Funktion malloc(). Sie erwartet als Parameter die Gr��e des angeforderten Speicherblocks in Bytes und liefert als return-Wert einen void-Zeiger auf den Adressraum. An dieser Stelle sollten wir uns �berlegen: Wie gro� muss der Speicherblock sein? Dazu sollten wir uns �berlegen, was in den Speicherblock "kommt". Zum einen die gesicherten OP-Codes aus der Ur-Funktion, also muss der Speicherblock schonmal mindestens die Anzahl Bytes fassen k�nnen, die wir als Parameter len an die DetourFunc() �bergeben haben. Zum anderen m�ssen wir von dem Speicherblock wieder zur�ck zur Ur-Funktion springen k�nnen. Dazu muss der Speicherblock noch einen zus�tzlichen Byte f�r den Spring-Befehl aufnehmen k�nnen (0xE9) und nochmals vier weitere f�r die Zieladresse. Macht insgesamt f�nf Bytes. Die Gesamtgr��e ist also 5+len Bytes:

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    BYTE* newMem4base = NULL;
    
    newMem4base = ( BYTE* )malloc( 5+len );
    if( newMem4Base == NULL )
        return false;

    for( DWORD i = 0; i < ( len+5 ); i++ )
        newMem4base[i] = 0x90;

    return true;
}

newMem4base enth�lt also den Zeiger auf den neuen Speicherblock. Wenn die Funktion fehlschl�gt, der Zeiger also NULL ist, schl�gt die Funktion fehl und gibt false zur�ck. Danach belegen wir jeder Speicheradresse mit einem NOP ( entspricht nichts machen).
Der n�chste Schritt w�re das Speichern der alten Bytes im neuen Speicherblock. Dazu m�ssen wir uns erstmal die n�tigen Rechte verschaffen, um auf den Speicher zuzugreifen. Das geschieht mittels VirtualProtect(). MSDN liefert n�here Informationen zu der Funktion. Danach kopieren wir mithilfe von memcpy() die Bytes. memcpy() erwartet als ersten Parameter die Ziel-Adresse, als zweiten die Quelle und als dritten die Anzahl Bytes, die kopiert werden sollen:

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    BYTE* newMem4base = NULL;
    DWORD dwOld;
    
    newMem4base = ( BYTE* )malloc( 5+len );
    if( newMem4Base == NULL )
        return false;

    for( DWORD i = 0; i < ( len+5 ); i++ )
        newMem4base[i] = 0x90;

    VirtualProtect( oldFunc, len, PAGE_READWRITE, &dwOld );
    memcpy( newMem4base, oldFunc, len );

    return true;
}

Langsam kommen wir zum Ende :) Nachdem wir also die Bytes gesichert haben, m�ssen wir den CALL auf unsere neue Funktion einrichten. Dazu �berschrieben wir das erste Byte der Ur-Funktion mit dem OP-Code f�r CALL (0xE8):

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    BYTE* newMem4base = NULL;
    DWORD dwOld;
    
    newMem4base = ( BYTE* )malloc( 5+len );
    if( newMem4Base == NULL )
        return false;

    for( DWORD i = 0; i < ( len+5 ); i++ )
        newMem4base[i] = 0x90;

    VirtualProtect( oldFunc, len, PAGE_READWRITE, &dwOld );
    memcpy( newMem4base, oldFunc, len );
    oldFunc[0] = 0xE8;

    return true;
}

So unmittelbar nach dem CALL-Byte folgen vier Bytes, die die Adresse der Funktion angeben, die aufgerufen werden soll. Diese Adresse muss relativ zu der aktuellen Adresse sein. Wir haben als Parameter jedoch die absolute Adresse unserer Funktion angegeben, also m�ssen wir erst an die relative Adresse kommen. Dazu gibt es zum Gl�ck eine g�ltige Regel:

relativeAdresse = absoluteAdresse - aktuelleAdresse -5;

Die absoluteAdresse ist in unserem Fall die Adresse der neuen Funktion, die aktuelleAdresse ist die Adresse der Ur-Funktion. Damit ergibt sich folgendes:

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    BYTE* newMem4base = NULL;
    DWORD dwOld;
    
    newMem4base = ( BYTE* )malloc( 5+len );
    if( newMem4Base == NULL )
        return false;

    for( DWORD i = 0; i < ( len+5 ); i++ )
        newMem4base[i] = 0x90;

    VirtualProtect( oldFunc, len, PAGE_READWRITE, &dwOld );
    memcpy( newMem4base, oldFunc, len );
    oldFunc[0] = 0xE8;
    *( DWORD* )( oldFunc+0x01 ) = DWORD( newFunc-oldFunc-5 );

    return true;
}

Damit w�re der CALL auf unsere Funktion fertig. Nachdem unsere Funktion aufgerufen wurde, m�ssen wir nun zu unserem neuen Speicherblock springen, an dem die alten OP-Codes gespeichert wurden, damit unsere Ur-Funktion auch noch ordnungsgem�� ausgef�hrt wird. Dazu setzen wir das Byte der n�chsten Adresse auf 0xE9 und die n�chsten 4Bytes wieder auf die Adresse, zu der gesprungen werden soll. Auch hier m�ssen wir erst aus den absoluten Adressen relative machen:

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    BYTE* newMem4base = NULL;
    DWORD dwOld;
    
    newMem4base = ( BYTE* )malloc( 5+len );
    if( newMem4Base == NULL )
        return false;

    for( DWORD i = 0; i < ( len+5 ); i++ )
        newMem4base[i] = 0x90;

    VirtualProtect( oldFunc, len, PAGE_READWRITE, &dwOld );
    memcpy( newMem4base, oldFunc, len );
    oldFunc[0] = 0xE8;
    *( DWORD* )( oldFunc+0x01 ) = DWORD( newFunc-oldFunc-5 );
    oldFunc[5] = 0xE9;
    *( DWORD* )( oldFunc+0x06 ) = DWORD( newMem4base-( oldFunc+0x5 )-5 );

    return true;
}

Kaum zu glauben, aber wir sind fast fertig! Nur noch zwei Schritte:

1. Wir m�ssen von unserem Speicherblock wieder zur�ck zu der Ur-Funktion springen

2. Wir m�ssen "Zu viel" gesicherte Bytes aus der Ur-Funktion mit NOP's versehen

Diese Punkte sollten keine Probleme mehr bereiten. Zum ersten Schritt: Zuerst erh�hen wir die Adresse des neuen Speicherblocks, um die Anzahl der gesicherten Bytes, damit die Adresse auf freien Speicher zeigt. Danach �berschreiben wir wieder das erste Byte mit 0xE9 (JMP) und die n�chsten vier Bytes mit der relativen Adresse, zu der gesprungen werden soll. Zum zweiten Schritt: Insgesamt nehmen der CALL und der JMP aus der Ur-Funktion 10Bytes ein. Sollte die Anzahl der zu sichernden Bytes, die als Parameter �beregben wurde, gr��er als 10Bytes sein, m�ssen wir die restlichen Bytes aus der Ur-Funktion NOPen, damit diese nicht doppelt ausgef�hrt werden:

Code:

#include <windows.h>

bool DetourFunc( ( BYTE* )oldFunc, ( BYTE* )newFunc, DWORD len )
{
    BYTE* newMem4base = NULL;
    DWORD dwOld;
    
    newMem4base = ( BYTE* )malloc( 5+len );
    if( newMem4Base == NULL )
        return false;

    for( DWORD i = 0; i < ( len+5 ); i++ )
        newMem4base[i] = 0x90;

    VirtualProtect( oldFunc, len, PAGE_READWRITE, &dwOld );
    memcpy( newMem4base, oldFunc, len );
    oldFunc[0] = 0xE8;
    *( DWORD* )( oldFunc+0x01 ) = DWORD( newFunc-oldFunc-5 );
    oldFunc[5] = 0xE9;
    *( DWORD* )( oldFunc+0x06 ) = DWORD( newMem4base-( oldFunc+0x5 )-5 );
    newMem4base += len;
    newMem4base[0] = 0xE9;
    *( DWORD* )( newMem4base+0x01 ) = DWORD( ( oldFunc+10 )-newMem4base-5 );

    for( DWORD i = 10; i <len; i++ )
        oldFunc[i] = 0x90;

    return true;
}

So damit ist die DetourFunc() fertig programmiert. Bleibt eine spannende Frage: Wie wende ich die Funktion denn jetzt an? Diese spannende Frage werde ich im zweiten Teil des Tutorials mithilfe eines Beispiels erkl�ren ;) Also gedulded euch, bis es fertig ist :)

Wenn ihr Fragen habt, k�nnt ihr sie gerne stellen.

Und wenn ihr Fehler findet (sei es Formulierungsfehler oder Falschaussagen), bitte melden; ansonsten freue ich mich auch �ber Feedback.

[Only registered and activated users can see links. Click Here To Register...]

Credits:
Nope
[Only registered and activated users can see links. Click Here To Register...]