Hilfe beim Bitscannen

[Kirajashi]

Hallo liebe Community ,

ich habe ein Problem ,denn ich möchte mit einer Value Adressen suchen und die Ergebnisse ersetzen. Dabei bin ich auf das gestoßen:

 Spoiler

#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"));
    }
}

dies ist aber ein allgemein Scanner ich will aber nur 4 bit Values scannen also brauch ich einen Tiefenscann aber das klappt irgendwie net könnte mir jemand helfen?

#push

#push