D3D Hook WriteMem Problem

Page 1 of 4 1 23 Last »
01/28/2011 19:12 germanhacker#1
Hallo Epvp,

Hab ein problem bei der WriteMem Funktion, aus dem D3D Hooking Tutorial von purple.d1amond.

die Funktion sieht folgendermaßen aus:

Code:
void WriteMem(DWORD dwOffset, DWORD dwValue, int len)
{
unsigned long Protection;
VirtualProtect((void*)dwOffset, 1, PAGE_READWRITE, &Protection);
memcpy((void*)dwOffset, (const void*)dwValue, len);
VirtualProtect((void*)dwOffset, 1, Protection, 0);
}
Also hab die Adresse (0x14052F8C), die Offset(0x30) und die Value(1). Doch dort muss ich anscheinend keine Adresse einsetzten. Wie soll das ganze denn funktionieren o.O

wie das z.b. :

Code:
    unsigned long address2;
    unsigned long address1 = 0x14052F8C; 
    unsigned long offset = 0x30;
    int value = 1;
    ReadProcessMemory(hProc, (LPCVOID)address1, &address2, sizeof(long), &numBytesRead); 
    address2 = address2+offset ; 
    WriteProcessMemory(ProcessHandle,(LPVOID)address2,&value,sizeof(int),NULL);
??????
_________________________

Und was hat es mit dem "int len" auf sich ?
Welcher Wert soll dort zugewiesen werden ? :/

Ich hoffe, ihr könnt mir weiter helfen ...
01/29/2011 09:23 xNopex#2
Deine Frage könntest du dir selber beantworten, wenn du dir die Dokumentation zur memcpy() - Funktion betrachten würdest.

DWORD dwOffset ist die Speicheradresse, in der du den Wert kopieren willst, den du als zweiten Parameter angegeben hast. Der dritte Parameter gibt dabei an, wie viele Elemente kopiert werden sollen. Folgendes kleines Beispiel soll das erklären.

Value-Address-Range:
0x001: 50
0x002: 103
0x003: 56

Ziel-Adresse:
0x004: 0
0x005: 0
0x006: 0

Beispiel1: Rufst du dann WriteMem() folgendermaßen auf:
WriteMem( 0x001, 0x004, 2 );

enthält die Ziel-Adresse folgenden Inhalt:
0x004: 50
0x005: 103
0x006: 0

Beispiel2:
WriteMem( 0x001, 0x004, 3 );

führt zu:
0x004: 50
0x005: 103
0x006: 56

Beispiel3:
WriteMem( 0x001, 0x005, 1 );

führt zu:
0x004: 0
0x005: 50
0x006: 0
01/29/2011 12:00 germanhacker#3
Ich hab das ganze jetzt so probiert:

Code:
void WriteMem(char* window, LPCVOID address, int value)
{
	HWND hWnd = FindWindow(0, window);
	DWORD proc_id; 
	GetWindowThreadProcessId(hWnd, &proc_id); 
	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, proc_id); 
	BYTE newdata[]={value}; 
	DWORD newdatasize = sizeof(newdata); 
	WriteProcessMemory(hProcess, (LPVOID)address, &newdata, newdatasize, 0);
	CloseHandle(hProcess); 
}
Code:
if (godmode == true)
	{
		DWORD offset = 0x14;
		DWORD Base = (DWORD) GetModuleHandleA("server.dll"); 
        DWORD Address = (Base + 0x0037492C) + offset; 
		WriteMem("Left4Dead2", (LPCVOID)Address, 1 );
		DrawFont ( 10, 70, txtGreen, "            godmode" );
	}
	else
	{
		DWORD offset = 0x14;
		DWORD Base = (DWORD) GetModuleHandleA("server.dll"); 
        DWORD Address = (Base + 0x0037492C) + offset; 
		WriteMem("Left4Dead2", (LPCVOID)Address, 0 );
	    DrawFont ( 10, 70, txtRed, "            godmode" );
	}
Doch es funktioniert immer noch nicht ganz so wie ich will :D

Das wird wohl noch dauern bis ich des mir zurecht gebastelt habe :D


So wie du das oben erklärt hast heißt das also

WirteMem(Adresse1, Value von Adresse1 auf Adresse2 schreiben, wv Adressen beschrieben werden sollen)

d.h. es werden die values von einer adresse auf eine andere kopiert. Was ich aber möchte ist, dass die Value von einer Adresse (server.dll+0x0037492C) mit dem Offset(0x14) mit 1 überschrieben werden soll.
01/29/2011 12:30 mydoom#4
Ich gehe davon aus, dass es sich dabei um Code handelt, der via Dll in einen Prozess injiziert wird. Dann brauchst du OpenProcess(), FindWindow() und Co. nicht.
01/29/2011 12:44 xNopex#5
Quote:
Was ich aber möchte ist, dass die Value von einer Adresse (server.dll+0x0037492C) mit dem Offset(0x14) mit 1 überschrieben werden soll.
Heute 09:23
Dann addiere auf die Adresse das Offset und übergebe die Summe an die Funktion :-/
Dir fehlt es an Grundlagenkenntnisse. Und falls du per Injektion arbeitest, dann nimm dir den Beitrag meines Vorredners zu Herzen und arbeite mit Zeigern. Um einiges schneller.
01/29/2011 13:45 germanhacker#6
Quote:
Originally Posted by xNopex View Post
Dann addiere auf die Adresse das Offset und übergebe die Summe an die Funktion :-/
Code:
		DWORD offset = 0x14;
		DWORD Base = (DWORD) GetModuleHandleA("server.dll"); 
		DWORD Address = (Base + 0x0037492C) + offset; 
		WriteMem("Left4Dead2", (LPCVOID)Address, 1 );
