Anti Game hacking 프로그램의 구현.


작성자 : Dual5651 (dual@null2root.org) in Null@Root

소개

 이번 글에서는 그 시점에서 알게된 Anti GH 프로그램이 갖추어야할 기능이 무엇
이며, 그 기능의 구현에 필요한 코드와 그 기능의 존재하는 약점등에 대해서 다루어
보고자 합니다. 이 글의 구성은 다음과 같습니다.

1. Anti Game Hacking 프로그램에 필요한 기능들.
2. Anti Game Hacking Program 구현에 필요한 코드들.


1. Anti Game Hacking 프로그램에 필요한 기능들.

 Anti GH 프로그램은 어떤 기능들이 필요할까요?

1. (Binary /Data File) Packing / Encrypting

2. GH Program Detecting

3. AutoPlay Blocking

4. Message Hooking Blocking

5. Unauthorized memory access Blocking

6. Debugging Blocking

7. SpeedHack Blocking

8. Integrity Checking

9. System descriptor restoring

 첫번째로 필요한 기능으로써, 실행파일 및 데이터 파일의 압축 또는 암호화
들 수 있습니다. 이 부분에 대해선 다른 의견을 가지고 있는 분들도 많은거 같습니다.
이런 분들의 주장에 근거로는 패킹 및 인크라입팅에 의존하면, 프로그램 자체의
Secure Coding이 약해지고, 대부분 이러한 패킹 및 인크라입팅은 범용적으로
사용되는 상용프로그램일 가능성이 높음으로, 풀릴(뚫릴 - 그만큼 공략하는 사람도
많기 때문에) 가능성도 높으며, 이로 인한 결과는 상상이상으로 치명적일 것이기
떄문입니다. 그럼에도 불구하고, 최근 실행파일의 패킹을 하지 않은 프로그램을
더 찾기 힘들만큼 많이 사용되어 지고 있으며, 또 어느정도 첫번째  방어선으로써
기대되어 지는 기능을 하여주고 있습니다.

그렇다면 게임의 데이터 파일들에 대한 패킹 및 인크라입팅은 왜 필요한 것일까요?
최근 Anti GH 프로그램의 도입으로 Memory Hacking이 힘들어지자, 최근 공격자들은
게임의 데이터파일을 조작하는 방식의(고전적이라면 고전적인 방법의) 해킹을 다시
시도하기 시작하였습니다. 실제 2007년도 국내의 어떤 게임에서는 해당 방식에 의한
GH이 이루어지기도 하였습니다.

 두번째로 필요한 기능으로써, 게임해킹 프로그램의 감지를 들 수 있습니다.
최근 가장 많이 쓰이는 GH방식으로 Memory Hacking이 있습니다.
이러한 MH(Memory Hacking)은 공격자 입장에서 Generic Game Hacking Tool
(ex: CheatEngine,Tsearch and so on...)로 우선 대상 Game에 대한 분석을 하고
그 후 그 게임만을 대상으로 하는 게임 트레이너가 나오게 됩니다.
즉, 범용 게임 해킹툴의 완전한 차단은 특정 게임 대상 트레이너의 제작을 막는 방법
이기도 합니다. 물런 이는 반드시 그러한 것은 아니며, 거의 근접한 %의 역활을 할 수
있습니다. 감지하는 방법으로써는 첫번째로 패턴 매칭이 있습니다.
패턴 매칭이란 특정한 GH 프로그램에서 발견되는 문자열이나, 코드배열등을
Anti GH프로그램에서 모든 프로세스에서 찾아 보고, 있다면 GH 프로그램으로
간주하는 방식입니다. 두번째로 Finding Named Object기법이 있습니다.
예를들어,
 hFileMap = CreateFileMapping((HANDLE)INVALID_HANDLE_VALUE,NULL,
  PAGE_READWRITE,0,dwSize,"DUALMEM");

의 경우 처럼, GH 프로그램이 사용되는 시스템 전역에 공유되는 파일맵의 이름이라던지,
GH 프로그램의 창이름, 클레스 이름, 프로세스 이름, 로드되는 드라이버 이름, 뮤텍스,
레지스트리 키등등의 요소등을 검사해보는 방법입니다. 이러한 요소를 확인하는 방법은
sysinternals의 Process Explorer를 이용하여 해당 GH프로그램이 가지고 있는 핸들등
을 통해서 확인하여 볼 수 있습니다.


 세번째로 필요한 기능으로써, 자동 플레이 차단을 들 수 있습니다.
최근 메모리 해킹보다 더 큰 문제로 대두되고 있는 것이, 자동플레이 문제 입니다.
과거에는 '작업장'이라는 이름으로, 빈곤한 국가에서 아동 및 청소년의 노동력을
착취하여 지속적인 게임 플레이를 통한 아이템 획득하여, 이를 판매, 이익을 얻는
방식의 범죄가 존재한 반면, 최근에는 이러한 노동력 착취가 아닌, 자동으로
게임을 플레이 해주는 프로그램 및 하드웨어를 이용하여 자동적으로 플레이 하여,
아이템을 획득, 이를 판매하여, 이익을 얻는 방식으로 변모하였습니다.

최근 단순한 메크로 방식의 자동 플레이 보다 진화된 형태의 두가지 자동 플레이
방식이 등장하였는데,  첫번쨰로 게임 클라이언트와 서버와의 통신 프로토콜등을
분석하여 게임 클라이언트와 똑같은 기능을 하는 클라이언트를 만들어(UI는 없는)
해당 클라이언트에 AI를 붙이어 자동적으로 사냥하게 하는 것입니다.
이 방식으로 접근하게 될 경우, Anti GH프로그램은 올바른 역활을 할 수 없게 되며,
서버측의 입장에서도 올바른 클라이언트와 공격자에 의해 만들어진 오토 플레이용
클라이언트를 분간하는 것도 현재로선, 명확한 방법은 존재하지 않습니다.
또 이 방식의 공격은 2차적인 피해를 낮기도 하는데, 이런 오토 플레이로써 기능을
하다가, 후에는 '프리 서버'라는 이름으로 판매되어, 실제 게임의 플레이어 수를
줄이고, 저작권을 침해하는 범죄가 2차적으로 이어집니다.
두번쨰로 하드웨어 방식의 오토 플레이 입니다. 이는 실제 사용자에 의해 이뤄지는
올바른 입력과 분간하는 것이 힘듭니다. 이를 분간하기 위한 방법으로써, 행동
패턴 기반의 감지방법이나, WMI등을 이용, 하드웨어의 ID를 확인하여 오토 플레이용
하드웨어를 감지하는 방법등이 사용되어 지고 있습니다.

 네번쨰로 필요한 기능으로써, 메시지 후킹 차단을 들 수 있습니다.
공격자는 메시지 후킹을 사용자의 키입력등을 가로 챌 목적으로 사용합니다.
게임의 경우, 키 입력을 가로채어, 아이디와 패스워드등을 알아낸 후,
접속하여 아이템등을 빼가는 등의 범죄에 사용되어 집니다.
현재 존재하는 대부분의 Anti GH 프로그램등은 대부분 기본적으로 유저레벨단의
메시지 후킹을 차단하고 있으며, 이로 인해 최근에는 키로거들도 유저레벨에서
메시지 후킹을 하는 방식이 아닌, 커널레벨에서 필터 드라이버등으로써 키로거
기능을 수행하고 있습니다.

 다섯번쨰로 필요한 기능으로써, 허용되지 않은 메모리 접근차단을 들 수 있습니다.
매시각각 생겨나는 GH 프로그램에 대응한다는 것은 참 힘든일이며,
Private한 GH 프로그램에 대해선 대응하기가 힘들다는 이유에서 이 방법은 Anti GH에
큰 도움이 되는 방법입니다. 게임 및 보호 프로그램의 프로세스에 허용되지 않은
접근을 차단함으로써, Private한 GH 프로그램도 견제할 수 있게 됩니다.
이를 수행하기 위해서 유저레벨에서는 각 프로세스에 Dll을 삽입하여, API를 후킹하게
하고, 커널레벨에서는 NtOpenProcess(), NtRead/WriteVirtualMemory()등의 함수를
후킹하여 프로세스로의 접근을 차단합니다. 그러나 최근 GH 프로그램도 이런 후킹에
대응하기 위하여, 기존의 API를 호출하는 것이 아닌, Pesudo 코드를 사용함으로써,
위에서 말했던 API들로는 충분치 않아, 최근에는 KeAttachProcess() 같은 프로세스
메모리 전환 계열 함수도 후킹대상에 포함되고 있습니다.

 여섯번쨰로 필요한 기능으로써, 디버깅 차단을 들 수 있습니다.
게임을 디버거에게 내준다는 것은, 알몸을 보여주는 것과 같습니다.
그럼으로, 디버거는 어떻게든 차단해야 하는 존재입니다. 디버거를 감지하는
방법으로는 우선 앞에서 말했던 요소들을 혼합함으로써 이루어 질 수 있습니다.
디버거들이 사용하는 API(DebugActiveProcess)같은 프로세스들을 후킹하는
것도 중요하며, 유명한 범용 디버거가 있는지 정기적으로 확인하여, 이들의
창이름, 클레스 이름, 프로세스 이름등 Anti GH프로그램의 두번쨰 기능에서
거론한 요소들로 감지할 수 있으며, 디버거 역시 유저레벨 디버거의 경우
다섯번째 기능으로 차단되며, 커널레벨 디버거의 경우는 반드시 두번쨰 기능을
이용하여 차단되어져야 합니다. 유명한 커널레벨 디버거로써는 SoftIce와
syser가 있으며, 필수적인 차단리스트 입니다.

 일곱번째로 필요한 기능으로써, 스피드 핵 차단을 들 수 있습니다.
공격자 입장에서 생각하기에는 단순히 스피드 핵을 차단하는 이유가 공정성 때문
이라고 생각할지 모르겠지만, 실제적으로 스피드 핵을 차단하는 이유는 공정성
그 이상의 이유가 있습니다. 스피드 핵을 사용할 경우 특정한 기능을 수행하는
루틴의 반복시간에 Gap이 짧아 짐으로써, (Delay시간의 감소) 서버로 유입되는
패킷량 역시 증가되게 됩니다. 만약, 스피드를 정상적인 속도에 10배로 하였다면,
서버로 보내는 패킷량도 10배에 근접하게 된다고 보시면 됩니다. 즉 반드시
차단해야 합니다. 스피드 핵은 두종류가 있는데, 첫번쨰는 GetTickCount() ,
timeGetTime(),QueryPerformanceCounter()등의 시간관련 함수를 후킹하는
방식이 있습니다. 이는 프로세스로의 메모리 접근을 차단함으로써 해결할 수
있는 문제입니다. (사실 메모리 접근을 하지 않고 후킹을 할 수도 있습니다.
-CopyOnWrite 관련) 두번쨰는 시스템의 PIT자체를 줄임으로써, 시스템 시간
전체를 빠르게 돌아가게 하는 방법이 있습니다. 이는 시스템 내부적으론 감지가
힘들게 되며, 서버와의 연동체크를 통해서 감지하는 방법이 있습니다.

 여덟번째로 필요한 기능으로써, 무결성 검사를 들 수 있습니다.
무결성 검사를 하는 이유로는, 만약 게임프로세스 및 보호 프로세스가 패킹이
해제되거나, 변조된 상태에서 실행된다면, Anti GH은 정상적인 기능을 수행할 수
없게 됩니다. 무결성 검사는 보호 프로세스가 시작될떄에, 게임 파일 및 보호
프로세스 자체 파일들에 대하여 우선적으로 이루어져야 하며,
실행 중에도 코드섹션에 대하여 정기적으로 이루어져야 합니다.
이렇게 검사를 수행할 경우, 만약 다섯번쨰 기능이 우회되여, 게임의 메모리나,
게임의 데이터 파일등이 수정되었다고 하여도, 이를 감지할 수 있습니다.

 아홉번째로 필요한 기능으로써, 시스템 디스크립터 복구를 들 수 있습니다.
게임이 시작하기전 시스템의 중요한 디스크립터들(ex: ssdt, idt, and so on)을
복구 하여둠으로써, 꺠끗한 환경에서 게임이 돌아가도록 해야 합니다.
이 작업이 수행되어 지지 않으면, Anti GH 프로그램은 올바른 작동을 할 수 없을
수도 있습니다.


2. Anti Game Hacking Program 구현에 필요한 코드들.

 앞에서는 안티 게임 해킹 프로그램이 갖추어야할 기능들에 대해서 알아 보았습니다.
이번에는 이러한 기능들을 구현하기 위해서 알아야 할 점 및 코드에 대해서 다루어
보도록 하겠습니다.

첫번째로 실행파일 및 데이터 파일의 압축 또는 암호화의 경우 코드의 길이가
짧은편이 아님으로, 관련 링크로 대신하도록 하겠습니다.
http://dual5651.hacktizen.com/tt/entry/Make-your-owner-PE-Protector-Part-1-Your-
first-EXE-Protector

참고 적으로 최근의 게임 EXE 패킹은 더미다 패커가 인기를 끌고 있고,
드라이버의 경우 Code Virtualizer가 인기를 끌고 있습니다.

두번쨰로 게임해킹 프로그램의 감지의 코드는 다음과 같습니다.

프로세스 메모리 영역의 패턴 검사 :

