![[HowTo]NoMenuhack coden(leicht)](https://www.elitepvpers.com/forum/iconimages/warrock-guides-tutorials-modifications/howto-nomenuhack-coden-leicht_ltr.gif){kind=small}
hab mal en kleines aber freines tutorial gemacht wie man einen nomenuhack für warrock erstellt.
Auf diese art gibt es noch keinen,nur mit andren codes....
1. Methode
2. Grundgerüst der Dll
3. "Hackfunktionen eincoden"
4. Fertiger, vollständiger Quellcode
5. FAQ
1. Methode, oder "Wie funktionieren Hacks":
Mir sind insgesamt zwei Methoden bekannt, wie man einen Hack programmieren kann. Eine davon läuft über die sogenannte "Dll-Injektion". Die andere Methode macht sich WinAPI-Funktionen, wie WriteProcessMemory() und ReadProcessMemory(), zu nutze. In diesem Tutorial möchte ich euch die "Dll-Injektion" vorstellen. Hierbei veranlasst der sogenannte Injektor, dass der Zielprozess (z.B. WarRock) unsere Dll in seinen Speicher lädt. Befindet sich unser Modul erst einmal im Speicher des Zielprogramms können wir von dort einfach über Zeiger den Speicher beliebig verändern. Jetzt kommen die sogenannten "Addys" ins Spiel. Die Addys sind die Adressen der Werte, die wir in unserem Modul über die Zeiger verändern wollen, um das Spiel zu manipulieren. Die Adressen werden meistens in der hexadezimalen Schreibweise dargestellt (erkennbar an dem "0x" vor der Zahl). Nehmen wir als Beispiel an, dass die Adresse 0x007D78E5 die aktuelle Munition speichert. Wollen wir nun zum Beispiel 1000 Einheiten an Munition haben, müssen wir nur den Wert der Adresse mit 1000 überschreiben. Ich hoffe das ist einigermaßen verständlich.
Zusammengefasst:
- Wir werden eine Dll programmieren
- Diese Dll wird mittels einem Injektor in den Zielprozess injiziert
- In unserer Dll werden wir mittels Zeiger die Werte bestimmter Adressen verändern
2. Grundgerüst der Dll
Eine Dll hat, ähnlich wie eine Exe in C++, eine Main-Funktion, die aufgerufen wird, wenn die Dll von einem Prozess geladen oder entladen wurde. Damit sieht das Grundgerüst einer Dll folgendermaßen aus:
Zuerst inkludieren wir den Header der WinAPI. Danach sehen wir die Main-Funktion der Dll, nämlich die DllMain( HINSTANCE, DWORD, LPVOID). Der erste Parameter der Dll ist ein Handle von unserer Dll. Sehr nützlich, aber für unser Beispiel uninteressant. Viel interessanter ist der zweite Parameter. Dieser enthält einen Wert, der angibt, wieso die Dll aufgerufen wurde. Der Datentyp DWORD ist btw. als unsigned int definiert, und deshalb können wir ihn auch bei switch-case verwenden ("switchen" ). Dieser Wert ist gleich DLL_PROCESS_ATTACH, wenn die Dll in den Speicher eines Prozesses geladen wurde. Also, wenn zum Beispiel unser Injektor die Dll in den Zielprozess injiziert hat. In diesem Fall wollen wir dann einen Thread erstellen, in dem wir die Werte der "Addys" verändern. Ein Thread läuft unabhängig von den anderen Threads des Zielprogramms, und das garantiert uns, dass der normale Programmablauf nicht unnötig von unserem Hack gestört wird.Quote:
#include <windows.h>
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
switch( fdwReason )
{
case DLL_PROCESS_ATTACH: break;
case DLL_PROCESS_DETACH: break;
case DLL_THREAD_ATTACH: break;
case DLL_THREAD_DETACH: break;
}
return TRUE;
}
Um den Thread zu erstellen verwenden wir CreateThread():
Infos zur Funktion gibt 's in der MSDN. Keine Lust jetzt jeden einzelnen Parameter zu erklären Am wichtigsten von allen Parametern ist für uns der dritte. Dieser gibt unseren Thread an, der gestartet werden soll. Bei uns also "HackThread". Unser Thread wird also gestartet und dann.. dann passiert erst einmal gar nichts. Unmittelbar nachdem die Dll gestartet wurde, wird dieser auch schon wieder aufgrund des return-Befehls beendet. Das wollen wir jetzt ändern. Wir richten eine Endlosschleife ein:Quote:
#include <windows.h>
DWORD WINAPI HackThread( LPVOID lpParam )
{
return 0;
}
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
switch( fdwReason )
{
case DLL_PROCESS_ATTACH: CreateThread( NULL, 0, HackThread, NULL, 0, NULL ); break;
case DLL_PROCESS_DETACH: break;
case DLL_THREAD_ATTACH: break;
case DLL_THREAD_DETACH: break;
}
return TRUE;
}
Eine stink-normale Endlosschleife Ohne dem Sleep in der Endlosschleife würde sich unser Thread 100% der CPU Auslastung ziehen und das würde wiederum auf Kosten des Spielspaßes gehen Darum das Sleep. Gibt bestimmt schönere Lösungen dafür, aber so geht es halt auch. Damit steht unser Grundgerüst der Dll. In der Endlosschleife können wir schließlich auch die eigentlichen Hackfunktionen "neicoden"Quote:
#include <windows.h>
DWORD WINAPI HackThread( LPVOID lpParam )
{
while( TRUE )
{
Sleep( 200 );
}
return 0;
}
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
switch( fdwReason )
{
case DLL_PROCESS_ATTACH: CreateThread( NULL, 0, HackThread, NULL, 0, NULL ); break;
case DLL_PROCESS_DETACH: break;
case DLL_THREAD_ATTACH: break;
case DLL_THREAD_DETACH: break;
}
return TRUE;
}
3. "Hackfunktionen neicoden"
Als erstes musst du dir die "Addys" beschaffen. Diese bekommst du via einen Addylogger. Adressen sind einfache "unsigned int" Variablen (DWORD), also kannst du sie zum Beispiel folgendermaßen deklarieren und definieren:
Wahlweise kannst du auch Makros dafür nehmen (wir halten uns in dem Tutorial bis jetzt eh an reines C):Quote:
DWORD dwSuperjump = 0x00FFFFFF;
DWORD dwSpeed = 0x00ABCDEF;
...
Für was du dich entscheidest, ist jedem selber überlassen. Ich verwende einfache Variablen:Quote:
#define superjump 0x00FFFFFF
#define speed 0x00ABCDEF
...
Damit das hier möglichst einfach bleibt, habe ich die Variablen einfach Global deklariert. Man könnte sie natürlich auch in eine Struktur packen, diese in der DllMain erstellen und als Parameter an den Thread übergeben. Nachdem wir jetzt die Addys haben, müssen wir die Hackfunktion an sich programmieren.. Also muss eine Funktion Superjump() und eine Funktion Speed() her, die wir in unserer Endlosschleife aufrufen:Quote:
#include <windows.h>
DWORD dwSuperjump = 0x00FFFFFF;
DWORD dwSpeed = 0x00ABCDEF;
DWORD WINAPI HackThread( LPVOID lpParam )
{
while( TRUE )
{
Sleep( 200 );
}
return 0;
}
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
switch( fdwReason )
{
case DLL_PROCESS_ATTACH: CreateThread( NULL, 0, HackThread, NULL, 0, NULL ); break;
case DLL_PROCESS_DETACH: break;
case DLL_THREAD_ATTACH: break;
case DLL_THREAD_DETACH: break;
}
return TRUE;
}
Viel wird nichts passieren, weil im Rumpf der Funktionen nicht ganz so viel steht Auch das können wir schnell ändern. In der Superjump-Funktion addieren wir einfach zu dem aktuellen Wert der Addy (die z-Koordinate) zum Beispiel 2000 Einheiten. Dann befindet sich die Spielfigur 2000 Einheiten höher in der Luft:Quote:
#include <windows.h>
DWORD dwSuperjump = 0x00FFFFFF;
DWORD dwSpeed = 0x00ABCDEF;
void Superjump()
{
}
void Speed()
{
}
DWORD WINAPI HackThread( LPVOID lpParam )
{
while( TRUE )
{
Sleep( 150 );
Superjump();
Speed();
}
return 0;
}
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
switch( fdwReason )
{
case DLL_PROCESS_ATTACH: CreateThread( NULL, 0, HackThread, NULL, 0, NULL ); break;
case DLL_PROCESS_DETACH: break;
case DLL_THREAD_ATTACH: break;
case DLL_THREAD_DETACH: break;
}
return TRUE;
}
Aber halt.. Nun würde unsere Spielfigur immer, wenn die Funktion aufgerufen wir (alle 150ms) 2000E höher in die Luft befördert.. Das ist doof. Wir wollen, aber, dass die Figur nur dann in die Luft befördert wird, wenn der Spieler eine bestimmte Taste drückt, zum Beispiel Strg. Dafür gibt es eine nette Funktion, nämlich GetAsyncKeyState(). Ist zwar unter einigen Programmieren verpönt, aber ein KeyboardHook oder sonstiges würde das Tut hier sprengen:Quote:
void Superjump()
{
*(float*)(dwSuperjump) += 2000;
}
Jetzt wird die Spielfigur nur dann um 2000E in die Luft gehoben, wenn die Control-Taste (=Strg) gedrückt wurde. Die Speed-Funktion lasse ich hierbei mal offen, aber ich gebe euch einen kleinen Tipp, wie ihr diese programmieren könnt: Wählt zwei beliebige Tasten aus. Die eine soll den Speed erhöhen, die andere diesen verringern. Prüft, welche Taste gedrückt wurde und erhöht oder senkt dann den aktuellen Wert der Adresse um einen bestimmten Wert. Dürfte nicht allzu schwer sein Natürlich könnt ihr weitere Funktionen ganz einfach hinzufügen, wenn ihr die entsprechenden Addys habt und wisst, wie ihr die Werte der Speicheradressen verändern müsst.Quote:
void Superjump()
{
if( GetAsyncKeyState( VK_CONTROL ) )
*(float*)(dwSuperjump) += 2000;
}
4. Fertiger, vollständiger Code
Gibts hier nicht.. Lest euch das ganze Tut durch, oder lasst es bleiben :-/
5. FAQ
Ich habe mir schon einmal ein paar Fragen überlegt, die eventuell auftauchen werden..:
Q: Welches Programm brauch ich zum Programmieren?
A: Am besten du holst dir eine IDE. Da gibt es zwei gute. Zum einen Code::Blocks und zum anderen MSVC++E
Q: Was für ein Projekt muss ich erstellen?
A: Unter Code::Blocks erstellst du am besten ein "shared DLL" Projekt. Und unter MSVC++E einfach ein neues DLL Projekt
Q: Wie erstelle ich die DLL?
A: Nachdem du deine Dll fertig programmiert hast, musst du bei Code::Blocks nur Strg+F9 drücken. Bei MSVC++E08 musst du nur F7 drücken.
Q: Beim Erstellen der Dll tauchen Fehler auf. Was jetzt?
A: Das kann man pauschal nicht beantworten. Helfen kann man dir nur, wenn du deinen Quellcode zeigst und die Fehler auflistest, die erscheinen.
Q: Wo finde ich die fertige DLL?
A: Unter Code::Blocks im Verzeichnis der Projektdatei und dann im Ordner bin/debug oder bin/release. Bei MSVC++E08 findest du die DLL im Projektmappenverzeichniss und dann im Ordner DEBUG oder RELEASE.
Das war 's Ich hoffe das Tutorial hilft euch ein bisschen beim Programmieren und wenn fragen auftauchen, fragt.
Thx sind immer gern gesehen
auch wenns euch nicht hilft vllt für die mühe 
