Внедряемся в память чужого процесса

#include <windows.h>
#include <tlhelp32.h>
#include <winbase.h>
#pragma comment(linker,"/BASE:0x13140000") // сдвигаем базу нашего процесса
 
 
// ------- объявляем функции --------
 
DWORD GetProcessID(char*);
BOOL Inject(HANDLE,DWORD(WINAPI* func)(LPVOID));
DWORD WINAPI func(LPVOID);
 
//-------- главная функция ---------
 
int  main(HINSTANCE,HINSTANCE,LPTSTR,int)
    {
        if(!Inject(OpenProcess(PROCESS_ALL_ACCESS,false,GetProcessID("calc.exe")),&func)){ return false;}
    return true;
 
    }
 
//-------- функция, которая будет выполняться в чужом процессе -------
 
DWORD WINAPI func(LPVOID)
    {
    LoadLibrary((LPCSTR)"kernel32.dll");
    LoadLibrary((LPCSTR)"user32.dll");
    MessageBox(0,(LPCSTR)"Hello from addres area of calc",(LPCSTR)"title",0);
    return true;
    }
 
//-------- поиск процесса ---------
 
DWORD GetProcessID(char* lpNameProcess) // в параметре - имя процесса для внедрения
    {
    HANDLE snap;
    PROCESSENTRY32 pentry32;
    snap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
        if(snap==INVALID_HANDLE_VALUE) return 0;
        pentry32.dwSize=sizeof(PROCESSENTRY32);
            if(!Process32First(snap,&pentry32)) {CloseHandle(snap);return 0;}
                do
                {
                    if(!lstrcmpi((LPCSTR)lpNameProcess,&pentry32.szExeFile[0]))
                    {
                    CloseHandle(snap);
                    return pentry32.th32ProcessID;
                    }
                }
        while(Process32Next(snap,&pentry32));
        CloseHandle(snap);
    return 0; 
    }
 
//-------- функция внедрения в чужой процесс -------------------
 
    BOOL Inject(HANDLE hProc,DWORD(WINAPI* func)(LPVOID))
{
    DWORD id;
    DWORD ByteOfWriten;
    HMODULE hModule = GetModuleHandle(NULL);
    DWORD size=((PIMAGE_OPTIONAL_HEADER)((LPVOID)((BYTE*)(hModule)+((PIMAGE_DOS_HEADER)(hModule))->e_lfanew+sizeof(DWORD)+sizeof(IMAGE_FILE_HEADER))))->SizeOfImage;
        char* hNewModule = (char*)VirtualAllocEx(hProc,hModule,size,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
            if(hNewModule==NULL) return false;
            WriteProcessMemory(hProc,hNewModule,hModule,size,&ByteOfWriten);
                if(ByteOfWriten!=size){return false;}
                HANDLE hThread=CreateRemoteThread(hProc,NULL,0,func,(LPVOID)hNewModule,0,&id);
                    if(hThread==0) return false;
return true;
}

#include <iostream>* 
#include <windows.h>
#include <iomanip>
using namespace std;
 
bool bDataCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
        for(;*szMask;++szMask,++pData,++bMask)
                if(*szMask=='x' && *pData!=*bMask )
                        return false;
        return (*szMask) == NULL;
}
 
DWORD dwFindPattern(DWORD dwAddress,DWORD dwLen, BYTE *bMask, char * szMask) {
        for(DWORD i=0;i<dwLen;i++)
                if( bDataCompare( (BYTE*)( dwAddress+i ),bMask,szMask) )
                        return (DWORD)(dwAddress+i);
        return (-1);
}
 
int main ()
{ ::setlocale(LC_ALL,"");
   
        DWORD MyAddress = NULL; // Адрес сигнатуры
        
        HWND hWnd = FindWindowA(0,"Timerocketxby");
 
        if (hWnd == 0) {
                cerr << "Запустите Timerocketxby" << endl;
        }else {
                    cerr << "процесс найден" << endl;
                        DWORD pId;
                        GetWindowThreadProcessId(hWnd, &pId);
                        HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, 0, pId);
 
                        if (!hProc){
                        cerr << "не могу открыть процесс" << endl;
                        }else{
                                                                        
                                        bool findOffsets();{
                
                                                DWORD start = 0x0151D426; //начало сканирования
                                                DWORD dwLen = 0x0151D626 - start;   //  Длина модуля сканирования
                                                cerr << "Длина модуля = " <<dwLen << endl;
                                                
                                                MyAddress = dwFindPattern(start, dwLen, (BYTE*)"\x89\xBE\x0A\x02\x00\x00\xE9\x87\x00\x00\x00\x83\xE8\x00\x74\x12", "xxxxxxxxxxxxxxxx"); //ищем адрес по маске
                                                cout << "Значение MyAddress = " << MyAddress << endl;
                                                 if (MyAddress == -1){
                                                        clog << "Искомой сигнатуры нет" << endl;
                                                        
                                                }else{
                                                        cerr << "Адрес найден" << endl;
                                                }
 
                                        }
 
                                
                                CloseHandle(hProc);
                        }
                }
                
        system("pause");
 
        return 0;
}

if(DoRtlAdjustPrivilege()){
 
    while (lpMem < si.lpMaximumApplicationAddress) {
 
        VirtualQueryEx(phandle, lpMem, &mbi, sizeof(MEMORY_BASIC_INFORMATION));   // Узнаем о текущем регионе памяти.
    
        if(PAGE_EXECUTE_READWRITE){         // Если он доступен для записи                                               
 
                PBYTE pBuffer = new BYTE[mbi.RegionSize];                                // Буфер под считываемый регион
 
                ReadProcessMemory(phandle, mbi.BaseAddress, pBuffer, mbi.RegionSize, 0); // Считываю весь найденный регион  
                
                int k = 0;
                                for (int  i = 0; i < mbi.RegionSize && k<SIZE; i++) { 
 
                                    if (pBuffer[i] == Prob[k])
                                    {
                                            if ( k == SIZE-1){
                                                cerr << "Маска найдена " <<endl; 
                                                MyAddress = (LPVOID)((DWORD)mbi.BaseAddress + (DWORD)i-SIZE+1);
                                                cerr << "Найденный адрес = " << hex << MyAddress << endl;
                                                k = 0;      j++;        
 
                                                break;
                                            }
                                             k++; //i++;
                                    }
 
                                    else {  k = 0; //i++;
                                    }
                                }
                                if (j > 0){ break;  }
            free(pBuffer); 
            //  } 
        lpMem = (LPVOID)((DWORD)mbi.BaseAddress + (DWORD)mbi.RegionSize);
        }
    }
}