BOOL PatternSearchFromAllProcesses()
{
 char StringDataBase[][30] = {"CheatEngine",
          "AutoPlay",
          "GameHack",
          "Memory Search",
          "TSearch"};
 char szProcess[MAX_PATH] = {0,};
 DWORD ProcessesID[1024];
 char WarningString[MAX_PATH] = "게임 해킹 프로그램 발견 되었습니다.\n게임이 종료 됩니다.\n";
 MEMORY_BASIC_INFORMATION struct_mbi;
 SYSTEM_INFO struct_si;
 HMODULE hMod;
 DWORD dbNeeded,dbNeeded2;
 HANDLE hProcess;
 LPVOID newbuf;
 LPVOID p;
    ULONG ret;
 int cnt;

 GetSystemInfo(&struct_si); //Getting Information to get max,min address

 printf("StartAdr : 0x%x, EndAdr : 0x%x\n",
   struct_si.lpMinimumApplicationAddress,
   struct_si.lpMaximumApplicationAddress);

 for(cnt=0; ;cnt++)    //Counting Pattern
  if(!StringDataBase[cnt][0])
   break;
 
 EnumProcesses(ProcessesID,sizeof(ProcessesID),&dbNeeded); //Get Processes IDs.
 
 for(int i = 0; i < dbNeeded / sizeof(DWORD); i++)
 {
  if((ProcessesID[i] == GetCurrentProcessId()) || ProcessesID[i] == 4) continue; //Do not scan by self
 
  hProcess = OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION,FALSE,ProcessesID[i]);
 
  if(hProcess)
  {
   EnumProcessModules(hProcess,&hMod,sizeof(hMod),&dbNeeded2);
   GetModuleBaseName(hProcess,hMod,szProcess,sizeof(szProcess)); //Get Module Name
   p = struct_si.lpMinimumApplicationAddress;
   
   do
   {
      VirtualQueryEx(hProcess,p,&struct_mbi, sizeof(struct_mbi));
      newbuf = malloc(struct_mbi.RegionSize);
      //Sometimes regionSize makes me crazy!!!
      if(newbuf)
      {
       ReadProcessMemory(hProcess,p,newbuf,struct_mbi.RegionSize,&ret);
       if(ret)
       {
        for(DWORD i = (DWORD)newbuf; i <= (DWORD)newbuf+(DWORD)struct_mbi.RegionSize; i++)
        {
         for(int j = 0; j < cnt; j++)
         {
        if(!strnicmp((char *)StringDataBase[j],(char *)i,strlen((char *)StringDataBase[j])))
        {
         strcat(WarningString,szProcess);
         strcat(WarningString,"프로세스를 종료하신후 다시 실행하여 주세요.\n");
         MessageBox(NULL,WarningString,"해킹 프로그램 발견",MB_ICONSTOP);
         CloseHandle(hProcess);
         ExitProcess(-1);
        }
         }
        }
       }
      }
      free(newbuf);
      *((PDWORD)&p) += (DWORD)struct_mbi.RegionSize;
    }while(p < struct_si.lpMaximumApplicationAddress);
  }
      CloseHandle(hProcess);
 }
 return TRUE;
}


실제로 실행해보면 알 수 있지만, ReadProcessMemory()를 수행하는 것은 꾀 시간을
많이 소요하는 작업입니다. 이렇게 하는 것보다는 Dll을 모든 프로세스에 인젝션 시키신 후,
각 프로세스에 인젝션된 Dll에서 메모리 검사를 하게되면, 같은 프로세스 영역 내임으로,
ReadProcessMemory()도 필요 없으며, 분할처리가 가능해져, 그 속도 역시 빨라 집니다.
Dll을 인젝션 하는 방식의 코드는 별도로 코드를 첨부하도록 하겠습니다.

Finding Named Object기법의 경우는 창이름 이나 클레스 이름은 EnumWindow 함수를
돌면서 GetWindowText(), GetClassName()함수를 이용하여 구하여 비교하는 방식을
쓰면 됩니다. 코드는 다음과 같습니다.

char szWindowDataBase[][30] = {"CheatEngine",
         "AutoPlay",
         "GameHack",
         "Memory Search",
         "TSearch"};

char szClassDataBase[][30] = {"CheatEngine",
         "AutoPlay",
         "GameHack",
         "Memory Search",
         "TSearch"};

int cnt,cnt2;

BOOL CALLBACK EnumWinProc(HWND hwnd,LPARAM lparam)
{
   char szWindow[255];
   char szClass[255];
 
   if(GetParent(hwnd)) return TRUE;
   GetWindowText(hwnd,szWindow,255);
   GetClassName(hwnd,szClass,255);
  
   for(int i = 0; i < cnt; i++)
   {
   if(!strnicmp(szWindowDataBase[i],szWindow,strlen(szWindowDataBase[i])))
   {
  MessageBox(NULL,"게임 해킹 프로그램 발견 되었습니다.\n게임이 종료 됩니다.\n","해킹 프로그램 발견",MB_ICONSTOP);
  ExitProcess(-1);
   }
   }

   for(i = 0; i < cnt; i++)
   {
   if(!strnicmp(szClassDataBase[i],szClass,strlen(szClassDataBase[i])))
   {
  MessageBox(NULL,"게임 해킹 프로그램 발견 되었습니다.\n게임이 종료 됩니다.\n","해킹 프로그램 발견",MB_ICONSTOP);
  ExitProcess(-1);
   }
   }
   return TRUE;
}

BOOL FindBadWindowOrClass()
{
    for(cnt = 0; ;cnt++)    //Counting Pattern
      if(!szWindowDataBase[cnt][0])
           break;

    for(cnt2 = 0; ;cnt2++)    //Counting Pattern
      if(!szWindowDataBase[cnt2][0])
           break;

 EnumWindows(EnumWinProc,NULL);
 return TRUE;
}

프로세스 이름의 경우 EnumWindow 콜백에서 GetThreadProcessId() 함수를 한 후,
OpenProcess() 하여주고, GetModuleBaseName()함수를 이용하여 프로세스 이름을
구하여 확인시켜 주는 방식으로 진행하여 주면 됩니다. 이 코드는 패턴 검사의 코드를
조금 수정하면 됨으로 따로 올리진 않겠습니다. 그 나머지 요소는 GH 프로그램이
사용하고 있는 요소들을 어떻게 확인하는지 Process Explorer를 이용한 예제를 보여드
리 겠습니다.

사용자 삽입 이미지

먼저 위와 같이 Lower panel view를 Handles로 해줍니다.

사용자 삽입 이미지
TSearch에서 사용중인 핸들 목록을 볼 수 있는데요.
위 그림에서 보면, TSearch는 3가지의 독특한 Event를 만드는 것을 알 수 있습니다.
즉, 다음 3가지 중 하나를 선택하여 해당 이벤트가 존재하는지를 확인한다면,
TSearch의 실행여부를 확인할 수 있습니다. 코드는 다음과 같습니다.

BOOL CheckByEventName()
{
 char szEventDataBase[][30] = {
         "User stopped search",
         "Debugger Loaded",
         "TSearch.ServerLoaded"
        };
 HANDLE hEvent;

  for(int cnt = 0; ;cnt++)    //Counting Pattern
      if(!szEventDataBase[cnt][0])
           break;

  for(int i = 0; i < cnt; i++)
  {
 if(OpenEvent(EVENT_ALL_ACCESS,FALSE,szEventDataBase[i]))
 {
    MessageBox(NULL,"게임 해킹 프로그램 발견 되었습니다.\n게임이 종료 됩니다.\n","해킹 프로그램 발견",MB_ICONSTOP);
       ExitProcess(-1);
 }
  }

  return TRUE;
}

뮤텍스를 이용한 확인 방법의 코드는 다음과 같습니다.

BOOL CheckByMutexName()
{
 char szMutexDataBase[][30] = {
         "TSearch",
         "CheatEngine",
         "GameHack"
        };
 HANDLE hEvent;

  for(int cnt = 0; ;cnt++)    //Counting Pattern
      if(!szMutexDataBase[cnt][0])
           break;

  for(int i = 0; i < cnt; i++)
  {
 CreateMutex(NULL,FALSE,szMutexDataBase[i]);
 if(GetLastError() == ERROR_ALREADY_EXISTS)
 {
    MessageBox(NULL,"게임 해킹 프로그램 발견 되었습니다.\n게임이 종료 됩니다.\n","해킹 프로그램 발견",MB_ICONSTOP);
       ExitProcess(-1);
 }
  }

  return TRUE;
}

파일맵을 이용한 방법의 코드는 다음과 같습니다.

BOOL CheckByFileMapName()
{
 char szFileMapDataBase[][30] = {"DUALMEM",
         "TSearch",
         "CheatEngine",
         "GameHack"
        };
 HANDLE hFileMap;
 LPVOID pMapFile;

  for(int cnt = 0; ;cnt++)    //Counting Pattern
      if(!szFileMapDataBase[cnt][0])
           break;

  for(int i = 0; i < cnt; i++)
  {
 hFileMap = CreateFileMapping((HANDLE)INVALID_HANDLE_VALUE,NULL,
      PAGE_READWRITE,0,1,szFileMapDataBase[i]);
 if(GetLastError() == ERROR_ALREADY_EXISTS)
 {
    MessageBox(NULL,"게임 해킹 프로그램 발견 되었습니다.\n게임이 종료 됩니다.\n","해킹 프로그램 발견",MB_ICONSTOP);
       ExitProcess(-1);
 }
  }

  return TRUE;
}

레지스트리, 파일로 확인하는 방법은 어떤 레지스트리나 파일을 쓰는지는 Process
Explorer를 확인하는 것으로 동일하고, 확인은 레지스트리나 파일을 열 떄,
이미 존재하는지 여부만 확인해주면 됨으로 별도의 코드는 첨부하지 않겠습니다.
윈도우즈에 로드되어 있는 드라이버의 목록은 ntdll.dll의
ZwQuerySystemInformation() 를 이용하여 구할 수 있습니다.

참고적으로 위의 핸들목록을 출력하는 기능은 정덕영님의 저서 'Windows 구조와
원리 그리고 Codes'에 나온 코드인 ListHandles라는 코드도 똑같은 기능을 합니다.
코드는 다음과 같습니다.

#include "stdafx.h"
#include "windows.h"
#include <stdio.h>
#include "nativeAPI.h"

BOOL EnablePrivilege(PCSTR name)
{
    TOKEN_PRIVILEGES priv = {1, {0, 0, SE_PRIVILEGE_ENABLED}};
    LookupPrivilegeValue(0, name, &priv.Privileges[0].Luid);

    HANDLE hToken;
    OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);

    AdjustTokenPrivileges(hToken, FALSE, &priv, sizeof priv, 0, 0);
    BOOL rv = GetLastError() == ERROR_SUCCESS;

    CloseHandle(hToken);
    return rv;
}


int main(int argc, char* argv[])
{
    ULONG pid;
 HANDLE hProcess, hCurrentProcess;
 SYSTEM_HANDLE_INFORMATION  *aHandles;
 ULONG  nHandles, nCount;
 ULONG  *pULONG;
 
 //1. Parameter parsing
    if (argc == 1)
 {
  printf("HELP : ListHandles PID\n");
  return 0;
 }
 pid = strtoul(argv[1], 0, 0);

 //2. Get process handle
    EnablePrivilege(SE_DEBUG_NAME);
    hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
 hCurrentProcess = GetCurrentProcess();

 //3. Get Handle's Information
    nCount = 100;
    pULONG = (PULONG)malloc(nCount * sizeof(SYSTEM_HANDLE_INFORMATION) + sizeof(ULONG));
    while (ZwQuerySystemInformation(SystemHandleInformation, pULONG,
    nCount * sizeof(SYSTEM_HANDLE_INFORMATION)+ sizeof(ULONG)
    , 0) == STATUS_INFO_LENGTH_MISMATCH)
 {
  free(pULONG);
  nCount += 50;
  pULONG = (PULONG)malloc(nCount * sizeof(SYSTEM_HANDLE_INFORMATION) + sizeof(ULONG));
 }
 nHandles = *pULONG;
 aHandles = (PSYSTEM_HANDLE_INFORMATION)(pULONG + 1);
 
 //4. Print Handle's Information
 printf("Process ID : %x\n", pid);
    for (ULONG i = 0; i < nHandles; i++)
 {
        if (aHandles[i].ProcessId == pid)
  {
   HANDLE hObject;
   OBJECT_BASIC_INFORMATION obi;
   POBJECT_TYPE_INFORMATION pOti;
   POBJECT_NAME_INFORMATION pOni;
   ULONG nTypeName, nObjectName, n;

   if(DuplicateHandle(hProcess, (HANDLE)aHandles[i].Handle,
    hCurrentProcess, &hObject, 0, 0, DUPLICATE_SAME_ACCESS) == FALSE)
    continue;

            ZwQueryObject(hObject, ObjectBasicInformation, &obi, sizeof(obi), &n);
            printf("%p %04hx %3lx %3ld %4ld ",
                   aHandles[i].Object, aHandles[i].Handle, obi.Attributes,
                   obi.HandleCount - 1, obi.PointerCount - 2);
   //Object Type
            nTypeName = obi.TypeInformationLength + 2;
            pOti = (POBJECT_TYPE_INFORMATION)malloc(nTypeName);

            ZwQueryObject(hObject, ObjectTypeInformation, pOti, nTypeName, &nTypeName);
            printf("%-14.*ws ", pOti->Name.Length / 2, pOti->Name.Buffer);
   //Object Name
            nObjectName = obi.NameInformationLength == 0
                ? MAX_PATH * sizeof (WCHAR) : obi.NameInformationLength;

             pOni = (POBJECT_NAME_INFORMATION)malloc(nObjectName);
           
            if (NT_SUCCESS(ZwQueryObject(hObject, ObjectNameInformation, pOni,
       nObjectName, &nObjectName)))
                printf("%.*ws", pOni->Name.Length / 2, pOni->Name.Buffer);

            printf("\n");
   
   free(pOni); free(pOti); CloseHandle(hObject);
        }
    }
    free(aHandles);
    CloseHandle(hProcess);

    return 0;
}


세번쨰로 자동 플레이 차단은 에플리케이션 방식의 오토플레이라면 유저레벨에서
막는방법과 커널레벨에서 막는 방법으로 나뉠 수 있습니다. 사실 후킹하는 시점이
다를 뿐, 실제적으로 차단해야할 API들은 같습니다. 유저레벨에서는 모든 프로세스에
Dll을 인젝션 한 후, 해당 Dll에서 GetPixel(), PostMessageA(), PostMessageW(),
SendInput(), SendMessageA(), SendMessageW(), SetCursorPos(), keybd_event(),
mouse_event() 등의 함수를 차단하여 주어야 합니다.
커널레벨에서는 KeServiceDescriptorTableShadow에 있는 SendInput(),
NtUserQueryWindow(), NtUserBuildHwndList(), NtUserFindWindowEx(),
NtUserGetForegroundWindow(), GetDC(), GetWindowDC() 등의 함수를 후킹해서
처리해 주어야 합니다.  그래픽 관련 함수를 후킹하는 이유는 최근 오토플레이들은
단순한 메크로가 아닌, 픽셀 정보를 읽어온 후, 그에 interact하여 작동하는 방식을
많이 취하기 떄문입니다. 위의 함수들을 모두 후킹하여 처리하여 주면, 에플리케이션
방식의 메크로는 거의 차단된다고 보시면 됩니다. (커널레벨에서의 irp 발생 및
pesudo 코드 사용등 예외는 존재합니다.)

네번쨰로 메시지 후킹 차단은 커널단에서 비교적 강력하게 구현될 수 있는데,
메시지 후킹은 SetWindowHookEx()를 이용해서 이루어 지는데, 운영체제 내에서는
다음과 같은 구조체로 관리 되어 집니다.
typedef struct _HOOK {
ULONG hHook;
ULONG cLockObj;
PTHREADINFO pti; //THREADINFO of CurrentThread
ULONG rpdesk;
ULONG pSelf;
struct _HOOK *phkNext;
int iHook; //HOOK_TYPE
ULONG offPfn; //Proc
unsigned int flags; //Flags
int ihmod;
PTHREADINFO ptiHooked; //THREADINFO of TargetThread (if Flags=HF_GLOBAL,=0)
PDESKTOP rpdesk;
} HOOK, *PHOOK;

TEB의 Win32ThreadInfo 구조체의 pDeskInfo에 aphkStart라는 배열이
훅을 관리하는데, 즉 이 배열을 주기적으로 0으로 초기화 시킴으로써 설치된 훅을
제거할수도 있으며 메시지 후킹을 차단할수도 있습니다.

다섯번쨰로 필요한 기능으로써, 허용되지 않은 메모리 접근차단은 유저레벨에서는
각 프로세스에 Dll을 인젝션 한 후, NtOpenProcess(), NtProtectVirtualMemory(),
NtReadVirtualMemory(), NtWriteVirtualMemory(), ZwOpenProcess(), ZwProtect
VirtualMemory(), ZwReadVirtualMemory(), ZwWriteVirtualMemory(),
OpenProcess(), ReadProcessMemory(), VirtualProtect(), VirtualProtectEx(),
WriteProcessMemory(), GetWindowThreadProcessId()등의 API를 후킹하여
주어야 합니다. 유저레벨에서의 후킹코드는 앞에서 다뤘던 코드에 조금의 수정을
가하면 되는 것임으로, 생략하도록 하겠습니다. 커널레벨에서의 후킹코드들은
다음과 같습니다.

ZwOpenProcess Hook :

NTSTATUS NewZwOpenProcess(
    OUT PHANDLE ProcessHandle,
    IN ACCESS_MASK DesiredAccess,
    IN POBJECT_ATTRIBUTES ObjectAttributes,
    IN PCLIENT_ID ClientId OPTIONAL
)
{
    NTSTATUS rc;
    NTSTATUS rc2;
    CHAR Caller_Process_Name[PROCNAMELEN];
    CHAR Target_Process_Name[PROCNAMELEN];
    PEPROCESS Process;
    char *nameptr;
    
    GetProcessName( Caller_Process_Name );  //Get Process Name

    rc = ((ZWOPENPROCESS)(OldZwOpenProcess)) (
   ProcessHandle,
   DesiredAccess,
   ObjectAttributes,
   ClientId OPTIONAL); 
 
 if(DesiredAccess == PROCESS_ALL_ACCESS)
 {

  if(NT_SUCCESS(rc))    
  {       
   
   rc2 = ObReferenceObjectByHandle(
      *ProcessHandle,
      PROCESS_ALL_ACCESS,
      NULL,
      KernelMode,
      (void *)&Process,
      NULL);
   if(NT_SUCCESS(rc2))
   {
    nameptr = (PCHAR)Process + gProcessNameOffset;
    strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
    Target_Process_Name[NT_PROCNAMELEN] = 0;
    if(!strncmp(Target_Process_Name,MYPROCESS,strlen(MYPROCESS)))
    {
     ObDereferenceObject(Process);
     ZwClose(ProcessHandle);
     rc = STATUS_INVALID_HANDLE;
     ProcessHandle = 0;
    }
   }
  }
 }
    return rc;
}

ZwOpenProcess() 함수를 후킹하고 있다가, 만약 핸들을 오픈하고자 하는 프로세스가,
보호하는 프로세스라면 핸들을 닫고 잘못된 핸들이라고 값을 리턴합니다.

ZwWriteVirtualMemory Hook :

NTSTATUS NTAPI NewZwWriteVirtualMemory(
 IN HANDLE hProcess,
 IN PVOID BaseAddress,
 IN PVOID Buffer,
 IN ULONG BytesToWrite,
 OUT PULONG BytesWritten
)
{
 NTSTATUS rc;
 NTSTATUS rc2;
                  CHAR Attack_Process_Name[PROCNAMELEN];
 CHAR Target_Process_Name[PROCNAMELEN];
 PEPROCESS Process;
 char *nameptr;

 GetProcessName( Caller_Process_Name );

 rc2 = ObReferenceObjectByHandle(
     hProcess,
     PROCESS_ALL_ACCESS,
     NULL,
     KernelMode,
     (void *)&Process,
     NULL);
 if(NT_SUCCESS(rc2))
 {
  nameptr = (PCHAR)Process + gProcessNameOffset;
  strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
  Target_Process_Name[NT_PROCNAMELEN] = 0;
  ObDefreferenceObject(Process);
  if(!strncmp(Target_Process_Name,MYPROCESS,strlen(MYPROCESS)))
  {
   return STATUS_UNSUCCESSFUL;
  }
 }

 rc = ((ZWWRITEVIRTUALMEMORY)(OldZwWriteVirtualMemory)) (
  hProcess,
  BaseAddress,
  Buffer,
  BytesToWrite,
  BytesWritten);
 return rc;
}


ZwReadVirtualMemory Hook :

NTSTATUS NTAPI NewZwReadVirtualMemory(
 IN HANDLE hProcess,
 IN PVOID BaseAddress,
 OUT PVOID Buffer,
 IN ULONG BytesToRead,
 OUT PULONG BytesRead
)
{
 NTSTATUS rc;
  NTSTATUS rc2;
                  CHAR Caller_Process_Name[PROCNAMELEN];
 CHAR Target_Process_Name[PROCNAMELEN];
 PEPROCESS Process;
 char *nameptr;

 GetProcessName( Caller_Process_Name ); 

 rc2 = ObReferenceObjectByHandle(
     hProcess,
     PROCESS_ALL_ACCESS,
     NULL,
     KernelMode,
     (void *)&Process,
     NULL);
 if(NT_SUCCESS(rc2))
 {
  nameptr = (PCHAR)Process + gProcessNameOffset;
  strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
  Target_Process_Name[NT_PROCNAMELEN] = 0;
  ObDefreferenceObject(Process);
  if(!strncmp(Target_Process_Name,MYPROCESS,strlen(MYPROCESS)))
  {
   {
    return STATUS_INVALID_HANDLE;
   }
  }
 }
 
 rc = ((ZWREADVIRTUALMEMORY)(OldZwReadVirtualMemory)) (
   hProcess,
   BaseAddress,
   Buffer,
   BytesToRead,
   BytesRead);
 return rc;
}

여섯번쨰로 디버깅 차단은 코드에 안티 디버깅 루틴을 삽입과 후킹을 사용합니다.
안티 디버깅 루틴을 먼저 다루어 보면,
첫번쨰로 IsDebuggerPresent() 함수를 이용한 방법이 있는데,
IsDebuggerPresent()함수는 kernel32.dll에 의해 export되어지는 함수로써,
해당 함수를 호출한 프로세스가 디버깅 당하는 중이면 TRUE(1)을,
아닐 경우는 FALSE(0)을 반환하는 함수이다. 즉 이 함수를 주기적으로 호출하여
줌으로써 디버깅 여부를 확인할 수 있다. 코드는 다음과 같습니다.

if(IsDebuggerPresent())
{
    OutputDebugString("Debugeed!!");
    //디버깅 당하는 중일떄의 어떠한 처리
}

두번쨰 방법으로 PEB 구조체의 BeingDebuggged 값을 직접 조작하는 방법이 있다.
IsDebuggerPresent()함수는 내부적으로, PEB의 BeingDebugged값을 읽어서 리턴
하여 주는 함수입니다. 즉 IsDebuggerPresent()함수를 호출하지 않고, 직접
PEB의 BeingDebugged의 값을 읽어와도 결과는 같다는 소리입니다.
다음은 PEB의 BeingDebugged의 값을 읽어오는 함수 입니다.

BOOL Pesudo_IsDebuggerPresent()
{
BOOL Retval = 0;
  __asm
  {
      push eax
      mov eax,dword ptr fs:{0x18]
      mov eax,dword ptr ds:[eax+0x30]
      movzx eax,byte ptr ds:[eax+0x2]
      mov Retval,eax
     pop eax
  }
  return Retval;
}

세번쨰 방법으로 CheckRemoteDebuggerPresent() 함수를 이용하는 방법이 있습니다.
이 함수는 함수를 호출하는 프로세스 자신외에도, 타 프로세스에도 사용이 가능합니다.
다음과 같이 사용합니다.

BOOL CheckDebugger(HANDLE hProcess)

{
     BOOL Retval = 0;
 
     CheckRemoteDebuggerPresent(hProcess,&Retval);
     return Retval;
}

* CheckRemoteDebuggerPresent()는 NTAPI의 ZwQueryInformationProcess()로
연결됩니다. ZwQueryInformationProcess()는 다음과 같은 호출 인자를 갖는 함수입니다.

NTSTATUS NTAPI ZwQueryInformationProcess(HANDLE ProcessHandle,
    PROCESSINFOCLASS ProcessInformationClass,
    PVOID ProcessInformation,
    ULONG ProcessInformationLength,
    PULONG ReturnLength);

첫번쨰는 질의 하고자 하는 대상 프로세스의 핸들.
두번쨰는 질의 하고자 하는 내용(디버깅 여부는 ProcessDebugPort)
세번쨰는 결과
네번쨰는 길이
다섯번쨰는 실반환 길이이다.
해당 함수를 직접 호출하는 것도 하나의 방법이 될 수 있을 것입니다.

네번쨰 방법으로 NtGlobalFlag의 값을 확인하는 방법이 있다.
디버거가 프로세스를 디버깅 할때는, 셋되어 지는 Flag들이 있는데, NtGlobalFlag는
그 중 하나이다. 코드는 다음과 같습니다.

BOOL CheckNtGlobalFlag()
{
  BOOL Retval = 0;

  __asm
  {
        push eax
        mov eax,dword ptr fs:[0x30]
         mov eax,0x68
         mov eax,dword ptr ds:[eax]
         cmp eax,0x70
        pop eax
        jne NotDebuged
         mov Retval,1
NotDebugged :
         nop
    }
    return Retval;
}

다섯번쨰 방법으로 Heap flags를 이용하는 방법이 있습니다. Heap의 상태가 디버그
되지 않고 있는 평소 상태와 다른지를 확인하는 것은 강력한 안티디버그 메소드가 될
수 있습니다. 예를들면, 힙 해더에 있는 ForceFlags(오프셋 0x10)은 디버거의 존재
여부를 확인하기 위해 쓰일 수 있습니다.대략적인 코드는 다음과 같습니다.

mov eax, fs:[30h]
mov eax, [eax+18h] ;process heap
mov eax, [eax+10h] ;heap flags
test eax, eax
jne @DebuggerDetected

여섯번쨰 방법으로 UnhandledExceptionFilter를 이용하는 방법이 있습니다.
SEH 핸들러의 주소로 디버거가 없을시 실행할 코드로 넣어주고,
고의적으로 예외를 발생시키어, 디버거가 있는지 없는지를 확인하여 주는
방법입니다. (디버거가 존재함으로, SEH 핸들러로 넘어 가지 않고, 다음 명령을
실행 시키게 되는점을 이용) 코드는 다음과 같습니다.

push @not_debugged
call SetUnhandledExceptionFilter
xor eax, eax
mov eax, dword [eax] ; trigger exception
;program terminated if debugged
;...
@not_debugged:
;process the exception
;continue the execution
;...

일곱번째로 NtSetInformationThread를 이용하는 방법이 있습니다. ThreadInformationClass 가 0x11 (ThreadHideFromDebugger 상수)로 지정되고
호출되면, 스레드는 디버거로부터 분리 될 것입니다. (ThreadHideFromDebugger는
ETHREAD의 필드중에 하나죠.) 코드는 다음과 같습니다.

