Andere Programme "manipulieren"

moin


Hier ein ganz simples Beispiel.

Dies ist mein "Opfer" Programm bei dem die variable xxx vom "Täter" Programm um eins erhöht werde soll, hab es nochmal Kommentiert:
Code: 
#include <windows.h>
#include <iostream>

int main()
{
	int xxx = 5;          // Zu ändernde Variable

	SetConsoleTitle("cracking opfer");          // Umsicher zu gehen das das Programm auch                                                                     // wirklich den Fenstertitel hat nach dem wir                                                                    // suchen

	std::cout<< xxx << "    " << &xxx << std::endl;   // Zeile spricht für sich
	Sleep(10000);						// Während diesen 10 sek wird das Täter Programm gestartet
	std::cout<< xxx << "    " << &xxx << std::endl;	// Hier kann man den geänderten Wert 									// von xxx sehen
	Sleep(10000);

	return 0;
}


Nun muss das Programm erstmal gestartet werden um die Adresse zu sehen, sie ist beim starten immer gleich, außer man ändert die Position der exe auf der Festplatte, sprich anderer Ordner.

Nun das Täter Programm:
Code: 
#include <windows.h>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	HWND hwnd;
	DWORD ID;
	DWORD rw=0;
	HANDLE handle;

	int puffer = 0;
	unsigned adresse = 0x0012FEE4;                  // Die Adresse bekommt man durch einen                                                                             // Probelauf des opfers, wir dbei euch                                                                             // anders sein

	hwnd = FindWindow(NULL, "cracking opfer");          // Fenster suchen
	if(!hwnd)                                                               // Wenn nciht gefunden gleich raus
	{
		std::cout<<"Fehler! Konnte Opfer nicht finden";
		Sleep(1000);
		return 0;
	}

	GetWindowThreadProcessId(hwnd, &ID);                 // Nun brauchen wir die ProcessID
                                                                                     // des opfers für die nächste                                                                                            // Funktion
	handle = OpenProcess(PROCESS_ALL_ACCESS, false, ID);       // Hier holen wir uns
                                                                                                        // das handle des                                                                                                            // opfers

	ReadProcessMemory(handle, (LPCVOID)adresse, &puffer, sizeof(puffer), &rw);
	std::cout<< puffer;                                                            // Test ob es wirklich der                                                                                                 // gesucht Wert xxx ist

	WriteProcessMemory(handle, (LPVOID)adresse, &(puffer+=1), sizeof(int), &rw); 
                                   // Und nun den Wert überschreiben

	Sleep(2000);
	CloseHandle(handle);                 // Extrem wichtig!
	return 0;
}


Hoffe es ist verständlich!


mfg
umbrasaxum
 
moin


Hab es mir nochmal durch den Kopf gehen lassen.
Und zwar frag ich mich immernoch wie Trainer den Wert im Speicher finden.
Denn sie wissen ja nicht unterwelcher Adresse er zu finden ist, da die Adresse einer Variable ja auf jeden Sytem verschieden ist.

Das würde dann doch auf die Methode den gesamten Speicher zu durchsuchen hinweisen. Wei es geht den Wert zu finden und zu überprüfen ob er wirklich zu dem Programm gehört ist mir bekannt, allerdings was ist wenn der Wert in 2 Variablen vorkommt?!


mfg
umbrasaxum
 
Zuletzt bearbeitet:
Hi,

Das mit der gleichen Adresse dürfte kein Problem sein. Man disassembliert den Code der Exe und findet
raus(vom Stack 'n Abbild machen nehm ich mal) wo entsprechende Variable liegt.
Da der Stack vor dem Start reserviert und bereitgestellt wird, sich also nicht mehr ändert, merkt man sich die
relative Addresse zum Anfang.
Im Trainer sucht man nun den Anfang der Stack addresse und voila, man hat die Variable!
 
moin


Also,
ich hab mich mal ein bsichen mit nem Debugger vertraut gemacht, dort hab ich gesehen von welcher bis zu welcher Adresse der Stack für mein Opferprogramm geht.
In ihm fand ich auch meinen gescuhten werd unter der Adresse die ich schon wusste hatte. Und ich weiss auch die Entfernung des Wertes von Anfang zum Stack.

Wie kann ich jetzt weiter vorgehen?
Ich kann zwar über die Anfangsadresse im Stack + die Entfernung der Variable zum Anfang des Stacks auch auf den Wert zu greifen, aber die Anfangsadresse des reservierten Bereichs im Stack ist doch auch je nach System verschieden.


mfg
umbrasaxum
 
Zuletzt bearbeitet:
Ich sag dir nur nochmal, ohne Assembler kannst du keine Rückschlüsse ziehen.
Lern Assembler und innerhalb von 3 Tagen wird dir das ganze Problem sowas von klar sein.....

Aber nochmal:
Globale Variablen usw werden immer Programmintern addressiert, also relativ zum ersten Byte der Exe (glaub ich jdf), sie erhalten einen Platz im Datensegment. So gilt die gleiche Addresse für jeden Programmaufruf.
Lokale Variablen, von denen also zur Kompilationszeit nicht sicher ist, wie oft, wie lange, usw sie gebraucht werden, können erst zur Laufzeit reserviert werden.
Das macht man, indem man einfach ebp sichert, ebp auf esp setzt, esp dekrementiert, je nachdem, wieviele Variablen man haben will und nun hat man einen ungenutzten Bereich, über den man per Offset (und der Offset ist natürlich auch bei jedem Programmstart gleich....) von ebp zugreifen kann, hier sind die Variablen.
 
moin


Na gut hast mich schon fast überzeugt.
Wollte mich schon immer mal mit Assembler anfangen fand aber nie Zeit, vielleiht isses jetzt soweit.

Kennst du vielleicht auch noch gute Seiten bzw. Tutorials?


mfg
umbrasaxum
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück