NTSTATUS                        ntStatus;
DWORD                           dwParentPID =   0xffffffff;
HANDLE							h_proc,h;
ULONG                           need;	
BOOL							isDebug=0;
 
 
HMODULE ntdll = GetModuleHandle("ntdll");
NTQSI NtQuerySystemInformation = (NTQSI)GetProcAddress(ntdll, "NtQuerySystemInformation");

ULONG size = 0x1000;
SYSTEM_HANDLE_INFORMATION *handles = (SYSTEM_HANDLE_INFORMATION*)malloc(size);
 
ntStatus = NtQuerySystemInformation(SystemHandleInformation, handles, size, &need);
if(ntStatus!=0)//jesli za maly bufor alokujemy wiekszy
					   {
                        free(handles);
                        size =need;
                        handles = (SYSTEM_HANDLE_INFORMATION*)malloc(size);
		NtQuerySystemInformation(SystemHandleInformation, handles, size, &need);
						}

int i=0;
int j=0;
for (i=0; i<handles->HandleCount; i++)
{
	if(handles->Handles[i].ObjectType==7)//Process
	{
		h=OpenProcess(PROCESS_DUP_HANDLE, FALSE,handles->Handles[i].OwnerPid);
		if(h!=0)
		{
			if (DuplicateHandle(h, (HANDLE)handles->Handles[i].HandleValue, GetCurrentProcess(),&h_proc, 0, FALSE, DUPLICATE_SAME_ACCESS))
			{
				if(GetProcessId(h_proc)==GetCurrentProcessId())
				{
					j=0;
					while(j<handles->HandleCount)
					{
						if(handles->Handles[i].OwnerPid==handles->Handles[j].OwnerPid && handles->Handles[j].ObjectType==0xb)
						{
						isDebug=1;
						}
					j++;
					}
				}
			}
		}
	}
}

if(isDebug==1)
{
printf("Debugger wykryty\n");
}
else
{
printf("Nie wykryto debuggera\n");
}
	if (handles) free(handles);

#include <windows.h>
#include <stdio.h>
#include <string>
#include <Tlhelp32.h>
#include <vector>
#include <Psapi.h>
#include <fstream>
#include "PE_class.h" //moja klasa do obslugi plikow PE(udostepnie razem z reszta kodu)
#pragma comment (lib,"psapi.lib");

HANDLE hProc;//uchwyt procesu
DWORD pid;//ProcessID
DWORD MainImageBase;//ImageBase procesu

int main(int argc, CHAR* argv[])
{
printf("\n\nIAT Hook detector v. 1.0 by Grzonu\n\n");
 
if(argc!=2)//sprawdzamy czy podano parametr jesli nie to wychodzimy
{
	printf("usage: %s <pid>\n\n",argv[0]);
	return 0;
}
pid=atoi(argv[1]);//pobieramy PID
DWORD IB=0;
DWORD ImgSize=0;
FindImageBase(pid,&IB,&ImgSize);//Znajdujemy ImageBase i Size procesu
printf("ImageBase: 0x%.8x\nImageSize: 0x%.8x\n\n",IB,ImgSize);
 
hProc=OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION,FALSE,pid);//otwieramy go
if(hProc==0)//jesli sie nie udalo to wychodzimy
{
printf("can`t open process\n");
return 0;
}
char* buf=LoadMod(IB);//ladujemy plik
MainImageBase=IB;
PE_file PE((HMODULE)buf);
IAT(&PE);//szukamy hookow
free(buf);//zwalniamy bufor zaalokowany w funkcji LoadMod
 
 
	return 0;
}

DWORD FindImageBase(DWORD pid,DWORD* IB,DWORD* ImgSize)//funkcja przyjmuje processID, wskazniki na bufory na dane
{
PROCESSENTRY32 lppe32;
char buf[260];
	memset(buf,0,260);
    HANDLE hSnapshot;
   hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//robimy snapshot listy procesow
    lppe32.dwSize = sizeof(PROCESSENTRY32);
 
    Process32First(hSnapshot, &lppe32);
	    do
        {
		if(lppe32.th32ProcessID==pid)//szukamy naszego procesu
		{
		strcpy(buf,lppe32.szExeFile);
		break;
		}
 
		}
        while(Process32Next(hSnapshot, &lppe32));
        CloseHandle(hSnapshot);
if(buf[0]==0)//jesli nie udalo sie znalesc zwracamy 0;
{
return 0;
}
 
MODULEENTRY32 mod32;
std::string x;
 
   hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);//robimy snapshot listy modolow znalezionego procesu
   mod32.dwSize = sizeof(MODULEENTRY32);
 
    Module32First(hSnapshot, &mod32);
	     do
        {
		x=mod32.szExePath;
		if(x.find(buf)!=0xFFFFFFFF)//sprawdzamy czy to główna czesc programu
		{//jesli tak to wypelniamy odpowiednie zmienne
			*IB=(DWORD)mod32.modBaseAddr;
			*ImgSize=mod32.modBaseSize;
		}
 
 
		}
        while(Module32Next(hSnapshot, &mod32));
        CloseHandle(hSnapshot);
return 1;
}

char* LoadMod(DWORD IB)
{
char ProcName[260];
GetModuleFileNameEx(hProc,(HMODULE)IB,ProcName,260);//pobieramy pelna sciezke do binarki modulu
std::ifstream f(ProcName,std::ios::binary);//otwieramy plik
char* buf;
f.seekg(0,std::ios::end);
int size=f.tellg();
f.seekg(0,std::ios::beg);
buf=(char*)malloc(size);//alokujemy bufor(pamietajmy go pozniej zwolnic)
memset(buf,0,size);
int i=0;
char ch;
while(i<size)
{
f.get(ch);//wczytujemy
buf[i]=ch;
i++;
}
f.close();
return buf;//zwracamy bufor
}

void IAT(PE_file* PE)
{
HINSTANCE hInstance =(HINSTANCE)PE->buf;
PIMAGE_DOS_HEADER pdosheader = (PIMAGE_DOS_HEADER)hInstance;//pobieramy naglowki
PIMAGE_NT_HEADERS pntheaders = (PIMAGE_NT_HEADERS)((DWORD)hInstance + pdosheader->e_lfanew);//i dalej...
PIMAGE_SECTION_HEADER psectionheader = (PIMAGE_SECTION_HEADER)(pntheaders + 1);
PIMAGE_IMPORT_DESCRIPTOR pimportdescriptor = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hInstance + PE->RVA_to_RAW(pntheaders->OptionalHeader.DataDirectory[1].VirtualAddress));//znajdujemy adres IAT w naglowku PE ale jako ze szukamy w pliku a nie w procesie pamietamy o zamianie adresu z RVA na RAW
PIMAGE_THUNK_DATA pthunkdatain, pthunkdataout;
PIMAGE_IMPORT_BY_NAME pimportbyname;
DWORD dw;
PCHAR ptr;
DWORD IB;
char* buf;
DWORD ImgSize;
PIMAGE_OPTIONAL_HEADER32 opt;
DWORD address;
DWORD IAT_adr;
DWORD read;
 