Example:
push 0
push 0
push 11h ;ThreadHideFromDebugger
push -2
call NtSetInformationThread
;thread detached if debugged
;...

여덟번쨰로 kernel32!CloseHandle and NtClose 를 이용하는 방법이 있습니다.
프로세스가 디버그될 떄, ZwClose() 를 잘못된 핸들을 주고 호출하는 것은
STATUS_INVALID_HANDLE(0xC0000008) 예외를 발생 시킵니다.
디버깅 당하고 있다면, CloseHandle()를 호출하는 다음줄의 코드를 발생시킬 것이고,
디버깅 되고 있지 않다면, SEH핸들러가 호출될 것임을 이용한 방법입니다.
코드는 다음과 같습니다.

push offset @not_debugged
push dword fs:[0]
mov fs:[0], esp
push 1234h ;invalid handle
call CloseHandle
; if fall here, process is debugged
;...
@not_debugged:
;...

아홉번쨰로 OutputDebugStringA를 이용하는 간단한 방법도 있습니다.
OutputDebugString()함수가 성공적으로 수행되는지, 안되는지 (리턴값)을 확인하는
방법입니다. 코드는 다음과 같습니다.

xor eax, eax
push offset szHello
call OutputDebugStringA
cmp eax, 1
jne @DebuggerDetected
...

앞서 말한 방법들을 모두 TLS Callback으로써 등록하여 작동시킬수도 있습니다.
TLS Callback은 스텔스하게 안티 디버그 코드를 실행시킬 수 있는 방법으로 사용될
수 있는데, 단지 안티 디버그 코드를 프로그램에 넣어놓고, 헥스 에디터등을 이용하여
PE해더의 Thread Local Storage entry (PE optional header에서 10번째 디렉토리 엔트리
에 있는) 의 값을 코드의 주소로 바꾸어줌으로써, 안티 디버그 코드가 프로그램의
엔트리 포인트가 실행되기전에, 실행 되도록 만들어 줄 수 있습니다.

열번째 방법으로 커널레벨에서 확인하는 방법으로써,  보호하고자 하는 프로세스의
EPROCESS에 debug port의 값을 확인하는 방법이 있습니다. debug port의 값은
디버깅 되고 있지 않을떄는 0이며, 디버깅 될때에는 0이 아닙니다. 이 점을 이용해서
디버깅 여부를 확인하고 싶은 프로세스의 EPROCESS 스트럭쳐의 debug port값을
확인하는 것은 아주 강력한 안티 디버그 방법으로서 사용될 수 있습니다.
이 밖에도 훨씬 많은 안티 디버깅 방법들이 존재하며,
나머지 목록및 더 자세한 설명은 다음페이지를 참조하시기 바랍니다.
http://dual5651.hacktizen.com/tt/entry/Windows-Anti-Debug-Reference

이렇게 많은 안티 디버깅 루틴이 존재하지만, 안티 디버깅 루틴만으로 충분한 것은
아닙니다. 위에서 말했듯이, 후킹 역시 중요한 부분을 차지 합니다.
DebugActiveProcess() 같은 함수를 필수적으로 후킹해 주어서 디버거가 붙는
자체를 차단해 주어야 합니다. 또 게임을 바로 실행시키는 방식이 아닌,
로더를 거치는 방식을 사용하여, CreateProcess()에 DEBUG_ONLY_THIS_PROCESS
같은 옵션을 가지고 임으로 사용되는 것을 막아주어야 합니다.

여덟번쨰로 필요한 기능인 무결성 검사의 코드는 다음과 같습니다.

#include "stdafx.h"
#include <windows.h>

int main(int argc, char* argv[])
{
 int a;
 DWORD checksum = 0xE1E4CDE2;
 __asm
 {
  pushad
  pushfd

  mov esi,offset StartAddressOfCheck
  mov ecx,offset EndAddressOfCheck
  sub ecx,offset StartAddressOfCheck
  xor eax,eax
  xor ebx,ebx

  Check_Loop:
    mov ebx, [esi]
    add eax,ebx
    rol eax,1
    inc esi
    loop Check_Loop
 
    cmp eax,checksum
    jne EndAddressOfCheck //코드 조작 감지
    popfd
    popad
 }
StartAddressOfCheck:
 a = 5;
 if(a > 10)
 {
  MessageBox(NULL,"You beat this program!!","Congratulation",64);
  return 0;
 }
 else
 {
  MessageBox(NULL,"a 변수의 값이 10보다 작습니다.","ashole!",MB_ICONWARNING);
  return 0;
 }
EndAddressOfCheck:
 __asm
 {
  popfd
  popad
 }
 MessageBox(NULL,"You can`t beat this program sxxker!!","Cracker!!",MB_ICONWARNING);
 return 0;
}

StartAddressOfCheck 로 부터 EndAddressOfCheck 까지의 명령어들의 합산값을
미리 계산하여 두고, 프로그램을 실행할 떄에, 그값이 기존의 값과 같은지 여부를
확인하여 변조되었는지를 확인하는 방법입니다. 이 확인하는 루틴을 별도의 스레드를
만들어 와일을 돌리거나, 타이머를 이용하는 방법으로, 코드의 지속적인 감시도 가능합니다.
단, 명령코드의 합산은 현재 코드가 존재하는 주소에 의해서도 영향을 받기 떄문에,
컴파일 모드가 디버그 인지, 릴리즈 인지, StartAddressOfCheck앞에 새로운 코드나
문자열등 StartAddressOfCheck의 주소에 영향을 줄 수 있는 변수가 있으면, 새롭게
checksum 값을 계산하여 상수값으로 주어야 합니다. 다소 귀찮은 면이 있지만,
프로그램을 안전하게 보호하는데 한 역활을 할 수 있습니다. 위의 코드는 프로세스에
대한 검사이지만, 파일에 대해서도 쉽게 적용할 수 있을 것입니다. (ReadFile())
또, 조금만 생각해보면, 게임에 무결성 체크 코드를 넣지 않아도, Anti GH 프로그램에서
ReadProcessMemory()함수를 이용하여 체크할수도 있을 것입니다.

아홉번쨰로 필요한 기능인 시스템 디스크립터 복구이 의미하는 것은 Rootkit에
의해 변조되어 있을, 디스크립터들(ex: SSDT, IDT, and so on..)을 의미 합니다.
SSDT 나 IDT의 변조여부는 어떻게 확인하는가? 원리는 간단합니다.
SSDT나 IDT는 기본적으로 ntoskrnl.exe의 메모리 영역에 속함으로,
각 모듈들의 시작주소와 끝주소들을 구해놓고, 만약 백터나 디스패쳐의 주소가
ntoskrnl.exe의 시작주소와 끝주소 사이에 있지 않다면, 이는 변조된 것으로
판단하면 됩니다. 코드는 다음과 같습니다.

PMODULE_LIST GetListOfModules(PNTSTATUS pns)

{

    ULONG ul_NeededSize;

    ULONG *pul_ModuleListAddress = NULL;

    NTSTATUS     ns;

    PMODULE_LIST pml = NULL;

    // Call it the first time to determine the size required

    // to store the information.

    ZwQuerySystemInformation(SystemModuleInformation,

                             &ul_NeededSize,

                             0,

                             &ul_NeededSize);

    pul_ModuleListAddress = (ULONG *) ExAllocatePool(PagedPool, ul_NeededSize);

    if (!pul_ModuleListAddress) // ExAllocatePool failed.

    {

        if (pns != NULL)

          *pns = STATUS_INSUFFICIENT_RESOURCES;

        return (PMODULE_LIST) pul_ModuleListAddress;

    }

    ns = ZwQuerySystemInformation(SystemModuleInformation,

                                  pul_ModuleListAddress,

                                  ul_NeededSize,

                                  0);

    if (ns != STATUS_SUCCESS)// ZwQuerySystemInformation failed.

    {

        // Free allocated paged kernel memory.

        ExFreePool((PVOID) pul_ModuleListAddress);

        if (pns != NULL)

           *pns = ns;

        return NULL;

    }

    pml = (PMODULE_LIST) pul_ModuleListAddress;

    if (pns != NULL)

       *pns = ns;

    return pml;

}

..................

   g_pml = GetListOfModules(&ns);
   if(!g_pml)
   {
    DbgPrint("Get Failed");
    return;
   }
    for(count = 0; count < g_pml->d_Modules; count++)
 {
  if(!_stricmp("ntoskrnl.exe",g_pml->a_Modules[count].a_bPath+g_pml->a_Modules[count].w_NameOffset))
  {
   g_NTOSKRNL.Base = (ULONG)g_pml->a_Modules[count].pBase;
   g_NTOSKRNL.End = ((ULONG)g_pml->a_Modules[count].pBase + g_pml->a_Modules[count].d_Size);
  }
 }

위의 코드로 ntoskrnl.exe의 시작주소와 끝주소를 알 수 있으며, SSDT와 IDT를
끝번호까지 돌면서, ntoskrnl.exe에 속하는지만 확인하여 주면 됩니다.
만약, 이런식으로 루프를 돌다가 변조된 것이 발견되면 어떻게 복구해야할까요?
그것에 대해서는
http://dual5651.hacktizen.com/tt/entry/SSDT-후킹-무력화에-대한-연구
의 SSDT Restore에 대해서 읽어보시고, 코드를 참조하시면 됩니다.

목차에는 없지만 최근 많이 사용되고 있는 프로세스 숨기기에 대해서도 간단히
다루어 보겠습니다. 첫번째로 사용할 수 있는 방법으로서 커널단에서
ZwQuerySystemInformation() 이라는 함수를 후킹하는 방법이 있습니다.
코드는 다음과 같습니다.

NTSTATUS NTAPI NewZwQuerySystemInformation(
            IN ULONG SystemInformationClass,
   IN PVOID SystemInformation,
   IN ULONG SystemInformationLength,
   OUT PULONG ReturnLength
)
{
 NTSTATUS rc;
 CHAR Attack_Process_Name[PROCNAMELEN];
 
 GetProcessName( Attack_Process_Name );

 rc = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (
   SystemInformationClass,
   SystemInformation,
   SystemInformationLength,
   ReturnLength );

 if( NT_SUCCESS( rc ) && strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
 {

  if(5 == SystemInformationClass)
  {
   struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *)SystemInformation;
   struct _SYSTEM_PROCESSES *prev = NULL;

   while(curr)
   {    
    ANSI_STRING process_name;
    ANSI_STRING ANSI_Enemy_Name;
    UNICODE_STRING Enemy_Name;
    RtlUnicodeStringToAnsiString( &process_name, &(curr->ProcessName), TRUE);
    if( (255 > process_name.Length) && (0 < process_name.Length) )
    {
     if(0 == strncmp( process_name.Buffer, ProcessName, NT_PROCNAMELEN-1))
     {
 
      //DbgPrint("[Alarm] ProcessScan Detected\n");
      //DbgPrint("Called by %s\n",Attack_Process_Name);
       if(prev)
       {
        if(curr->NextEntryDelta)
        {
         prev->NextEntryDelta += curr->NextEntryDelta;
        }
        else
        {
         prev->NextEntryDelta = 0;
        }
       }
       else
       {
        if(curr->NextEntryDelta)
        {
         (char *)SystemInformation += curr->NextEntryDelta;
        }
        else
        {
         SystemInformation = NULL;
        }
       }
     }
    }
    RtlFreeAnsiString(&process_name);
    prev = curr;
    if(curr->NextEntryDelta) ((char *)curr += curr->NextEntryDelta);
    else
    {
     curr = NULL;
    }
   }
  }
 }
 return rc;
}

NtUserQueryWindow(), NtUserBuildHwndList(), NtUserFindWindowEx(),
NtUserGetForegroundWindow() 라는 함수들은 창의 핸들과 관련이 있는 함수들입니다.
창의 핸들을 획득하는 것을 차단하기 위해 위의 함수들을 후킹하는 코드 입니다.