Das hab ich gemacht. Lies sich auch Kompilieren, aber hat zuletzt ingame nicht funktioniert :D
01/29/2011 14:20 mydoom#7
[Only registered and activated users can see links. Click Here To Register...]
01/29/2011 14:24 MrSm!th#8
Quote:
BYTE newdata[]={value};
Au au au, das sollte eigentlich einen Compiler-Fehler geben, du willst du eine Variable vom Typ int (4Bytes groß) in eine Variable vom Typ Byte (1 Byte groß) verschieben, das kannst du natürlich nicht einfach machen.
Ich frage mich sowieso, was das mit dem BYTE Array soll.

Gib es doch direkt so an:

Code:
WriteProcessMemory(hProcess, (LPVOID)address, &value, sizeof(int), 0);
01/29/2011 15:04 germanhacker#9
Quote:
Originally Posted by MrSm!th View Post
Au au au, das sollte eigentlich einen Compiler-Fehler geben, du willst du eine Variable vom Typ int (4Bytes groß) in eine Variable vom Typ Byte (1 Byte groß) verschieben, das kannst du natürlich nicht einfach machen.
Ich frage mich sowieso, was das mit dem BYTE Array soll.

Gib es doch direkt so an:

Code:
WriteProcessMemory(hProcess, (LPVOID)address, &value, sizeof(int), 0);
Also ich habs jetzt so gemacht...

Code:
		HWND hWnd = FindWindow(0, "Left4Dead2");
		DWORD proccess_ID;
		GetWindowThreadProcessId(hWnd, &proccess_ID);
		HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, proccess_ID);
		DWORD offset = 0x14;
		DWORD Base = (DWORD) GetModuleHandleA("Server.dll") + 0x0037492C;
		DWORD Address = Base + offset; 
		int value = 1;
		WriteProcessMemory(hProcess, (LPVOID)Address, &value, sizeof(int), 0);
Jetzt gibts keinen Absturz mehr, funktioniert aber trotzdem noch nicht. Wie würde das ganze ohne OpenProcess(), FindWindow() und CO aussehen ?
01/29/2011 15:45 MrSm!th#10
Ist das eine Dll oder eine externe Anwendung?
01/29/2011 19:25 germanhacker#11
Das ist eine Dll, d.h. Findwindow und so brauch ich nicht. Aber weiß leider nicht wies sonst aussehn soll x)
01/29/2011 20:11 MrSm!th#12
memcpy
01/29/2011 20:15 germanhacker#13
meinste das hier ?

Code:
void WriteMem(DWORD dwOffset, DWORD dwValue, int len)
{
unsigned long Protection;
VirtualProtect((void*)dwOffset, 1, PAGE_READWRITE, &Protection);
memcpy((void*)dwOffset, (const void*)dwValue, len);
VirtualProtect((void*)dwOffset, 1, Protection, 0);
}
Wenn ja erklär mal, wurd mir schon erklärt, verstehs aber trotzdem nit :S


DWORD offset = 0x14;
DWORD Base = (DWORD) GetModuleHandleA("server.dll") + 0x0037492C;
DWORD Address = Base + offset;

also "Address" ist jetzt meine Adresse.

int value = 0;

"value" meine value :D

ja und wie soll das aussehn. so vllt ?

WriteMem(Address, 1, "und kp was hier hin soll^^")
01/29/2011 20:53 MrSm!th#14
Die Funktion ist vollkommen bescheuert, kein Wunder, dass das in nem Crash endet:

Du brauchst übrigens generell keine Funktionen, wenn du in den Speicher des Prozesses schreiben willst, in dem sich die DLL schon befindet, da nutzt man einfach Pointer.
Nur kann es auch mal sein, dass eben die Code Section, das ist der Teil im Programm, in dem die ausführbaren Daten sind und damit auch die EndScene, welche ja für einen D3D Hook gehookt wird, keinen Schreibzugriff erlaubt und eigentlich nur deshalb sind da die Aufrufe von VirtualProtect.

Um übrigens auf deine Frage im ersten Post zu kommen: Die Namen der Parameter sind doch scheiß egal, mit dwOffset ist in dem Fall die Adresse gemeint!

