DMA in C++ umgehen

[Pat Garrett]

Guten Tag!

Ich möchte gerne wissen, wie man Dynamic Memory Allocation innerhalb eines in C++ geschriebenen Trainers ignorieren kann.
Also angenommen ich habe herausgefunden, dass in dem Programm spiel.exe bei
0000432100 ein "DEC EAX" ausgeführt wird, wie kann ich das, innerhalb einer C++ Anwendung NOPen oder etwas sinngemäßes tun?
Ich hatte zuerst die Idee, die Exe zuerst zu ändern und dann einen Vergleich mit der originalen zu machen um herauszufinden, welcher Code an welcher Stelle geändert werden muss, diesen dann in meinen C++ Code einbauen und beim Programmstart an die richtige Stelle im Spiel schreiben.

Meint ihr, das funktioniert? Ich frage erst, weil ich noch nicht genau weiß, wie ich das mit dem Vergleich machen soll und wie ich die richtigen Stellen in der Datei herauskrieg. Für den Vergleich könntem an im Notfall ja ein extra Programm schreiben. :O

Grüzzi

[Adroxxx]

huh?
Etwas Sinnfrei was du da schreibst. Was hat DEC EAX mit DMA zutun? Und wieso willst du DMA ignorieren? Wohl eher umgehen oO


Du berechnest den Pointer. Wie du den Pointer herausbekommst, weißt du ja wohl. Wenn nicht CE Tutorial machen. Du holst dir den Wert der Adresse und addierst den Offset dazu.

Außerdem kannst du auch in C & C++ inline asm benutzten

PHP Code:

_asm{
        mov eax,ebx
        blablub
} 


[12354]

Am einfachsten ist natürlich den Pointer zu finden.

wenn du diese Anweisung z.B jetzt NOPen willst musst du halt die entsprechenden Bytes an die Adresse schreiben.
Bei DEC EAX sollte das dann eben 1(weil dec eax afaik auch 1 byte hat) 0x90 Byte sein.

[Pat Garrett]

Du berechnest den Pointer. Wie du den Pointer herausbekommst, weißt du ja wohl. Wenn nicht CE Tutorial machen. Du holst dir den Wert der Adresse und addierst den Offset dazu.

Nein, das wusst ich noch nicht, sonst hätte ich wohl nicht gefragt.
Bin auch erst jetzt auf Idee gekommen mal bei EPVP nach diversen Tutorials zu suchen, war bisher nur auf andern Seiten, da gab's nicht eine Erklärung wie man den Pointer herausfindet. Da ging es immer nur bis zur Adresse.

Was hat DEC EAX mit DMA zutun? Und wieso willst du DMA ignorieren? Wohl eher umgehen oO

Nichts. Wollte ein Beispiel geben, aber bei genauerem überlegen hat es ja tatsächlich nichts damit zutun. Tut mir leid, war wohl etwas verwirrt gestern.

Thread kann im Grunde geschloßen werden, weiß ja nun dass ich nach dem Pointer suchen muss. Darauf hätte ich auch irgendwie selber kommen können, aber naja, was soll's.

[Pat Garrett]

Tut mir leid wegen des Doppelposts, aber sonst hätte in den Thread keiner mehr reingeguckt. Hätte auch einen neuen aufmachen können, spart euch also Vorwürfe!

Ich habe jetzt, in meinem Beispiel, den Pointer herausgefunden und er hat die Adresse "00007170" und das Offset ist 30. Das heißt, eig. müsste ich doch in C jetzt nur

unsigned adress = 0x0071A0
...
WriteProcessMemory(ProcessHandle,(LPVOID)adress,&value,sizeof(int),NULL);

schreiben, oder? Das funktioniert allerdings nicht ganz. Wenn ich den Wert von 000071A0 auslese, kommt etwas komisches dabei heraus. Es ist auch nicht die Adresse des Wertes auf den der Pointer zeigt. Das verwirrt mich.

Sagt mir bitte nicht ich soll bei Google Defeat DMA eingeben, es gibt nämlich tausend kluge Menschen, die das vorher vorgeschlagen haben und ich hab die letzten 2 Stunden damit verbracht Google zu quälen, aber bei Leuten die das gleiche Problem haben kommen entweder nur so kluge Antworten wie "stfu and google defeat DMA" oder irgendwelche Anleitungen wie ich das ganze dann mit Hilfe von CE durch Disassemblen löse, aber das will ich ja nicht. Oder funktioniert es nur so?

Danke schonmal im Voraus.

[Adroxxx]

Sorry, aber Google Defeat DMA. Weil ich ganz stark vermute dass du ganz einfach nicht verstanden wie DMA funktioniert.

Natürlich kannst du DMA mit C / C++ umgehen, aber dafür musst du erstmal verstehen wie es funktioniert.

Schau dir erstmal das Cheat Engine Tutorial an, da werden Pointer auch behandelt. Und du musst ansich erstmal den Pointer mittels CE, Debugger + Pointer Scanner herausfinden.

Wenn du das hast, fügst du in CE den Pointer hinzu.Dann hast du schonmal die Adresse und Offsets.

So nun in C / C++. Was schreibst du denn an diese Stelle rein? weil du schreibst ja irgendwas an die adresse 0x0071A0 .

Also wenn du dma umgehen willst, kannst du entweder immer wieder den pointer berechnen in c++ und dann den wert auslesen oder du überschreibst die stelle. Du kannst natürlich auch mit inline asm code caves nutzen, wobei das etwas schwieriger ist.

btw: es hilft immer deinen ganzen code zu sehen damit man dir besser helfen kann.