UINT_PTR NewNtUserQueryWindow(IN ULONG WindowHandle,IN ULONG TypeInformation)
{
    ULONG WindowHandleProcessID;
    CHAR Attack_Process_Name[PROCNAMELEN];
    CHAR Target_Process_Name[PROCNAMELEN];
    PEPROCESS Process;
    char *nameptr;

        GetProcessName(Attack_Process_Name);
 if(strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
 {
  WindowHandleProcessID = ((NTUSERQUERYWINDOW)(WINDOWSERVICEIDX(483)))(WindowHandle,0);
  if(PsLookupProcessByProcessId((HANDLE)WindowHandleProcessID,&Process) == STATUS_SUCCESS)
        {
   ObDereferenceObject(Process);
                 nameptr = (PCHAR)Process + gProcessNameOffset;
   strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
   Target_Process_Name[NT_PROCNAMELEN] = 0;
   if(!strncmp(Target_Process_Name,ProcessName,NT_PROCNAMELEN-1) || WindowHandleProcessID == SaruenProcessID)
   {
    return 0;
   }
  }
    }  
 return OldNtUserQueryWindow(WindowHandle,TypeInformation);
}

NTSTATUS NewNtUserBuildHwndList(IN HDESK hdesk, IN HWND hwndNext, IN ULONG fEnumChildren, IN DWORD idThread, IN UINT cHwndMax, OUT HWND *phwndFirst, OUT ULONG* pcHwndNeeded)
{
 NTSTATUS result;
    CHAR Attack_Process_Name[PROCNAMELEN];
 CHAR Target_Process_Name[PROCNAMELEN];
 ULONG ProcessID;
 PEPROCESS Process;
 char *nameptr;
 ULONG i = 0,j;
 
    GetProcessName(Attack_Process_Name);
 if(strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
 {
  if(fEnumChildren == 1)
  {
   ProcessID = OldNtUserQueryWindow((ULONG)hwndNext,0);
   if(PsLookupProcessByProcessId((HANDLE)ProcessID,&Process) == STATUS_SUCCESS)
            {
    ObDereferenceObject(Process);
                   nameptr = (PCHAR)Process + gProcessNameOffset;
     strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
    Target_Process_Name[NT_PROCNAMELEN] = 0;
    if(!strncmp(Target_Process_Name,ProcessName,NT_PROCNAMELEN-1) || ProcessID == SaruenProcessID)
    {
     return STATUS_UNSUCCESSFUL;
    }
   }
          }
  result=((NTUSERBUILDHWNDLIST)(WINDOWSERVICEIDX(312)))(hdesk,hwndNext,fEnumChildren,idThread,cHwndMax,phwndFirst,pcHwndNeeded);
  if (result == STATUS_SUCCESS)
  {
   while (i<*pcHwndNeeded)
   {
    ProcessID=OldNtUserQueryWindow((ULONG)phwndFirst[i],0);
    if(PsLookupProcessByProcessId((HANDLE)ProcessID,&Process) == STATUS_SUCCESS)
              {
                    nameptr = (PCHAR)Process + gProcessNameOffset;
      strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
     Target_Process_Name[NT_PROCNAMELEN] = 0;
     ObDereferenceObject(Process);
     if(!strncmp(Target_Process_Name,ProcessName,NT_PROCNAMELEN))
     {
       for (j=i; j<(*pcHwndNeeded)-1; j++)    
         phwndFirst[j]=phwndFirst[j+1];
       phwndFirst[*pcHwndNeeded-1]=0;
       (*pcHwndNeeded)--;
       continue;
     }
    }
    i++;
   }
  }
  return result;
 }
 return OldNtUserBuildHwndList(hdesk,hwndNext,fEnumChildren,idThread,cHwndMax,phwndFirst,pcHwndNeeded);
}

ULONG NewNtUserFindWindowEx(IN HWND hwndParent, IN HWND hwndChild, IN PUNICODE_STRING pstrClassName OPTIONAL, IN PUNICODE_STRING pstrWindowName OPTIONAL, IN DWORD dwType)
{
 ULONG result;
 ULONG ProcessID;
        PEPROCESS Process;
        char *nameptr;
        CHAR Attack_Process_Name[PROCNAMELEN];
        CHAR Target_Process_Name[PROCNAMELEN];

        GetProcessName(Attack_Process_Name);
        if(!strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
  {
   result=OldNtUserFindWindowEx(hwndParent,hwndChild,pstrClassName,pstrWindowName,dwType);
   return result;
  }
  result = ((NTUSERFINDWINDOWEX)(WINDOWSERVICEIDX(378)))(hwndParent,hwndChild,pstrClassName,pstrWindowName,dwType);
  if(strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
        {
           ProcessID = OldNtUserQueryWindow(result,0);
           if(PsLookupProcessByProcessId((HANDLE)ProcessID,&Process) == STATUS_SUCCESS)
           {
                 nameptr = (PCHAR)Process + gProcessNameOffset;
   strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
  Target_Process_Name[NT_PROCNAMELEN] = 0;
  if(!strncmp(Target_Process_Name,ProcessName,NT_PROCNAMELEN-1) || ProcessID == SaruenProcessID)
  {
   result=0;
  }
  ObDereferenceObject(Process);
           }
           
        }
 return result;
}

ULONG NewNtUserGetForegroundWindow(VOID)
{
 ULONG result;
 ULONG ProcessID;
        PEPROCESS Process;
        char *nameptr;
        CHAR Attack_Process_Name[PROCNAMELEN];
        CHAR Target_Process_Name[PROCNAMELEN];

        GetProcessName(Attack_Process_Name);
  if(!strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
  {
   result=OldNtUserGetForegroundWindow();
   return result;
  }
  result = ((NTUSERGETFOREGROUNDWINDOW)(WINDOWSERVICEIDX(404)))();
        if(strncmp(Attack_Process_Name,ProcessName,NT_PROCNAMELEN-1))
        {
           ProcessID = OldNtUserQueryWindow(result,0);
           if(PsLookupProcessByProcessId((HANDLE)ProcessID,&Process) == STATUS_SUCCESS)
           {
                 nameptr = (PCHAR)Process + gProcessNameOffset;
   strncpy(Target_Process_Name, nameptr, NT_PROCNAMELEN);
  Target_Process_Name[NT_PROCNAMELEN] = 0;
  if(!strncmp(Target_Process_Name,ProcessName,NT_PROCNAMELEN-1) || ProcessID == SaruenProcessID)
  {
   result=LastForegroundWindow;
  }
  else
  {
   LastForegroundWindow=result;
  }
  ObDereferenceObject(Process);
           }
           
        }
 return result;
}

두번쨰로 사용할 수 있는게 DKOM입니다. DKOM은 예외경우가 많이 발생할 수 있음으로,
필드 프로그램에서 사용할 떄에는, 신중에 신중을 고려하여야 할 부분입니다.

첫번째로 가장 많이 알려진 DKOM적 방법인 EPROCESS LINK를 끊는 방법입니다.
먼저 숨기고자 하는 프로세스 이름으로 EPROCESS를 찾는 함수 입니다.

PEPROCESS
FindProcessByName(char *Name)
{
 PLIST_ENTRY start_plist,plist_hTable = NULL;
 ULONG *d_pid;
 PEPROCESS eproc;
 char *nameptr;
 CHAR Process_Name[NT_PROCNAMELEN];
 NTSTATUS rc;

 plist_hTable = (PLIST_ENTRY)((*(ULONG*)
  ((ULONG)PsInitialSystemProcess + 0xC4)) + 0x1C);
 
 start_plist = plist_hTable;


 do
 {
  d_pid = (ULONG*)(((ULONG)plist_hTable + 0x8)
      - 0x1C);
  rc = PsLookupProcessByProcessId((HANDLE)*d_pid,&eproc);
  if(eproc && NT_SUCCESS(rc))
  {
   nameptr = (PCHAR)eproc + gProcessNameOffset;
   strncpy(Process_Name, nameptr, NT_PROCNAMELEN);
   Process_Name[NT_PROCNAMELEN] = 0;
   ObDereferenceObject(eproc);
   if(!strncmp(Process_Name,Name,NT_PROCNAMELEN-1))
   {
    return eproc;
   }
  }
 // DbgPrint("%s\n",Process_Name);
  plist_hTable = plist_hTable->Flink;  
 }while(start_plist != plist_hTable);

 return 0;
}

그후에는 다음과 같은 코드로 숨킬 수 있습니다.

PEPROCESS MyProcess;
PLIST_ENTRY plist_active_procs;

MyProcess = FindProcessByName(ProcessName);

    if(MyProcess)
    {
     plist_active_procs = (LIST_ENTRY *)((DWORD)MyProcess + 0x88);
     *((DWORD *)plist_active_procs->Blink) = (DWORD)plist_active_procs->Flink;
     *((DWORD *)plist_active_procs->Flink+1) = (DWORD)plist_active_procs->Blink;
     plist_active_procs->Flink = (LIST_ENTRY *) &(plist_active_procs->Flink);
     plist_active_procs->Blink = (LIST_ENTRY *) &(plist_active_procs->Flink);
    }

위의 코드에 다음과 같은 한줄을 붙여넣음으로서, 보호하고자 하는 프로세스의
PID를 0으로 만들어 접근이 불가능하게 할 수도 있습니다.

*((DWORD*)((DWORD)MyProcess+0x84)) = 0;

csrss.exe 에서 핸들을 지우는 코드 입니다.

 PEPROCESS gpeproc_csrss;

  gpeproc_csrss = (PEPROCESS)FindProcessByName("csrss.exe");
    if(!gpeproc_csrss) gpeproc_csrss = (PEPROCESS)FindProcessByName
                                                                               ("CSRSS.EXE");


if(gpeproc_csrss) EraseHandle((PEPROCESS)gpeproc_csrss, (PVOID)MyProcess);

void EraseHandle(PEPROCESS eproc, PVOID tarHandle)
{
 PTABLE_ENTRY   orig_tableEntry, p_tableEntry, *pp_tableEntry, **ppp_tableEntry;
 int a, b, c;
 int i_numHandles, i_hperPage, i_numTables;
 int i_handle;

 //DbgPrint("Hiding %x from %s process handle table.\n", tarHandle, (DWORD)eproc+gul_ProcessNameOffset);
 i_numHandles = *(int*)((*(PDWORD)((DWORD) eproc + 0xC4)) + 0x3C);
 orig_tableEntry = (PTABLE_ENTRY)*(PDWORD)((*(PDWORD)((DWORD) eproc + 0xC4)));
 i_numTables = ((DWORD)orig_tableEntry & 3);

 i_hperPage = PAGE_SIZE/sizeof(TABLE_ENTRY);
 
 if (i_numTables == 0)
 {
  //DbgPrint("Found a single level handle table.\n");
  p_tableEntry = (PTABLE_ENTRY)((DWORD)orig_tableEntry & 0xfffffff8);
  for (a = 0; a < i_hperPage; a++)
  {
   if (((p_tableEntry[a].object ^ 0x80000000) & 0xfffffff8) == ((DWORD)tarHandle - 0x18))
   {
    //DbgPrint("Handle = %x Object Header %x Security %x\n", a*4, ((p_tableEntry[a].object | 0x80000000) & 0xfffffff8), p_tableEntry[a].security);
    p_tableEntry[a].object = 0;
    p_tableEntry[a].security = 0;
   }
  }
 }
 else if (i_numTables == 1)
 {
  //DbgPrint("Found a two level handle table.\n");
  pp_tableEntry = (PPTABLE_ENTRY)((DWORD)orig_tableEntry & 0xfffffff8);
  for (a = 0; a < i_hperPage; a++)
  {
   if (pp_tableEntry[a] == NULL)
    break;

   for (b = 0; b < i_hperPage; b++)
   {
    if (((pp_tableEntry[a][b].object ^ 0x80000000) & 0xfffffff8) == ((DWORD)tarHandle - 0x18))
    {
     //DbgPrint("Handle = %x Object Header %x Security %x\n", ((a*512)+b)*4, ((pp_tableEntry[a][b].object | 0x80000000) & 0xfffffff8), pp_tableEntry[a][b].security);
     pp_tableEntry[a][b].object = 0;
     pp_tableEntry[a][b].security = 0;
    }
   }
   
  }
 }
 else if (i_numTables == 2)
 {
  //DbgPrint("Found a three level handle table.\n");
  ppp_tableEntry = (PPPTABLE_ENTRY)((DWORD)orig_tableEntry & 0xfffffff8);
  for (a = 0; a < i_hperPage; a++)
  {
   if (ppp_tableEntry[a] == NULL)
    break;

   for (b = 0; b < i_hperPage; b++)
   {
    if (ppp_tableEntry[a][b] == NULL)
     break;

    for (c = 0; c < i_hperPage; c++)
    {
     if (((ppp_tableEntry[a][b][c].object ^ 0x80000000) & 0xfffffff8) == ((DWORD)tarHandle - 0x18))
     {
      //DbgPrint("Handle = %x Object Header %x Security %x\n", ((a*512)+(b*256)+c)*4, ((ppp_tableEntry[a][b][c].object | 0x80000000) & 0xfffffff8), ppp_tableEntry[a][b][c].security);
      ppp_tableEntry[a][b][c].object = 0;
      ppp_tableEntry[a][b][c].security = 0;
     }
    }
   
   }
  }
 }
}

PspCidTable에서 오브젝트를 지우는 함수 입니다.

먼저 다음과 같이 PspCidTable을 지우는 함수를 먼저 호출 합니다.

DWORD gcid_table;

gcid_table = GetPspCidTable();

DWORD
GetPspCidTable()
{
    PVOID pPspCidTable = NULL;
    ULONG i;
    UNICODE_STRING  usPsLookup;
    PUCHAR Buff;
   
    RtlInitUnicodeString( &usPsLookup, L"PsLookupProcessByProcessId" );
    Buff = MmGetSystemRoutineAddress( &usPsLookup );

    if( Buff != NULL )
    {   
        for( i = 0; i < 0x40; i++, Buff++ )
        {
            if( *(PUSHORT)(Buff) == 0x35ff && *((PUCHAR)Buff+6) == 0xe8 )
            {
                pPspCidTable = (PVOID)(*(PULONG)(Buff+2));
                break;
            }
        }
    }

    return (DWORD)pPspCidTable ? *(DWORD*)pPspCidTable : (DWORD)NULL;
}

 EraseObjectFromPspCidTable(gcid_table, (PVOID)MyProcess, 0,*((DWORD*)((DWORD)MyProcess+0x84)), 0 );

void EraseObjectFromPspCidTable(DWORD handle_table, PVOID tarHandle, enum ObjectType obj_type, DWORD pid, DWORD tid)
{
 PTABLE_ENTRY   orig_tableEntry, p_tableEntry, *pp_tableEntry, **ppp_tableEntry;
 int a, b, c;
 int i_numHandles, i_hperPage, i_numTables;
 int i_handle;

 i_numHandles = *(int*)(handle_table + 0x3c);
 orig_tableEntry = (PTABLE_ENTRY)*(PDWORD)(handle_table + 0);
 i_numTables = ((DWORD)orig_tableEntry & 3);

 i_hperPage = PAGE_SIZE/sizeof(TABLE_ENTRY);
 
 if (i_numTables == 0)
 {
 
//   DbgPrint("Found a single level handle table.\n");
  p_tableEntry = (PTABLE_ENTRY)((DWORD)orig_tableEntry & 0xfffffff8);
  for (a = 0; a < i_hperPage; a++)
  {
   if (((p_tableEntry[a].object | 0x80000000) & 0xfffffff8) == ((DWORD)tarHandle))
   {
//     DbgPrint("[%d]\n",a);
//     DbgPrint("Handle = %x Object %x Security %x\n", a*4, ((p_tableEntry[a].object | 0x80000000) & 0xfffffff8), p_tableEntry[a].security);
   
//     add_index(&g_PspCidTableList, SINGLE_LEVEL,obj_type,(DWORD)tarHandle,pid,tid, a,0, 0, p_tableEntry[a].object, p_tableEntry[a].security);
   
    p_tableEntry[a].object = 0;
    p_tableEntry[a].security = ((PHANDLE_TABLE)handle_table)->FirstFree;
    ((PHANDLE_TABLE)handle_table)->FirstFree = (ULONG)( (tid!=0) ? tid : pid );
   }
  }
 }
 else if (i_numTables == 1)
 {
//   DbgPrint("Found a two level handle table.\n");
  pp_tableEntry = (PPTABLE_ENTRY)((DWORD)orig_tableEntry & 0xfffffff8);
 
  for (a = 0; a < i_hperPage; a++)
  {
   if (pp_tableEntry[a] == NULL)
    break;

   for (b = 0; b < i_hperPage; b++)
   {
    //DbgPrint("Comparing %x to %x\n", ((pp_tableEntry[a][b].object | 0x80000000) & 0xfffffff8), tarHandle);
    if (((pp_tableEntry[a][b].object | 0x80000000) & 0xfffffff8) == ((DWORD)tarHandle))
    {
//      DbgPrint("[%d][%d]\n",a,b);
//      DbgPrint("Handle = %x Object %x Security %x\n", ((a*512)+b)*4, ((pp_tableEntry[a][b].object | 0x80000000) & 0xfffffff8), pp_tableEntry[a][b].security);
//      add_index(&g_PspCidTableList, DOUBLE_LEVEL,obj_type,(DWORD)tarHandle, pid,tid,  a,b, 0, pp_tableEntry[a][b].object, pp_tableEntry[a][b].security);

     pp_tableEntry[a][b].object = 0;
     pp_tableEntry[a][b].security = ((PHANDLE_TABLE)handle_table)->FirstFree;
     ((PHANDLE_TABLE)handle_table)->FirstFree = (ULONG)( (tid!=0) ? tid : pid );
    }
   }
   
  }
 }
 else if (i_numTables == 2)
 {
//   DbgPrint("Found a three level handle table.\n");
  ppp_tableEntry = (PPPTABLE_ENTRY)((DWORD)orig_tableEntry & 0xfffffff8);
  for (a = 0; a < i_hperPage; a++)
  {
   if (ppp_tableEntry[a] == NULL)
    break;

   for (b = 0; b < i_hperPage; b++)
   {
    if (ppp_tableEntry[a][b] == NULL)
     break;

    for (c = 0; c < i_hperPage; c++)
    {
     if (((ppp_tableEntry[a][b][c].object | 0x80000000) & 0xfffffff8) == ((DWORD)tarHandle))
     {
//       DbgPrint("Handle = %x Object %x Security %x\n", ((a*512)+(b*256)+c)*4, ((ppp_tableEntry[a][b][c].object | 0x80000000) & 0xfffffff8), ppp_tableEntry[a][b][c].security);
//       add_index(&g_PspCidTableList, TRIPLE_LEVEL,obj_type, (DWORD)tarHandle, pid,tid,  a,b, c, ppp_tableEntry[a][b][c].object, ppp_tableEntry[a][b][c].security);

      ppp_tableEntry[a][b][c].object = 0;
      ppp_tableEntry[a][b][c].security = ((PHANDLE_TABLE)handle_table)->FirstFree;
      ((PHANDLE_TABLE)handle_table)->FirstFree = (ULONG)( (tid!=0) ? tid : pid );
     }
    }
   
   }
  }
 }
}

HandleListEntry 해제하는 코드 입니다.

UnHookHandleListEntry((PEPROCESS)MyProcess);

void UnHookHandleListEntry(PEPROCESS eproc)
{
 PLIST_ENTRY plist_hTable = NULL;
 plist_hTable = (PLIST_ENTRY)((*(PDWORD)((DWORD) eproc + 0xc4)) +  0x1c);

 //DbgPrint("Unhooking the handle table of Process: %s\n", (DWORD)eproc+gul_ProcessNameOffset);
 *((DWORD *)plist_hTable->Blink) = (DWORD) plist_hTable->Flink;
 *((DWORD *)plist_hTable->Flink+1) = (DWORD) plist_hTable->Blink;

 //plist_hTable->Flink = (LIST_ENTRY *) &(plist_hTable->Flink); // Change the current LIST_ENTRY
 //plist_hTable->Blink = (LIST_ENTRY *) &(plist_hTable->Flink); // so we don't point to crap

}

프로세스에 속해 있는 스레드를 숨기는 코드 입니다.

if(gpeproc_csrss) HideThreadsInTargetProcess((PEPROCESS)MyProcess, gpeproc_csrss);


void HideThreadsInTargetProcess(PEPROCESS eproc, PEPROCESS target_eproc)
{
 PETHREAD start, walk;
 DWORD check1, check2;

 if (eproc == NULL)
  return;

 check1 = *(DWORD *)((DWORD)eproc + 0x50);
 check2 = ((DWORD)eproc + 0x50);
 // If check1 points back to the EPROCESS, there are no threads in the process.
 // It must be exiting.
 if (check1 == check2)
  return;

 start = *(PETHREAD *)((DWORD)eproc + 0x50);
 start = (PETHREAD)((DWORD)start - 0x1b0);
 walk = start;
 do
 {
  EraseHandle(target_eproc, walk);
  walk = *(PETHREAD *)((DWORD)walk + 0x1b0);
  walk = (PETHREAD)((DWORD)walk - 0x1b0);
 }while (walk != start);
}


 


지금 소개한 프로세스 숨기는 코드들만 사용하여도, 충분히 강력한 효과를 내실 수 있
을 것입니다. 하지만 꼭 명심하시기 바랍니다. DKOM을 사용할떄는 충분한 필드 테스트가
선행되어져야 한다는 것을...

여담이지만, 사실 이 글의 제목은 'Anti Game hacking 프로그램이 갖추어야할 기능들과
약점들.' 이었는데요. 글을 쓰다보니 -_-;; 필요한 기능과 코드만 다루어도 글의 길이가
꾀 길더군요. 그래서 두편으로 나누기로 결정을 하였습니다. 그럼 다음편에서는
Anti GH 프로그램의 약점과 그 대안에 대해서 알아보도록 하겠습니다.
이 글에서 잘못된 부분은 dual@null2root.org 로 알려주시거나, 이 글에 리플을 달아
주셔도 감사하겠습니다. 그럼 이만 (__)...

프로세스에서 메모리 패턴 검사 :

윈도우,클레스 목록에서 검사 :

이벤트,뮤텍스,파일맵 이름 검사 :

CRC 검사 :

참고 문헌 (?)
- 추후 추가 예정.

==============================================================================================================

출처 : 데브피아  : http://www.devpia.com/MAEUL/Contents/Detail.aspx?BoardID=51&MAEULNO=20&no=7806&page=2

'C/C++언어 > 후킹' 카테고리의 다른 글

Hooking 을 사용하는 프로그램 내의 구현  (0) 2007.11.11
Global Hooking in Win32  (0) 2007.11.11
[본문스크랩] 메세지 후킹  (0) 2007.09.06
[본문스크랩] Knowledge Base API  (0) 2007.09.06
API Hooking Revealed  (0) 2007.09.06
출처 : http://blog.naver.com/seamusic00/130009898000

Hooking 을 사용하는 프로그램 내의 구현

int FAR PASCAL InitHooksDll(HWND hMain);
int FAR PASCAL InstallHook();
int FAR PASCAL UnInstallHook();

ON_MESSAGE(WM_KEY_HOOK, OnSetFocus)   //사용자가 지정한 함수 Call

// Hook 사용하기 전  

 static HINSTANCE hinstDLL;
 typedef int (WINAPI *inithook)(HWND command);
 inithook initkbhook;
 hinstDLL = LoadLibrary((LPCTSTR) "Hook.dll");
 initkbhook = (inithook)GetProcAddress(hinstDLL, "InitHooksDll");
 initkbhook(this->m_hWnd);             //Dll Load
 typedef BOOL (CALLBACK *inshook)();
 inshook instkbhook;
 instkbhook = (inshook)GetProcAddress(hinstDLL, "InstallHook");
 instkbhook();                                //Hook Start

 //Hook 사용한 후  (프로그램 종료시)

 static HINSTANCE hinstDLL;
 typedef int (WINAPI *UnInhook)();
 UnInhook UnInkbhook;
 hinstDLL = LoadLibrary((LPCTSTR) "Hook.dll");
 UnInkbhook = (UnInhook)GetProcAddress(hinstDLL, "UnInstallHook");
 UnInkbhook();                                //Hook End

--------------------------------------------------------------------------------------

 실제 Hook dll

//공유 테이블
#pragma data_seg("SHARDATA")
static HWND hwndMain = NULL;
static HINSTANCE hInstance;
#pragma data_seg()

int FAR PASCAL InitHooksDll(HWND hMain);
//Hook의 init

int FAR PASCAL InstallHook();
//Hook Start

int FAR PASCAL UnInstallHook();
// Hook 해제

LRESULT CALLBACK KeyboardFunc(int nCode,WPARAM wParam,LPARAM lParam);
// 실제 후킹 담당

int CALLBACK InitHooksDll(HWND hMain)
{
      hwndMain = hMain;
      hInstance = theApp.m_hInstance;
      return 1;
}

int CALLBACK InstallHook()
{
      hHook = SetWindowsHookEx(WH_KEYBOARD,(HOOKPROC)KeyboardFunc,hInstance,0);
      //키가 눌리는 것을 후킹
      return 1;
}

  
int CALLBACK UnInstallHook()
{
      UnhookWindowsHookEx(hHook);
      return 1;
}

---------------------------------------------------------

// 실제 하는 작업 부분 (아래는 키보드 Hooking 이다)

LRESULT CALLBACK KeyboardFunc(int nCode,WPARAM wParam,LPARAM lParam)
{
      CString message;
      if(nCode >= 0)
      {
            if(wParam != VK_PROCESSKEY)

           {
                  char szTemp[100];
                  sprintf(szTemp, "wParam=%X, lParam=%X", wParam, lParam);
            }
 
           if(wParam == VK_HANJA)   //한자키를 누르면 Event를 발생시킨다.
           {  
                  HWND ProcB = FindWindow( NULL, "Program Name");
                  UINT uMsg;
                  uMsg = WM_KEY_HOOK;
                  if( ProcB )
                  { 
                        ::PostMessage(ProcB, uMsg, NULL ,NULL);
                  }
           }
     }
      return (CallNextHookEx(hHook,nCode,wParam,lParam));
}


신라호텔 프로그램 작업할 때 했던 Hooking

정보를 찾고 구현을하고 Test를 하면서 무척 재미있었다.. ㅋㅋ

이제서야 정리를 하네... >.<

'C/C++언어 > 후킹' 카테고리의 다른 글

Anti Game hacking 프로그램의 구현.  (0) 2008.01.17
Global Hooking in Win32  (0) 2007.11.11
[본문스크랩] 메세지 후킹  (0) 2007.09.06
[본문스크랩] Knowledge Base API  (0) 2007.09.06
API Hooking Revealed  (0) 2007.09.06
 Global Hooking in Win32
 ====================================================

 후크에는 두가지가 있다.
   Local Hook   - 하나의 스레드나 프로세스 안에서의 후킹
   Global Hook  - 전역 모든 윈도우들에 대한 후킹

 후크를 하기 위해서는 기본적으로 두가지 자료형을 알아야 한다.
   HHOOK - 후크 핸들  윈도우 시스템에서 한번 이벤트가
           발생하면 후크 체인의 첫 후크핸들에게 이벤트를
           넘긴다. 각 후크들은 다음 후크를 호출하여 후크체인에
           있는 모든 후크 프로시져를 호출하게 된다.
   HOOKPROC - 후크 프로시져로 후크시 호출되는 프로시져이다.
    LRESULT CALLBACK fnHookProc(int nCode, WPARAM wParam, LPARAM lParam)
    라는 자료형을 갖는다.

 1. 로컬 후킹
   SetWindowHookEx를 이용하면 간단히 구현이 가능하다.
   각 후크는 후크 타입이 있는데 아래와 같다.
      WH_CALLWNDPROC - 윈도우 메세지가 목적지로 전달되기 전에
                       메세지를 후크할때 쓴다 (SendMessage)
                       CallWndProc라는 후크프로시져명의 도움말 참조한다.
      WH_CALLWNDPROCRET - 윈도우 메세지가 목적지에 전달되어 처리
                          된 후 후크가 일어난다
                          CallWndRetProc함수명 도움말 참조
      WH_CBT - computer-based training (CBT) application 에 유용한
               후크 타입 CBTProc 함수 참조
      WH_DEBUG - 디버깅에 유용한 후크 DebugProc 참조
      WH_FOREGROUNDIDLE - Foreground상태있는 윈도우가 idle상태로 들어갈
                          때 생기는 후크 이는 idle시 낮은 우선순위
                          (low priority)를 줄때 유용하다 ForegroundIdleProc
      WH_GETMESSAGE - 메세지가 Post된 후 후크됨 (PostMessage)
                      GetMsgProc 함수 참조
      WH_JOURNALPLAYBACK - WH_JOURNALRECORD에 의해서 Record되기 전에
                           일어나는 후크 JournalPlaybackProc
      WH_JOURNALRECORD - Input message가 시스템 메세지 큐로 들어가는것을
                         Record하는 후크 JournalRecordProc
      WH_KEYBOARD - 등등이 있다.... -_- 도움말 참조..

 
 --------------------- 로컬 후크 예제 ------------------------------
    HHOOK hHook;
    HOOKPROC hProc;
              :
    hProc = CallWndProc;            // CallWndProc 후크 프로시져로 연결
    hHook = ::SetWindowsHookEx(     // 후크를 설치한다. ( 후크체인에 끼워넣는다 )
                 WH_CALLWNDPROC,    // WH_CALLWNDPROC 후크 설치
                 hProc,             // 후크차례가 오면 분기되는 콜백후크 프로시져
                 (HINSTANCE) NULL,  // 전역 후크가 아닌 로컬 후크임을 말한다
                 dwTreadID);        // 특정 스레드를 정한다 0 이면 현재 스레드


    만일 여러 스레드중 한 HWND가 속한 스레드를 얻고 싶으면
    DWORD    dwProcessID = NULL;
    DWORD    dwTreadID = ::GetWindowThreadProcessId( hWnd, &dwProcessID );

    if( dwProcessID )
    {
                 :
         후크 설치코드 맨 마지막인자에 dwThreadID를 넣으면 된다.    
    }

// 자세한 프로시져 도움말을 보면 자세히 알수 있다.
LRESULT WINAPI CallWndProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CWPSTRUCT* lpWp = (CWPSTRUCT*)lParam;
     //PMSG lpMsg = (PMSG)lParam;    
    if (nCode < 0 && hWnd == lpWp->hwnd )  // do not process message
        return CallNextHookEx(m_stHookCallProc.hHook, nCode, wParam, lParam);

    switch(  lpWp->message  )
    {
         case EM_REPLACESEL :
         TRACE("CallWndProc EM_REPLACESEL %s\r\n ", (char*)lpWp->lParam );
         break;

         default : 
         break;
    }   
    return CallNextHookEx(m_stHookCallProc.hHook, nCode,
        wParam, lParam);
}
 
2 전역 후킹
  전역 후킹을 하기 위해서는 후크 프로시져를 dll안에 넣어야 한다.
 


 --------------------- 전역 후크 예제 --------------------------

  testdll.dll 에서 ............

// dll에서 쓰는 자료는 dll공유를 했다.
// 이 후크 프로시져 dll은 내 프로그램에서 쓰이기도 하지만
// 시스템에 의해서 이 dll이 또 열리게 된다. ( dll의 참조카운트 증가
//  가 일어나지 않고 새로 dll이 생긴다. 따라서 두 dll은 자료가
//  분리되어 있는 셈이다. )
// 그러므로 부득이 하게 자료를 공유자료로 해야 한다.
#pragma data_seg(".shared")
    HHOOK             _hHook = NULL;
    HWND            _hTarget = NULL;
#pragma data_seg()
// 공유 자료로 했을 경우 아래처럼 링커 옵션도 주어야 한다.
#pragma comment(linker, "/SECTION:.shared,RWS")

// 자료 억세스 함수 마련...
extern "C" __declspec(dllexport) void fnSetHook( HHOOK hHook )
{
    _hHook = hHook;
}

extern "C" __declspec(dllexport) void fnSetHWND( HWND hWnd )
{
    _hTarget = hWnd;
    char szBuf[20];
    wsprintf( szBuf, "%lu", (ULONG)_hTarget );
    MessageBox( NULL, szBuf, "fnSetHWND당시의 _hTarget값", MB_OK);
}

extern "C" __declspec(dllexport) HHOOK fnGetHook()
{
    return _hHook;
}

// 콜백을 위한 CALLBACK 콜링컨벤션 키워드를 넣게 되면 나중에 GetAddressProc시
// NULL값을 리턴하므로 그냥 콜링컨벤션을 무시했다
//extern "C" __declspec(dllexport) LRESULT CALLBACK fnCallWndProc(int nCode, WPARAM wParam, LPARAM
lParam)
extern "C" __declspec(dllexport) LRESULT fnCallWndProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    CWPSTRUCT* lpWp = (CWPSTRUCT*)lParam;
     
    if( nCode >= 0  ) //&& _hTarget == lpWp->hwnd ) // do not process message
    { 
        switch(  lpWp->message  )
        {
        case EM_REPLACESEL :
            if( _hTarget == lpWp->hwnd )
            {
                MessageBox( NULL, "EM_REPLACESEL 메세지 발쌩", "메세지 발쌩in
dll", MB_OK);
            }
            break;

        default : 
            break;
        }   
    }
    return CallNextHookEx( _hHook, nCode, wParam, lParam);
}


 내 프로그램에서 .........................
HINSTANCE    hInstDll = NULL
HHOOK        hHook = NULL;

// dll을 연다.
hInstDll = LoadLibrary("TestDll.dll");
if( hInstDll )
{
    // 후크 프로시져를 찾아낸다.
    LRESULT (*hHookDllProc)(int, WPARAM, LPARAM ) = (LRESULT (*)(int, WPARAM, LPARAM ))
GetProcAddress(hInstDll, "fnCallWndProc");
    if( hHookDllProc ) // 있으면 후크를 설치한다.
        hHook = SetWindowsHookEx( WH_CALLWNDPROC, (HOOKPROC)hHookDllProc, hInstDll, 0);
   
        // dll내의 자료를 세팅한다. HHOOK와 HWND 값 세팅
    void (*lpfnSetHook)(HHOOK) = (void (*)(HHOOK))GetProcAddress(hInstDll, "fnSetHook");
    if( lpfnSetHook )
        (*lpfnSetHook)( hHook );
        void (*lpfnSetHWND)(HWND) = (void (*)(HWND))GetProcAddress
(hInstDll, "fnSetHWND");
    if( lpfnSetHWND )
        (*lpfnSetHWND)( m_hTarget );
}



출처 : http://blog.naver.com/heroyik/14775896

따라해보는 후킹

작성자 : 이은규

작성일 : 2003.11.02

홈페이지 : http://unkyulee.net

 

목차

1. 들어가는 글

2. 후킹이란?

3. 후킹 프로시져를 만들어 보자.

4. 후킹 프로시져를 시작, 종료하는 함수

5. 프로시져 내에서 다른 윈도우로 데이터 전송하기

6. 간단한 샘플 프로그램

 


1. 들어가는 글

 

 "그냥 실행되는 걸 보고 싶었다."

 

 예전에 했던 프로젝트의 내용 중에 사용자가 키보드로 입력하는 내용을 얻어와서 처리해야 되는 부분이 있었다. 이러한 기능을 구현하기 위해서는 후킹 이라는 기술을 사용해야 한다. 그래서 관련된 내용을 인터넷에서 찾아봤는데, 왜 이렇게 알아야 되는 내용이 많은지… 또 내용들은 어찌나 어렵던지… 후킹 구현한답시고 한달 내내 문서 읽고 인터넷 뒤지고 엄청 고생 했었다. 결국 간단한 샘플 코드를 구해서 원하는 기능을 구현 했던 기억이 있다.

 

 프로젝트 내에서 그리 중요한 부분도 아니였고, 그냥 호기심에 후킹이라는 걸 실제로 구현해보고 싶었던 것 뿐이였는데, 정말 어렵게 공부했던 것 같다.

 

 이 강좌는 순전히 호기심으로 혹은 그냥(?) 한번 후킹을 실제로 구현해 보고자 하는 사람들을 대상으로 한다. 후킹에 대한 자세한 이론은 대부분 생략할 예정이다. 대신에 이 강좌를 다 읽고 나면 후킹을 사용한, 일단 돌아가는 코드를 작성 할 수 있을 것이다.

 

 일단 돌아가는 코드를 작성하고 나면, 그 외의 내용을 익히는 것은 시간 문제일 뿐이지 않을까 생각한다. ^0^)

 


2. 후킹이란?

 

 "후킹은 도청하는 걸 예로 들면 쉽게 이해할 수 있다."

 

 후킹이란 다른 프로세스에 걸려서(Hooked) 해당 프로세스의 정보를 얻어 오거나, 변경하는 것이 가능한 기술이다. 여기서 프로세스란 좁게 봐서 "윈도우 프로시져" 혹은 "윈도우 메시지" 라고 생각하면 되겠다.

 

 예를 들어 보자. 한 아파트 건물이 있다고 하자. 그리고 이 건물을 도청하고 싶다. 그럼 전화선들이 지나가는 곳(Window Process) 에 도청 장치(후킹 프로시져)를 설치한다. 그럼 도청장치 사이로 전화 내용들이(Window Message) 지나간다. 도청 장치는 그 중 필요한 메시지를 저장하고 있거나, 필요한 곳으로 전송한다.

 

 위의 과정들에 의해서 빌딩은 도청을 당한다. 그럼 실제 후킹의 경우를 살펴보자. 일단 윈도우 메시지(전화 내용)를 후킹 한다고 하면 윈도우 메시지를 발생시키는 곳(전화선들이 지나가는 곳)에 후킹 프로시져(도청 장치)를 설치한다. 그럼 해당 윈도우에서 발생하는 메시지가 후킹 프로시져를 거쳐가게 된다. 그럼 후킹 프로시져는 메시지들을 보고 필요한 내용을 저장하던지 필요한 곳에 전달을 하면 되는 것이다.

 

 그림 한번 보자. 위 그림은 Ivo Ivanov 라는 사람이 쓴 API Hooking Reveal 라는 문서에서 퍼 가지고 왔다. 그림을 보면 Hook Driver 라는 것들이 3개가 보인다. 그림에서 현재 윈도우가 3 개가 떠있는데 각각의 윈도우에 하나씩 Hook Driver 가 붙어 있는 모양이다. 따라서 이 드라이버(후킹 프로시져) 들이 각각의 윈도우에서 오는 메시지들을 받을 수가 있는 것이다.

 

 뭔가 굉장히 많아 보인다. 하지만 결국 개발자가 만들어 주는 것은 후킹 프로시져 하나이다.

 

 여기서 키포인트는 특정 위도우가 받는 메시지를 후킹 프로시져도 받을 수 있다는 것이다. 이런 기술을 바로 후킹이라고 한다.

 

 


3. 후킹 프로시져를 만들어 보자.

 

 "이론은 끝났다. 이제 만들어 보자."

 

 후킹 프로시져… 아까부터 프로시져라는 단어가 계속 나오는데 결국 프로시져는 함수와 그 의미가 비슷하다. 따라서 후킹 프로시져라고 함은 후킹을 하는 함수라고 생각하자. 따라서 후킹 프로시져를 만든다는 것은 함수를 하나 만든다고 생각하면 된다.

 

 후킹 함수를 만들기 위해서는 지켜야 하는 규칙들이 있다.

1. Call Back 함수이여야 한다.

2. 함수의 마지막 부분에서는 CallNextHookEx() 함수를 호출한다.

3. 함수가 받는 인자는 정해져 있다.

4. 후킹 프로시져는 DLL 안에 있어야 한다.

 

Ex)

//--------------------------------------------------------------

// Hook Procedure - Keyboard

//--------------------------------------------------------------

LRESULT CALLBACK KeyboardProcedure(int nCode, WPARAM wParam, LPARAM lParam)

{

             if( nCode >= 0 )

             {

            

             }

             // We must pass the all messages on to CallNextHookEx.

           return ::CallNextHookEx( g_Hook , nCode , wParam , lParam );

}

 

 위의 규칙들을 지켜서 만든 후킹 프로시져 함수이다.

 

 4번째 규칙에 의하면 후킹 함수는 DLL 내부에 있어야 한다. Visual C++ 6.0 에서 DLL 프로젝트를 하나 만들어 보자.

 

Step 1. Win32 Dynamic-Link Library 프로젝트 생성

Step 2. Simple 프로젝트 선택 후 Finish

Step 3. cpp 파일에 위의 후킹 함수를 만들어 준다.

 

위의 프로젝트를 컴파일 하면 HookDll.dll 파일이 생성된다.

 

전체 프로젝트 파일 내용

// HookDll.cpp : Defines the entry point for the DLL application.

//

 

#include "stdafx.h"

 

BOOL APIENTRY DllMain( HANDLE hModule,

                       DWORD  ul_reason_for_call,

                       LPVOID lpReserved

                                                                   )

{

    return TRUE;

}

 

//--------------------------------------------------------------

// Hook Procedure - Keyboard

//--------------------------------------------------------------

LRESULT CALLBACK KeyboardProcedure(int nCode, WPARAM wParam, LPARAM lParam)

{

             if( nCode >= 0 )

             {

                          

             }

             // We must pass the all messages on to CallNextHookEx.

             return ::CallNextHookEx( g_Hook , nCode , wParam , lParam );

}

 

 

 


4. 후킹 프로시져를 시작, 종료하는 함수

 

 이번 단계에서는 앞서 만든 후킹 프로시져를 설치하고, 제거하는 함수를 만들어 보겠다. 후킹 프로시져는 특정 윈도우에 설치가 되어야 제 역할을 할 수 있게 된다. 이때 후킹 프로시져를 설치해주는 함수가 바로 SetWindowsHookEx() 이다. 그 다음에 설치된 후킹 프로시져를 제거하기 위해서는 UnhookWindowsHookEx() 가 쓰이게 된다. 각각의 사용법을 알아보고 앞에서 만든 프로젝트에 이어서 적용시켜 보자.

 

SetWindowsHookEx()의 사용법

HHOOK SetWindowsHookEx(

    int idHook,

    HOOKPROC lpfn,

    HINSTANCE hMod,

    DWORD dwThreadId

);

 

 첫번째 패러메터는 후킹 필터를 설정한다. 후킹 프로시져가 받은 메시지의 종류를 설정하는 항목이다. 예를 들어 WH_GETMESSAGE로 설정하면 모든 메시지를 받게 되고, WH_KEYBOARD로 설정하게 되면 키보드 관련 메시지만 전달 받게 된다. 더 자세한 내용은 MSDN 을 참고하기 바란다.

 

 두번재 패러메터는 후킹 프로시져의 포인터를 지정해야 한다. 간단하게 후킹 프로시져 함수 이름 써주면 된다.

 

 세번째 패러메터는 DLL 의 핸들을 넘겨줘야 된다. 이 값은 앞에서 만든 프로젝트에서 DLlMain() 함수를 보면 HANDLE hModule 값이 넘어오는데 이걸 저장 해놨다가 넘겨주면 된다.

 

 네번째 패러메터는 후킹 프로시져를 설치할 윈도우 값을 넘겨준다. 이번 예에서는 0 을 넘겨준다. 0 을 넘겨주면 후킹 프로시져가 모든 윈도우에 설치가 된다.

 

 이 함수가 리턴하는 값을 잘 저장 해 놓자. 나중에 후킹을 해제할 때 필요하게 된다.

 

Ex) g_HookKeyboard = SetWindowsHookEx( WH_KEYBOARD , KeyboardProcedure , (HINSTANCE)g_Module , 0 ) ;

 