Hier mal ne bessere Version der Funktion:
Code:
void WriteMem(void *Adresse, void *Quelle, int len)
{
unsigned long Protection;
VirtualProtect(Adresse, len, PAGE_READWRITE, &Protection);   //hier stand vorher statt len 1, das ist natürlich Quatsch, da nicht nur das erste Byte auf schreibzugriff gestellt werden muss!
memcpy(Adresse, Quelle, len);
VirtualProtect(Adresse, len, Protection, 0); //hier genauso
}
Und, falls du unbedingt eine Funktion haben möchtest, die den Speicher auf nen gewissen Wert setzt:

Code:
void WriteMem(void *Adresse, int Wert, int len)
{
unsigned long Protection;
VirtualProtect(Adresse, len, PAGE_READWRITE, &Protection);
memset(Adresse, Wert, len);
VirtualProtect(Adresse, len, Protection, 0);
}

Ein kleiner Tipp: du solltest die Sprache vielleicht erstmal richtig lernen.
01/29/2011 21:32 germanhacker#15
Quote:
Originally Posted by MrSm!th View Post
Die Funktion ist vollkommen bescheuert, kein Wunder, dass das in nem Crash endet:

Du brauchst übrigens generell keine Funktionen, wenn du in den Speicher des Prozesses schreiben willst, in dem sich die DLL schon befindet, da nutzt man einfach Pointer.
Nur kann es auch mal sein, dass eben die Code Section, das ist der Teil im Programm, in dem die ausführbaren Daten sind und damit auch die EndScene, welche ja für einen D3D Hook gehookt wird, keinen Schreibzugriff erlaubt und eigentlich nur deshalb sind da die Aufrufe von VirtualProtect.

Um übrigens auf deine Frage im ersten Post zu kommen: Die Namen der Parameter sind doch scheiß egal, mit dwOffset ist in dem Fall die Adresse gemeint!

Hier mal ne bessere Version der Funktion:
Code:
void WriteMem(void *Adresse, void *Quelle, int len)
{
unsigned long Protection;
VirtualProtect(Adresse, len, PAGE_READWRITE, &Protection);   //hier stand vorher statt len 1, das ist natürlich Quatsch, da nicht nur das erste Byte auf schreibzugriff gestellt werden muss!
memcpy(Adresse, Quelle, len);
VirtualProtect(Adresse, len, Protection, 0); //hier genauso
}
Und, falls du unbedingt eine Funktion haben möchtest, die den Speicher auf nen gewissen Wert setzt:

Code:
void WriteMem(void *Adresse, int Wert, int len)
{
unsigned long Protection;
VirtualProtect(Adresse, len, PAGE_READWRITE, &Protection);
memset(Adresse, Wert, len);
VirtualProtect(Adresse, len, Protection, 0);
}

Ein kleiner Tipp: du solltest die Sprache vielleicht erstmal richtig lernen.
Danke, für deine Hilfe, dennoch funktioniert das ganze noch nicht so, wie ich es möchte.

Ich hab die obrige Funktion einwenig umgeändert. Da meine Adressen in DWORD geschrieben sind.

Code:
void WriteMem(DWORD dwAdresse, int Wert, int len)
{
unsigned long Protection;
VirtualProtect((void*)dwAdresse, len, PAGE_READWRITE, &Protection);
memset((void*)dwAdresse, Wert, len);
VirtualProtect((void*)dwAdresse, len, Protection, 0);
}
Jetzt wollte ich das ganze anwenden also ...

Code:
	if (godmode == true)
	{
		DWORD offset = 0x14;
		DWORD Base = (DWORD) GetModuleHandleA("server.dll") + 0x0037492C;
		DWORD Address = Base + offset; 
		WriteMem(Address, 1, 0);
        //DrawFont ( 10, 70, txtGreen, "            godmode" );
	}
	else
	{
		DWORD offset = 0x14;
		DWORD Base = (DWORD) GetModuleHandleA("server.dll") + 0x0037492C;
		DWORD Address = Base + offset; 
		WriteMem(Address, 0, 0);
	    //DrawFont ( 10, 70, txtRed, "            godmode" );
	}
	if(GetAsyncKeyState(VK_NUMPAD1) &1) // Öffnen mit NUMPAD1
	{
		godmode = !godmode;
	}
Bei "len" hab ich erstmal 0 eingesetzt, da bei 1 oder anderen Werten das Spiel abkrazt.
Für dwAdresse habe ich meine fertige Adresse verwendet und bei "Wert" meinen Wert "1" eingetragen.
Wenn ich dann ingame über numpad1 das ganze einschalten möchte, bekomme ich trotzdem noch schaden. Dann hab ich über cheat engine nachgeschaut, ob die Adresse sich auf 1 gesetzt hat. Diese war allerdings immer noch auf 0...


Quote:
Ein kleiner Tipp: du solltest die Sprache vielleicht erstmal richtig lernen.
Du hast recht ich hab nach den wichtigsten basics schon aufgehört, aber es war so interessant mit D3D Hooking anzufangen. :D

Aber ich wusste auch nicht, dass es so schwer ist eine Value einer bestimmten Adresse zu ändern. :S
Page 1 of 4 1 23 Last »