[Pat Garrett]

Ehm ja, hab den Pointer ja bereits über CE herausgefunden. Das ist die Adresse die ich im obigen Code-Beispiel gegeben hab. (Da ist schon das Offset dazu addiert)

Also ich habe das jetzt so verstanden, dass die Pointer-Adresse bei DMA gleich bleibt, nur die Adresse der Werte auf die sie zeigt eben nicht. Ich werd mir aber gleich mal bei Wiki den Artikel zu DMA durchlesen.

Naja, hier kurz der Code, vll. verstehst du dann meine Denkweise:

(Der Plan: Prozess öffnen, Wert über STDIN einlesen, Wert mit WriteProcessMemory schreiben)

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

using namespace std;

int main() 
{
  HWND hwnd;
  hwnd = FindWindow(0,"Solitär");
  DWORD Id;
  HANDLE ProcessHandle;
  int value;
  int value2;
  unsigned adress = 0x0071A0;

  if(!hwnd)
  {
    cout << "Solitär nicht gefunden!" << endl;
  }
  else 
  {
	cout << "Solitär gefunden!" << endl;
    cout << "Fensterhandle: " << hwnd << endl;   
    GetWindowThreadProcessId(hwnd,&Id); 
    cout << Id << endl;
    ProcessHandle = OpenProcess(PROCESS_VM_WRITE |PROCESS_VM_OPERATION ,false,Id);	
	cout << "ProcessHandle: " << ProcessHandle << endl;
    cout << "How much points to add? ";
	cin >> value;
	fflush(stdin);	
	ReadProcessMemory(ProcessHandle,(LPVOID)adress,&value2,sizeof(int),NULL);
	cout << "Value 2: " << value2 << endl;
	WriteProcessMemory(ProcessHandle,(LPVOID)adress,&value,sizeof(int),NULL); 
	cout << "Value 1 geschrieben." << endl;
	cin.get();
  }
}

Ich weiß, dass Solitair keine dynamischen Speicher benutzt, aber das sollte doch eig. eher unwichtig sein, oder? Wollte es nur mit irgend einem Programm ausprobieren, ob es funktioniert anstatt auf eine normalen Wert direkt auf einen Pointer zuzugreifen, der auf den Wert zeigt.

Pointer braucht man wenn man einen Trainer basteln möchte.
da aber sich die Adresse manchmal ändert und ihr sie nicht immer Suchen müsst. Benutz man Pointers die führen immer auf die neue Adresse.

(Aus dem CE Tutorial von vulcanraven)

edit: Okay, dass das Lesen nicht geht ist mir inzwischen klar, da bei OpenProcess nur Schreibrechte gegeben wurden. Aber trotzdem funktioniert auch das schreiben nicht.

[Bot_interesierter]

Dein Programm muss sich Debug Rechte holen damit es ReadProcessMemory und WriteProcessMemory für fremde Prozesse verwenden kann, du kannst dazu System.Diagnostic.Process.EnterDebugMode() aus dem .NET framework verwenden oder aber mit AdjustTokenPrivileges() dir selbst die entsprechenden Rechte geben.


Du solltest die Debug Rechte erlangen bevor du dir das ProcessHandle holst.

[Pat Garrett]

Okay, aber das ist trotzdem nich das Problem. Es funktioniert ja auch wenn ich einfach die Adresse der Variable direkt angeb, aber wenn ich den Pointer benutz eben nicht.

[Bot_interesierter]

Weil du das Pointer Konzept nicht verstanden hast ^^

[Pat Garrett]

Dann klär mich bitte auf, was ich an Pointern angeblich nicht verstanden habe. Ist ein Pointer etwa keine Variable die auf eine andere Variable "zeigt" (auf sie verweist) und deren Adresse als Wert enthält?

[Bot_interesierter]

Zeig mal den Code her bei dem das mit dem Pointer nicht klappt, ich hoffe dir ist klar das du zwei ReadProcessMemory machen musst um den Wert auf den der Pointer Zeigt zu lesen.

[Pat Garrett]

Nein.

Der Code, den ich vorhin geposted hab ist eben das mit den Pointern. Ich dachte mir schon, dass das mit dem was ich da geschrieben hab alleine nicht klappt, aber ich hab eben auch keine Ahnung wie es sonst klappen könnte, deshalb, bitte, klär mich auf.

[schlurmann]

Ein Zeiger zeigt auf eine Adresse im Speicher. Mehr gibt es dazu eigentlich nicht zu sagen. Da ein Zeiger natürlich auch Informationen enthält (eben eine Adresse) verbraucht er auch Speicher und dieser hat auch eine Adresse (wichtig bei Zeigern auf Zeiger).

int main()
{
    int* p = NULL; // Zeiger, Stack, 4 Byte
    int  x = 1337; // Variable, Stack, 4 Byte
    p = &x; // Zuweisung, p hält Adresse von x
    cout<<*p; // Wert an der Adresse auf die p zeigt
    cout<<p; // Adresse auf die p zeigt ( == &x)
    cout<<&p; // Adresse des Zeigers im Speicher
}

[Pat Garrett]

Aaalso...

int value;
unsigned adress1=0x0071A0;
unsigned adress2;
ReadProcessMemory(ProcessHandle,(LPVOID)adress1,&adress2,sizeof(int),NULL);
ReadProcessMemory(ProcessHandle,(LPVOID)adress2,&value,sizeof(int),NULL);

So in etwa? :S
Tut mir leid, ich bin wohl zu blöd selber drauf zu kommen.