int i=0;
while ( pimportdescriptor->TimeDateStamp != 0 ||pimportdescriptor->Name != 0)//pobieramy tak dlugo importy az sie skoncza :)
{
	ptr = (PCHAR)((DWORD)hInstance+ PE->RVA_to_RAW((DWORD)pimportdescriptor->Name));//Nazwa biblioteki Dll
	i=0;
	IB=FindModule(ptr);//Funkcja szukajaca ImageBase na podstawie nazwy biblioteki(omowie dalej)
	buf=LoadMod(IB);//opisana wczesniej funkcja ladujaca kod 
	PE_file PE2((HMODULE)buf);//ladujemy kod do klasy
	opt=PE2.GetOptionalHeader();//Pobieramy odpowiedni header
	ImgSize=opt->SizeOfImage;//pobieramy potrzebne nam pole z tego headera czyli ImageSize
	free(buf);//zwalniamy bufor
 
		pthunkdataout = (PIMAGE_THUNK_DATA)((DWORD)hInstance + PE->RVA_to_RAW((DWORD)pimportdescriptor->FirstThunk));//pobieramy adres gdzie zaczynaja sie adresy w IAT
		if (pimportdescriptor->Characteristics == 0)
		{
			pthunkdatain = pthunkdataout;//pobieramy adres struktury z ktorej pobierzemy nazwy funkcji
		}
		else 
		{
			pthunkdatain = (PIMAGE_THUNK_DATA)((DWORD)hInstance +PE->RVA_to_RAW((DWORD)pimportdescriptor->Characteristics));//to samo ;)
		}
 
		while ( pthunkdatain->u1.AddressOfData != NULL)//dopuki sa jeszcze jakies funkcje
		{
			if ((DWORD)pthunkdatain->u1.Ordinal & IMAGE_ORDINAL_FLAG)//jesli Ordinal
			{
				LPSTR x=MAKEINTRESOURCE(LOWORD(pthunkdatain->u1.Ordinal));//Ordinal
				address=MainImageBase+(pimportdescriptor->FirstThunk+(i*4));//adres bufora na adres funkcji
				ReadProcessMemory(hProc,(LPCVOID)address,&IAT_adr,4,&read);//Odczytujemy adres funkcji znajdujacej sie pod adresem pobranym wyzej
 
				if(IAT_adr<IB || IAT_adr>(IB+ImgSize))//sprawdzamy czy adres miesci sie w granicach swojego modułu
				{//jesli nie to sprawdzamy w jakim module znajduje sie funkcja
				DWORD HookBase=FindHookModule(IAT_adr);//pobieramy ImageBase modułu w ktorym znajduje sie ta funkcja.(Ta funkcje omowie pozniej)
				char modname[260];
				if(HookBase==0)//jesli nie ma takiego modulu oznacza ze jest to poprostu zaalokowana pamiec np. przez VirtualAllocEx
				{
				strcpy(modname,"Virtual Memory");
				}
				else//jesli jest to pobieramy sciezke do tego modułu
				{
				GetModuleFileNameEx(hProc,(HMODULE)HookBase,modname,260);
				}
printf("Ord: %x(%s) --- Hooked by %s(0x%.8x)\n",x,ptr,modname,IAT_adr);//printfujemy wynik :)
				}
 
 
			} else {
				pimportbyname = (PIMAGE_IMPORT_BY_NAME)(PE->RVA_to_RAW((DWORD)pthunkdatain->u1.AddressOfData) + (DWORD)hInstance);
					address=MainImageBase+(pimportdescriptor->FirstThunk+(i*4));//tutaj to samo co wyzej 
				ReadProcessMemory(hProc,(LPCVOID)address,&IAT_adr,4,&read);
 
				if(IAT_adr<IB || IAT_adr>(IB+ImgSize))
				{
				DWORD HookBase=FindHookModule(IAT_adr);
				char modname[260];
				if(HookBase==0)
				{
				strcpy(modname,"Virtual Memory");
				}
				else
				{
				GetModuleFileNameEx(hProc,(HMODULE)HookBase,modname,260);
				}
				printf("%s(%s) --- Hooked by %s(0x%.8x)\n",(char*)pimportbyname->Name,ptr,modname,IAT_adr);
				}
 
			}
 
        i++;//nastepna funkcja
			pthunkdatain++;
			pthunkdataout++;
		}
 
	pimportdescriptor++;//nastepna DLL`ka
 
}
}

void str_tolower(char* str)//funkcja zamieniajaca string na male litery
{
int i=0;
int size=strlen(str);
 
while(i<size)
{
str[i]=tolower(str[i]);
i++;
}
}
 
DWORD FindModule(char* mod_name)
{
MODULEENTRY32 mod32;
std::string x;
   HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);//o tym juz mowilem
   mod32.dwSize = sizeof(MODULEENTRY32);
   str_tolower(mod_name);
 
    Module32First(hSnapshot, &mod32);
	     do
        {
		str_tolower(mod32.szExePath);
		x=mod32.szExePath;
 
		if(x.find(mod_name)!=0xFFFFFFFF)//jesli to szukany modul to zwracamy jego ImageBase
		{
			return (DWORD)mod32.modBaseAddr;
		}
 
 
		}
        while(Module32Next(hSnapshot, &mod32));
        CloseHandle(hSnapshot);
		return 0;
}
 
DWORD FindHookModule(DWORD Address)//funkcja szukajaca ImageBase modulu w ktorym znajduje sie funkcja
{
MODULEENTRY32 mod32;
   HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
   mod32.dwSize = sizeof(MODULEENTRY32);
 
    Module32First(hSnapshot, &mod32);
	     do
        {
		if(Address>=(DWORD)mod32.modBaseAddr && Address<=(DWORD)(mod32.modBaseAddr+mod32.modBaseSize))//jesli adres znajduje sie w przedziale <ImageBase ; ImageBase+ImageSize> to zwracamy jego ImageBase
		{
return (DWORD)mod32.modBaseAddr;
		}
 
		}
        while(Module32Next(hSnapshot, &mod32));
        CloseHandle(hSnapshot);
		return 0;
}