Łączenie poprzez NamedPipe do DLLInject-ora

const DWORD sleepResult = ::SleepEx(INFINITE, TRUE);

 w `HookCall`.
`sleepResult` wynosi wtedy 192.
Kod main.cpp: http://4programmers.net/Pastebin/3069
Biblioteka którą używam: http://tibiaapi.googlecode.com/svn/trunk/tibiaapi/InjectedDLL/
z niej także mam klase Packet :)

const DWORD sleepResult = ::SleepEx(INFINITE, TRUE);

void InjectDll(HANDLE hProcess, const char * szDllPath)
{
    size_t sLibPathLen = (strlen(szDllPath)+1);
    SIZE_T bytesWritten = 0;

    void * pRmtLibraryPath = VirtualAllocEx(hProcess, NULL, sLibPathLen, MEM_COMMIT, PAGE_READWRITE);
    WriteProcessMemory(hProcess, pRmtLibraryPath, (void*)szDllPath, sLibPathLen, &bytesWritten);
    HMODULE hKernel32 = GetModuleHandle("Kernel32");
    FARPROC pfnLoadLibraryA = GetProcAddress(hKernel32, "LoadLibraryA");
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pfnLoadLibraryA, pRmtLibraryPath, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    VirtualFreeEx(hProcess, pRmtLibraryPath, sizeof(pRmtLibraryPath), MEM_RELEASE);
}

bool Inject(std::string filename, HANDLE hProcess)
{
	size_t filenameLen = strlen(filename.c_str() + 1);
	SIZE_T bytesWritten = 0;

	void * pRmtLibraryPath = VirtualAllocEx(hProcess, 0, filenameLen, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
	WriteProcessMemory(hProcess, pRmtLibraryPath, filename.c_str(), filenameLen, &bytesWritten);

	HANDLE hThread = CreateRemoteThread(hProcess, 0, 0, (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle("Kernel32"), "LoadLibraryA"), pRmtLibraryPath, 0, 0);
	WaitForSingleObject(hThread, INFINITE);

	VirtualFreeEx(hProcess, pRmtLibraryPath, filenameLen, MEM_RELEASE);
	std::cout << bytesWritten << std::endl;
	std::cout << pRmtLibraryPath << std::endl;
	std::cout << hThread << std::endl;
	std::cout << pRmtLibraryPath << std::endl;
	return hThread > 0 && pRmtLibraryPath > 0;
}

Inject("C:\\Users\\TheAifam5\\Documents\\Visual Studio 2013\\Projects\\TiBot\\Debug\\Core.dll", hTibia)

    PROCESSENTRY32 entry;
    entry.dwSize = sizeof(PROCESSENTRY32);

    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);

    if (Process32First(snapshot, &entry) == TRUE)
    {
        while (Process32Next(snapshot, &entry) == TRUE)
        {
            if (stricmp(entry.szExeFile, "target.exe") == 0)
            {  
                HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, entry.th32ProcessID);

                // Tutaj już masz HANDLE procesu

                CloseHandle(hProcess);
            }
        }
    }

    CloseHandle(snapshot);

char szGameExePath [MAX_PATH] = "sciezka_do_exe"; 
char szGamePath[MAX_PATH] = "sciezka_tam_gdzie_exe_egzystuje";
STARTUPINFO siStartupInfo = {0};
PROCESS_INFORMATION piProcessInformation = {0};
siStartupInfo.cb = sizeof(siStartupInfo);

if(!CreateProcess(szGameExePath, "cmd_line", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, szGamePath, &siStartupInfo, &piProcessInformation))
{
    MessageBox(NULL,"Cannot create game process.","Error",MB_ICONERROR);
    return E_FAIL;
}

char szPath[MAX_PATH] = { 0 };
GetModuleFileName(NULL,szPath,MAX_PATH);
for(unsigned int i = strlen(szPath); i > 0; i--)
{
    if (szPath[i] == '\\')
    {
        szPath[i] = '\0';
        break;
    }
}
 
strcat(szPath,"\\core.dll");
 
InjectDll(piProcessInformation.hProcess,szPath);
 
ResumeThread(piProcessInformation.hThread);

HANDLE getHandle(DWORD pID)
{
	return OpenProcess(PROCESS_ALL_ACCESS, FALSE, pID);
}

DWORD TibiaPid;
GetWindowThreadProcessId(FindWindow("TibiaClient", NULL), &TibiaPid);

VirtualFreeEx(hProcess, pRmtLibraryPath, filenameLen, MEM_RELEASE);

#include "stdafx.h"

#include <iostream>
#include <algorithm>

using namespace std;

#define MAXNAMESIZE 255

string buildFilePath(string path, string fileName) {
	string tmp = path + "\\" + fileName, result;
	for (int i = 0; i < tmp.size(); i++) {
		if (tmp[i] == '\\') {
			result += "\\";
			result += "\\";
		}
		else {
			result += tmp[i];
		}
	}
	return tmp;
}

PROCESS_INFORMATION startProcess(string exeFilePath, string params) {

	STARTUPINFOA lpStartupInfo = { sizeof(lpStartupInfo) };
	PROCESS_INFORMATION lpProcessInfo;

	memset(&lpStartupInfo, 0, sizeof(lpStartupInfo));
	memset(&lpProcessInfo, 0, sizeof(lpProcessInfo));

	CreateProcessA(exeFilePath.c_str(),
		(LPSTR) params.c_str(), NULL, NULL,
		NULL, NULL, NULL, NULL,
		&lpStartupInfo,
		&lpProcessInfo);

	return lpProcessInfo;
}

int main() {

	char folderPath[MAX_PATH], dllName[MAXNAMESIZE], exeName[MAXNAMESIZE], params[MAXNAMESIZE];
	GetCurrentDirectoryA(MAX_PATH, folderPath);
	string configFilePath = buildFilePath(folderPath, "loader.cfg");

	GetPrivateProfileStringA("Loader", "dllName", "", dllName, MAXNAMESIZE, configFilePath.c_str());
	GetPrivateProfileStringA("Loader", "exeName", "", exeName, MAXNAMESIZE, configFilePath.c_str());
	GetPrivateProfileStringA("Loader", "params", "", params, MAXNAMESIZE, configFilePath.c_str());

	string exeFilePath = buildFilePath(folderPath, exeName);
	string dllFilePath = buildFilePath(folderPath, dllName);

	if (exeName[0] == '\0') {
		cerr << "Unable to load config file.\n" + configFilePath + '\n';
		system("pause");
		return -1;
	}

	PROCESS_INFORMATION pInfo = startProcess(exeFilePath, params);
	HMODULE hKernel32 = GetModuleHandleA("KERNEL32");
	void* pLibRemote;

	pLibRemote = VirtualAllocEx(pInfo.hProcess, NULL, MAXNAMESIZE, MEM_COMMIT, PAGE_READWRITE);
	WriteProcessMemory(pInfo.hProcess, pLibRemote, (void*) dllFilePath.c_str(), MAXNAMESIZE, NULL);
	CreateRemoteThread(pInfo.hProcess, NULL, 0, (LPTHREAD_START_ROUTINE) GetProcAddress(hKernel32, "LoadLibraryA"), pLibRemote, 0, NULL);

	return 0;
}

[Loader]
exeName=cstrike.exe
dllName=AntiBan.dll
params=-game cstrike

size_t filenameLen = strlen(filename.c_str() +1);