Ich wollte fragen ob ihr mir helfen könnt, da ich keine Ahnung habe wie ich das Problem lösen kann. Wieso kann er es nicht konvertieren?

#include <iostream>
#include <Windows.h>
#include <psapi.h>
#include <vector>
#include <iterator>
#include <algorithm>
#include <stdio.h>

using namespace std;

DWORD getProcessIdByExeName(const char* exeName)
{
        DWORD aProcesses[1024];
        DWORD cProcesses;
        DWORD cbNeeded;

        if(!EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded))
                return 0;

        cProcesses = cbNeeded / sizeof(DWORD);

        DWORD processId;

        unsigned int i;
        for(i = 0; i < cProcesses; i++)
        {
                if(aProcesses[i] != 0)
                {
                        processId = aProcesses[i];

                        char processName[MAX_PATH];

                        HANDLE processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);

                        if(processHandle)
                        {
                                HMODULE hMod;

                                if(EnumProcessModules(processHandle, &hMod, sizeof(hMod), &cbNeeded))
                                        GetModuleBaseName(processHandle, hMod, processName, sizeof(processName) / sizeof(char));
                        }

                        CloseHandle(processHandle);

                        if(strcmp(processName, exeName) == 0)
                                return processId;
                }
        }

        return 0;
}

DWORD getMemoryAddressByStringPattern(HANDLE processHandle, const std::string& pattern)
{
    uint8_t* p = NULL;
    MEMORY_BASIC_INFORMATION mbi;
    for(p = NULL; VirtualQueryEx(processHandle, p, &mbi, sizeof(mbi)) == sizeof(mbi); p += mbi.RegionSize)
    {
        vector<char> lpBuff;
        vector<char>::iterator lpPos;
        if(mbi.State == MEM_COMMIT && (mbi.Type == MEM_MAPPED || mbi.Type == MEM_PRIVATE))
        {
            DWORD bytesRead;
            lpBuff.resize(mbi.RegionSize);
            ReadProcessMemory(processHandle, p, &lpBuff[0], mbi.RegionSize, &bytesRead);
            lpBuff.resize(bytesRead);

            DWORD lpAddr = std::string(lpBuff.begin(), lpBuff.end()).find(pattern);
            if(lpAddr != string::npos)
                return lpAddr + (DWORD)p;

        }
    }
    return 0;
}

int main()
{
    DWORD xbProcessId = getProcessIdByExeName("XenoSuite.exe");
    if(xbProcessId == 0)
    {
        cout << ">> XenoSuite not found, please open an instance to patch it!" << endl;
        return 0;
    }
    else
        cout << ">> XenoSuite found, now we open process!" << endl;

    HANDLE xbProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, xbProcessId);
    if(xbProcessHandle == NULL)
    {
        cout << ">> Cannot open process of XenoSuite (open patcher with administrator privilegles)" << endl;
        return 0;
    }
    else
        cout << ">> Patcher got access to the process, now we'll find addresses to patch!" << endl;

    const string patternToFind = "%s%s%s%s";
    const string replacePattern = "AAAAAAAA";

    DWORD xbAddr1 = getMemoryAddressByStringPattern(xbProcessHandle, patternToFind);
    printf(">> Memory address: 0x%lX\n", (DWORD)xbAddr1);
    WriteProcessMemory(xbProcessHandle, (LPVOID)(xbAddr1), replacePattern.c_str(), replacePattern.size() + 1, NULL);

    CloseHandle(xbProcessHandle);
    cout << ">> Now you can login with your fake data!" << endl;
    system("pause");
}

Line 65 Col. 87 [Error] cannot convert 'DWORD* {aka long unsigned int*}' to 'SIZE_T* {aka long long unsigned int*}' for argument '5' to 'WINBOOL ReadProcessMemory(HANDLE, LPCVOID, LPVOID, SIZE_T, SIZE_T*)'

Line 70 Col. 40 [Error] cast from 'uint8_t* {aka unsigned char*}' to 'DWORD {aka long unsigned int}' loses precision [-fpermissive]

In function 'int main()':

Line 102 Col 57 Breaker.cpp [Warning] cast to pointer from integer of different size [-Wint-to-pointer-cast]

Hier muss bytesRead stattdessen als SIZE_T deklariert werden.

return lpAddr + (DWORD)p;

Ich bin mir nicht ganz sicher was das soll; falls du aber tatsächlich genau das da stehen haben willst, schreibe

return lpAddr + reinterpret_cast<DWORD>(p);

Auch dieser Cast wird allerdings fehlschlagen wenn DWORD kleiner ist als ein Zeigertyp auf deiner Maschine. Keine Ahnung was das ganze soll. In einen std::intptr_t passt er per Definition rein. Seit wann aber addiert man zwei Adressen?

Was ich ganz und gar nicht verstehen kann ist warum du getMemoryAddressByStringPattern einen DWORD zurückgeben lässt obwohl es laut Namen ja eine Adresse zurückgibt. DWORD ist auf einigen Maschinen zu klein (da Zeiger dort 64-Bit groß sind). Warum nicht void* (aka LPVOID )?