UnhookWindowsHookEx() 의 사용법

 

BOOL UnhookWindowsHookEx(         

             HHOOK hhk

);

 

 이 함수는 후킹 핸들을 받아서 해당 후킹 프로시져를 해제한다. 이때 받는 핸들은 SetWindowsHookEx() 함수가 리턴한 값을 넣어주면 된다.

 

 

프로젝트를 계속 진행 해보자.

 

1. 필요한 전역 변수를 만들어 준다.

//---------------------------------------------------

// Global Variables

// 공용 메모리

//---------------------------------------------------

#pragma data_seg(".HKT")

HINSTANCE g_Module = NULL ;     // DLL Handle

HHOOK g_Hook = NULL ;  // Hook Handle

HWND g_HwndServer = NULL ;      // Hook Server Window Handle

#pragma data_seg()

 

 

2. SetHook, Remove 이라는 함수를 만든다.

//------------------------------------------------------------------// Set Hook

//------------------------------------------------------------------BOOL     SetHook( HWND hWnd )

{

             g_HwndServer = hWnd ;                // Set Hook Server

             g_Hook = SetWindowsHookEx( WH_KEYBOARD , KeyboardProcedure , (HINSTANCE)g_Module , 0 ) ;

             return false ;

}

 

//------------------------------------------------------------------// Remove Hook

