ich habe ein Problem ,denn ich möchte mit einer Value Adressen suchen und die Ergebnisse ersetzen. Dabei bin ich auf das gestoßen:
Code:
#include <Windows.h>
#include <Tchar.h>
#include <vector>
// Struktur für Fensterelement
struct Window
{
std::basic_string<::TCHAR> title;
::HWND handle;
};
// Variablen
std::vector<Window> windows;
// Callback fr EnumWindows. Wird aufgerufen fr jedes Fenster
BOOL CALLBACK EnumWindowsProc (::HWND hwnd, ::LPARAM l_param);
// Listet Fenster auf und regelt Auswahl eines Fensters
::HWND select_window (void);
// Werte aus dem Adresspuffer ersetzen
void repleace_values (::HANDLE process, std::vector<::DWORD>& adresses);
// Durchsucht Arbeitsspeicher nach gesuchtem Wert u. speichert alle Adressen mit diesem Wert
void scan_memory (::HANDLE process, ::DWORD start, ::DWORD end, unsigned int value, std::vector<::DWORD>& adresses);
// Dursucht die gespeicherten Adressen wiederholt
void rescan_memory (::HANDLE process, std::vector<::DWORD>& adresses);
// ///////////////////////////////////////////////////////////////////////////
// Programmeinsprungspunkt.
int _tmain (int argc, ::TCHAR* argv[])
{
// Ausgabe der Überschrift
::_tprintf (_T ("MemScan v1.3 by TcH\n\n"));
// Fenster auswählen
::HWND hwnd = select_window ();
// Scann starten...
::DWORD process_ID;
// Zum Fenster zugehörigen Prozess ermitteln
::DWORD thread_ID = ::GetWindowThreadProcessId (hwnd, &process_ID);
// In den Prozess einklinken
::HANDLE process = ::OpenProcess (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF, FALSE, process_ID);
::MEMORY_BASIC_INFORMATION mbi;
// Dient zur Ermittlung der Arbeitsspeichergröße, sowie Anfang und Ende
::SYSTEM_INFO sys_info;
::GetSystemInfo (&sys_info);
// Alle Adressen welche den gesuchten Wert werden hier gespeichert
std::vector<::DWORD> adresses;
unsigned int value = 0;
// Keine Adresswerte im Array, Scan starten
::_tprintf (_T ("Nach welchem Wert soll gescannt werden: "));
::_tscanf (_T ("%d"), &value);
::_tprintf (_T ("starte Scanvorgang nach %d\n"), value);
// Anfangsadresse für Durchsuchung festlegen
::DWORD adress = (::DWORD) sys_info.lpMinimumApplicationAddress;
do
{
// Arbeitsspeicherbereiche ermitteln
::VirtualQueryEx (process,
reinterpret_cast<void*>(adress),
&mbi,
sizeof (::MEMORY_BASIC_INFORMATION));
// Anfang & Ende des aktuellen Bereiches ermitteln
::DWORD start = (::DWORD) mbi.BaseAddress;
::DWORD end = (::DWORD) mbi.BaseAddress + mbi.RegionSize;
// Bereich einem "tiefen" Scan unterziehen
if (mbi.State == MEM_COMMIT)
scan_memory (process, start, end, value, adresses);
adress += mbi.RegionSize;
// Durchsuche solange nach Bereichen, bis Ende im RAM
} while (adress < (::DWORD) sys_info.lpMaximumApplicationAddress);
// Ausgabe der Anzahl der Übereinstimmungen
::_tprintf (_T ("%d Uebereinstimmungen gefunden\n"), adresses.size ());
// nochmaliger Scan oder Ersetzen kann nur stattfinden, wenn Adressen gefunden wurden
if (adresses.size () != 0)
{
while (true)
{
// Ausgabe des Menus
unsigned int choice;
::_tprintf (_T ("Gefilterte Adressen Scannen (1)\n")
_T ("Werte aus vorhandenem Scan ersetzten (2)\n")
_T ("Beenden (3)\n")
_T ("Auswahl: "));
::_tscanf (_T ("%u"), &choice);
// Vorhandene Adressen nochmals durchsuchen
if (choice == 1)
rescan_memory (process, adresses);
// Werte der Adressen ersetzen
else if (choice == 2)
repleace_values (process, adresses);
// Beenden
else if (choice == 3)
{
// Aufräumen - Handle wieder freigeben
::CloseHandle (process);
return 0;
}
// Ungültige Eingabe
else
::_tprintf (_T ("Fehler - ungueltige Eingabe\n"));
}
}
// Aufräumen - Handle wieder freigeben
::CloseHandle (process);
// Schließen des Fensters verhindern
::TCHAR a;
::_tscanf (_T ("%c"), &a);
return 0;
}
// ///////////////////////////////////////////////////////////////////////////
// Callback fr EnumWindows. Wird aufgerufen fr jedes Fenster
BOOL CALLBACK EnumWindowsProc (::HWND hwnd, ::LPARAM lParam)
{
// Kein Fenster
if (!::IsWindow (hwnd))
return (TRUE);
// nur sichtbare Fenster auflisten
if (!::IsWindowVisible (hwnd))
return (TRUE);
// Fensterberschrift ermitteln
::TCHAR title[256];
if (!::GetWindowText (hwnd, title, sizeof (title) / sizeof (title[0])))
return (TRUE);
// neues Fenster hinzufgen...
Window wnd;
wnd.handle = hwnd;
wnd.title = title;
windows.push_back (wnd);
return (TRUE);
}
// ///////////////////////////////////////////////////////////////////////////
// Listet Fenster auf und regelt Auswahl eines Fensters
::HWND select_window (void)
{
// Alle Fenster auflisten
::EnumWindows (EnumWindowsProc, 0);
// Liste aller Fenster ausgeben.
std::vector<Window>::iterator window_it = windows.begin ();
for (int i = 0; window_it != windows.end (); ++ window_it, ++ i)
::_tprintf (_T ("%d : %s\n"), i, window_it->title.c_str ());
// Auswahl des Fensters & Prüfung, ob Auswahl im Gültigskeitsbereich liegt
unsigned int choice = 0;
do
{
::_tprintf (_T ("\nWelches Fenster soll gescannt werden: "));
::_tscanf (_T ("%d"), &choice);
} while (choice < 0 || choice >= windows.size ());
// ausgewählte Fensterhandle zurckgeben
return (windows[choice].handle);
}
// ///////////////////////////////////////////////////////////////////////////
// Werte aus dem Adresspuffer ersetzen
void repleace_values (::HANDLE process, std::vector<::DWORD>& adresses)
{
// Abfragem durch welchen Wert ersetzt werden soll
unsigned int write_buffer = 0;
::_tprintf (_T ("Mit welchem Wert soll ersetzt werden: "));
::_tscanf (_T ("%d"), &write_buffer);
// Adresse fr Adresse den Wert ersetzen
std::vector<::DWORD>::iterator i = adresses.begin ();
for (i; i != adresses.end (); ++ i)
{
if (::WriteProcessMemory (process, reinterpret_cast<void*>(*i), &write_buffer, sizeof (unsigned int), 0))
::_tprintf (_T ("Erfolg - Wert wurde ueberschrieben\n"));
else
::_tprintf (_T ("Fehler - Wert konnte nicht ueberschrieben werden\n"));
}
}
// ///////////////////////////////////////////////////////////////////////////
// Durchsucht Arbeitsspeicher nach gesuchtem Wert u. speichert alle Adressen mit diesem Wert
void scan_memory (::HANDLE process, ::DWORD start, ::DWORD end, unsigned int value, std::vector<::DWORD>& adresses)
{
for (::DWORD i = start; i < end; ++ i)
{
unsigned int read_buffer = 0;
// Wert auslesen
::ReadProcessMemory (process, reinterpret_cast<void*>(i), &read_buffer, sizeof (unsigned int), 0);
// Wert stimmt mit gesuchten Wert berein
if (read_buffer == value)
{
::_tprintf (_T ("Wert (%d) an der Stelle 0x%x gefunden\n"), value, i);
adresses.push_back (i);
}
}
}
// ///////////////////////////////////////////////////////////////////////////
// Durchsucht die gespeicherten Adressen
void rescan_memory (::HANDLE process, std::vector<::DWORD>& adresses)
{
if (adresses.size () > 0)
{
unsigned int value = 0;
::_tprintf (_T ("Nach welchem Wert soll gescannt werden: "));
::_tscanf (_T ("%d"), &value);
::_tprintf (_T ("starte Scanvorgang nach %d\n"), value);
// temporäres Array, indas die neuen Adressen kopiert werden
std::vector<::DWORD> temp;
std::vector<::DWORD>::iterator i = adresses.begin();
for (i; i != adresses.end (); ++ i)
{
unsigned int read_buffer = 0;
// Wert auslesen
::ReadProcessMemory (process, reinterpret_cast<void*>(*i), &read_buffer, sizeof (unsigned int), 0);
// Wenn gesuchter Wert vorhanden, Adresse speichern
if (read_buffer == value)
{
::_tprintf (_T ("Wert (%d) an der Stelle 0x%x gefunden\n"), value, *i);
temp.push_back (*i);
}
}
// Altes Array löschen
adresses.clear ();
// Altes Array durch neues ersetzen
adresses = temp;
::_tprintf (_T ("%d Uebereinstimmungen gefunden\n"), adresses.size());
}
else
{
::_tprintf (_T ("Keine Werte vorhanden\n"));
}
}
#push
#push