//------------------------------------------------------------------BOOL     RemoveHook()

{

             UnhookWindowsHookEx( g_Hook ) ;

             return false;

}

 

 

// HookDll.def 파일 부분

LIBRARY   HookDll

 

SECTIONS

             .HKT   Read Write Shared

 

EXPORTS

             SetImeWindow                 @1

             SetHook                                        @2

             RemoveHook                                 @3

 

 

 

3.. 위의 함수와 전역 변수의 세팅을 위한 [프로젝트명].def 파일을 만들어 준다.

LIBRARY   [프로젝트명]

 

SECTIONS

             .HKT   Read Write Shared

 

EXPORTS

             SetHook                                        @2

             RemoveHook                                 @3

 

 

4. DllMail 함수에서 핸들을 저장한다.

//------------------------------------------------------------------// DllMain : Entry point

//------------------------------------------------------------------BOOL APIENTRY DllMain( HANDLE hModule,

                       DWORD  ul_reason_for_call,

                       LPVOID lpReserved

                                                                   )

{

             switch (ul_reason_for_call)

             {

             case DLL_PROCESS_ATTACH:

                           g_Module = (HINSTANCE)hModule; // Save Dll Handle

                           break;

 

             case DLL_PROCESS_DETACH:

                           RemoveHook();

                           break;

    }

 

    return TRUE;

}

 

 

전체 프로젝트 파일

 

1. HookDll.cpp

// HookDll.cpp : Defines the entry point for the DLL application.

//

 

#include "stdafx.h"

 

//---------------------------------------------------

// Global Variables

// 공용 메모리

//---------------------------------------------------

#pragma data_seg(".HKT")

HINSTANCE g_Module = NULL ;     // DLL Handle

HHOOK g_Hook = NULL ;  // Hook Handle

HWND g_HwndServer = NULL ;      // Hook Server Window Handle

#pragma data_seg()

 

BOOL    RemoveHook() ;

BOOL    SetHook( HWND hWnd ) ;

 

//------------------------------------------------------------------

// DllMain : Entry point

//------------------------------------------------------------------

BOOL APIENTRY DllMain(

                                                                                HANDLE hModule,

                                                                                DWORD  ul_reason_for_call,

                                                                                LPVOID lpReserved

                                                                  )

{

             switch (ul_reason_for_call)

             {

             case DLL_PROCESS_ATTACH:

                           g_Module = (HINSTANCE)hModule; // Save Dll Handle

                           break;

                          

             case DLL_PROCESS_DETACH:

                           RemoveHook();

                           break;

    }

            

    return TRUE;

}

 

//--------------------------------------------------------------

// Hook Procedure - Keyboard

//--------------------------------------------------------------

LRESULT CALLBACK KeyboardProcedure(int nCode, WPARAM wParam, LPARAM lParam)

{

             if( nCode >= 0 )

             {

                          

             }

             // We must pass the all messages on to CallNextHookEx.

             return ::CallNextHookEx( g_Hook , nCode , wParam , lParam );

}

 

//------------------------------------------------------------------

// Set Hook

//------------------------------------------------------------------

BOOL    SetHook( HWND hWnd )

{

             g_HwndServer = hWnd ;                // Set Hook Server

             g_Hook = SetWindowsHookEx( WH_KEYBOARD , KeyboardProcedure , (HINSTANCE)g_Module , 0 ) ;

            

             return false ;

}

 

//------------------------------------------------------------------

// Remove Hook

//------------------------------------------------------------------

BOOL    RemoveHook()

{

             UnhookWindowsHookEx( g_Hook ) ;

             return true ;

}

 

 

2. HookDll.def 파일

LIBRARY   HookDll

 

SECTIONS

.HKT   Read Write Shared

 

EXPORTS

SetHook                                        @2

RemoveHook                                 @3

 

 

프로젝트를 컴파일 하면 HookDll.lib 와 HookDll.dll 파일이 생성이 된다.


5. 프로시져 내에서 다른 윈도우로 데이터 전송하기

 

 이번에는 앞서 만든 후킹 프로시져를 좀더 강화해보기로 하자. 후킹 프로시져 내에서 메시지를 받고 받은 메시지를 복사하여 특정 윈도우에게 보낼 것이다.

 

 이때 WM_COPYDATA 메시지를 생성 할 것이다.

 

1. WM_COPYDATA 로 보낼 데이터의 구조를 정의한다.

// 메시지를 저장하는 구조체

typedef struct

{

             int                       Type ;

             WPARAM            Data ;

             LPARAM              lParam ;

} HEVENT;

 윈도우 메시지의 내용을 저장할 구조체

 

 

2. 현재의 메시지를 복사한다.

COPYDATASTRUCT  CDS;

HEVENT          Event;

 

// Set CDS

CDS.dwData = 0 ;

CDS.cbData = sizeof(Event);

CDS.lpData = &Event;

 

// 메시지의 내용을 저장한다.

Event.Type = 1 ;               // It's WM_KEY..

Event.Data = wParam ;     // Send CharCode

Event.lParam = lParam ;

 

 

3. g_HwndServer 에게로 메시지를 전달한다.

// g_HwndServer  에게로 메시지를 날린다.

// g_HwndServer 는 SetHook 함수 호출시 저장한 윈도우 핸들이다.

::SendMessage( g_HwndServer , WM_COPYDATA , 0 , (LPARAM)(VOID*)&CDS ) ;

 

 

 

프로젝트를 계속 진행 해보자.

 

1. 앞선 프로젝트의 내용 중 KeyboardProcedure() 함수의 내용을 수정한다.

 

//------------------------------------------------------------------

// Hook Procedure - Keyboard

//------------------------------------------------------------------

LRESULT CALLBACK KeyboardProcedure(int nCode, WPARAM wParam, LPARAM lParam)

{

             if( nCode >= 0 )

             {

                           // Send To HookServer

                           COPYDATASTRUCT  CDS;

                           HEVENT          Event;

                           // Set CDS

                           CDS.dwData = 0 ;

                           CDS.cbData = sizeof(Event);

                           CDS.lpData = &Event;

                           // Set Variables

                           Event.Type = 1 ;               // It's WM_KEY..

                           Event.Data = wParam ;     // Send CharCode

                           Event.lParam = lParam ;

                          

                            ::SendMessage( g_HwndServer , WM_COPYDATA , 0 , (LPARAM)(VOID*)&CDS ) ;    

             }

 

             // We must pass the all messages on to CallNextHookEx.

             return ::CallNextHookEx( g_Hook , nCode , wParam , lParam );

}

 

 

2. Event 구조체를 정의 해준다.

typedef struct

{

             int                       Type ;

             WPARAM            Data ;

             LPARAM              lParam ;

} HEVENT;


6. 간단한 샘플 프로그램

 

 지금까지 만들어 본 후킹 프로시져를 가지고 실제로 샘플 프로그램을 작성해보자.

 

 

1. 프로젝트를 생성한다.

             - MFC 다이얼로그

 

2. 위의 프로젝트를 컴파일 하면 HookDll.lib 와 HookDll.dll 파일이 생성이 된다. 이 파일을 새롭게 생성할 프로젝트 폴더에 복사한다.

 

3. 프로젝트를 세팅한다.

             - 메뉴에서 Project -> Setting -> Link 탭에서 Object/Modules Library 칸에 HookDll.lib 를 지정한다.

 

 

 

4 . 다이얼로그를 위의 모양같이 만들어 주고

에디트 컨트롤을 생성하고 다음과 같이 변수를 연결해준다..

 

ID : IDC_EDIT_CNT

Value : m_Cnt

Type : int


5. 클래스 위저드로 WM_COPYDATA 메시지 핸들러를 생성한다.

BOOL CHookTestDlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)

{

             // TODO: Add your message handler code here and/or call default

            

             // WM_COPYDATA 메시지가 올때마다 카운트를 증가한다.

             m_Cnt++ ;

             UpdateData( false ) ;

 

             return CDialog::OnCopyData(pWnd, pCopyDataStruct);

}

 

위와 같이 수정해준다.

 

6. DLL 에 있는 함수를 사용하기 위해 헤더 파일에 다음을 추가한다.

BOOL    RemoveHook() ;

BOOL    SetHook( HWND hWnd ) ;

 

 

7. InitDialog() 함수에서 SetHook() 함수를 호출한다.

BOOL CHookTestDlg::OnInitDialog()

{

             CDialog::OnInitDialog();

 

             // Add "About..." menu item to system menu.

 

             // IDM_ABOUTBOX must be in the system command range.

             ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);

             ASSERT(IDM_ABOUTBOX < 0xF000);

 

             CMenu* pSysMenu = GetSystemMenu(FALSE);

             if (pSysMenu != NULL)

             {

                           CString strAboutMenu;

                           strAboutMenu.LoadString(IDS_ABOUTBOX);

                           if (!strAboutMenu.IsEmpty())

                           {

                                        pSysMenu->AppendMenu(MF_SEPARATOR);

                                        pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);

                           }

             }

 

             // Set the icon for this dialog.  The framework does this automatically

             //  when the application's main window is not a dialog

             SetIcon(m_hIcon, TRUE);                           // Set big icon

             SetIcon(m_hIcon, FALSE);                          // Set small icon

            

             // TODO: Add extra initialization here

             SetHook( this->GetSafeHwnd() ) ; // 후킹 프로시져 설치

            

             return TRUE;  // return TRUE  unless you set the focus to a control

}

 

자 이제 실행하면 키보드를 칠 때마다 카운트가 증가하는 프로그램이 완성이 되었다

'C/C++언어 > 후킹' 카테고리의 다른 글

Hooking 을 사용하는 프로그램 내의 구현  (0) 2007.11.11
Global Hooking in Win32  (0) 2007.11.11
[본문스크랩] Knowledge Base API  (0) 2007.09.06
API Hooking Revealed  (0) 2007.09.06
동적 API 후킹의 구조  (0) 2007.09.06

출처: http://blog.daum.net/wooyoung

www.debuglab.com 에서 있는 자료들입니다.


이 자료를 정리하신 분은 서우석이라는 분인데..정말 대단하다라는 생각이 듭니다.

어쩜 이렇게 정리를 잘 하셨을까.. 부럽다는 생각만 드는군요..ㅡㅡ



-------------------------------------------------------------------

Home


lastest update : 2001.08.06




'C/C++언어 > 후킹' 카테고리의 다른 글

Hooking 을 사용하는 프로그램 내의 구현  (0) 2007.11.11
Global Hooking in Win32  (0) 2007.11.11
[본문스크랩] 메세지 후킹  (0) 2007.09.06
API Hooking Revealed  (0) 2007.09.06
동적 API 후킹의 구조  (0) 2007.09.06

+ Recent posts