'소스' 태그의 글 목록 (4 Page)

// 하앍 include 가 넘 많다...
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <errno.h>

#define EPOLL_SIZE 60
#define EPOLL_EVENT_SIZE 100
#define OPENPORT 5000

// main
int
main (int argc, char **argv)
{
struct epoll_event *events;
struct epoll_event ev;
struct sockaddr_in addr, clientaddr;
int clilen;
int sfd, efd, cfd;
int i;
int max_got_events;
int result;
int readn;
int sendflags = 0;
char buf_in[256] = { '\0' };

if ((efd = epoll_create (EPOLL_EVENT_SIZE)) < 0)
{
perror ("epoll_create (1) error");
return -1;
}

// init pool
events = (struct epoll_event *) malloc (sizeof (*events) * EPOLL_SIZE);
if (NULL == events)
{
perror ("epoll_create (0) error");
return -1;
}

clilen = sizeof (clientaddr);
sfd = socket (AF_INET, SOCK_STREAM, 0);
if (sfd == -1)
{
perror ("socket error :");
close (sfd);
return -1;
}

addr.sin_family = AF_INET;
addr.sin_port = htons (OPENPORT);
addr.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (sfd, (struct sockaddr *) &addr, sizeof (addr)) == -1)
{
close (sfd);
return -2;
}
listen (sfd, 5);

if (sfd < 0)
{
perror ("init_acceptsock error");
return 1;
}

printf("Running Server port %d\n",port);
ev.events = EPOLLIN;
ev.data.fd = sfd;
result = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &ev);
if (result < 0)
{
perror ("epoll_ctl error");
return 1;
}

while (1)
{
max_got_events = epoll_wait (efd, events, EPOLL_SIZE, -1);
for (i = 0; i < max_got_events; i++)
{
if (events[i].data.fd == sfd)
{
printf("Accepted\n");
cfd = accept (sfd, (struct sockaddr *) &clientaddr, &clilen);
if (cfd < 0)
{
perror ("Accept error");
return -1;
}

ev.events = EPOLLIN;
ev.data.fd = cfd;
epoll_ctl (efd, EPOLL_CTL_ADD, cfd, &ev);
}
else
{
cfd = events[i].data.fd;

memset (buf_in, 0x00, 256);
readn = read (cfd, buf_in, 255);
// if it occured ploblems with reading, delete from epoll event pool and close socket
if (readn <= 0)
{
epoll_ctl (efd, EPOLL_CTL_DEL, cfd, &ev);
close (cfd);
printf ("Close fd ", cfd);
}
else
{
printf ("%s", buf_in);
send (cfd, buf_in, strlen (buf_in), sendflags);
}

}
}
}
return 1;
}

'리눅스 서버에 대해서' 카테고리의 다른 글

Epoll 채팅 서버 소스 (0)	2008.05.25
Select 채팅 서버 (0)	2008.05.25
쓰레드 에코서버 (0)	2008.05.25
epoll 서버 프로그래밍 (0)	2008.03.29
겜서버 숙제 (0)	2008.03.24

epoll 리눅스에서 다루는 이벤트 통지형 서버 구조임.
Win32로 따지면 WSAEventSelect 모델 정도로 볼수 있을것이다.
Win32에선 WSAEventSelect를 더욱 개선한 Overlapped 모델을 지원하지만 실제 Overlapped 모델은 윈도우 컨디션에 따라 성능을 제대로 보장하지 못한다고 한다.
하여튼..
http://twopairs.tistory.com/101 사이트에 의하면

c epoll vs java epoll vs java poll

korean

test machine : linux, mem 2G, 2cpu
server's business logic is echo, client send 1 request per 5 second and
data volumn is less then 1k.

result :

c epoll server
when 30000 socket is running
CPU 6-12%
there aren't special phenomenon.

java epoll server
In 30000 socket is running
CPU 10-17%
there aren't special phenomenon.

java poll server
In 3000 socket is running
cpu reach near 100%
In 10000 socket is running
listen socket accept connection but cpu reach 100%...

conclusion :
epoll is fantastic
음.. 하여간 epoll 이면서 c언어로 해야한다.

서버는 c++을 사용하지 않는데 그 이유로는.. class를 생성하면서 메모리 관리가 복잡해지기 때문이다.
그리고. 직관적으로 짜지 않으면 워낙 많은 변수로 안전성이 떨어진다. ㅡ_ㅡ..

잡스 형님의 말씀 처럼 Simple is best 인 코드는 서버 코드가 아닐까 생각된다.

이제 본론에 들어가서 epoll 서버 샘플 프로그래밍이다. 출처는 아래와 같다.

출처 : http://www.xevious7.com/archive/200704

epoll 서버 샘플 프로그래밍

프로그래밍/서버프로그래밍 2007/04/18 10:19

epoll 서버 샘플 프로그래밍 by xevious7 http://www.xevious7.com/52
(문서의 작성일. 2006.5월9일)
(문서의 수정및 추가 2007년 4월)

거의 1년여전에 이 문서를 작성해놓고 실수로 공개를 안하고 있었습니다.
계속 비공개문서로 있었던 것이죠. 아마도 무슨 바쁜일 때문에 미처 공개하지
못하고 다른 문서들로 인하여 계속 비공개로 남아있었던 것 같습니다.
최근에 epoll에 대한 것을 테스트하다가 뒤늦게 문서가 비공개로 되어있는
것을 알았습니다. 그래서 내용도 조금 수정하고 테스트서버도 작성해보았습니다.
소스도 공개합니다.

epoll을 이용하여 작성된 완성된 훌륭한 서버소스가 많이 공개되어있지만 ,
일반적으로 공부하려는 프로그래머가 그 큰 소스의 내부를 분석하여
이해하기는 좀 무리가 있다고 생각이 듭니다.

아무래도 잘 짜여지고 다듬어지다보니
보다 추상화가 많이 되어있고 보다 감싸져있기 때문에 쓰기는 편해도 이해하기는
힘들다고 할까요.

직관적으로 이해를 돕기 위해서 , 여기 공개하는 epoll응용
테스트서버는 C언어로 작성하였습니다. 단순한 에코형서버입니다.
접속한 모든 클라이언트에게 내용을 전달합니다. 두 클라이언트가 접속하면
서로 채팅하는것이 될것이고 여러클라이언트가 붙으면 대화방처럼 작동합니다.

여기에 간단한 프로토콜을 넣으면 (채널관리 ,룸관리) 간단한 채팅서버가
될것입니다.

다시 말하면 이해를 위한 뼈대구조의 하나의 샘플입니다.

소스코드가 매끄럽지 못합니다. 다만 직관적 이해를 위해 코드를 압축하거나
추상화하는 것은 자제했습니다.

관련링크

http://www.joinc.co.kr/modules/moniwiki/wiki.php/epoll
윗글은 epoll의 제작자가 만든 원래의 URL에(man페이지) 대한 번역과
이 링크에도 간단한 에코서버소스가 공개되어있습니다.

epoll 제작자의 글은 다음 URL에 있습니다.
http://www.xmailserver.org/linux-patches/epoll.txt

대용량 서버에 대한 방법론에 대한것은 다음문서
http://www.kegel.com/c10k.html 에서 자세히 볼 수 있습니다.

epoll을 사용하기위한 조건

epoll은 2001년 7월 11일에 다비드 라이프니치(David Libenzi)씨에 의해서
리얼타임 시그날 (RealTime Sinal)의 대안으로 제안된 이후로 2.5.x 커널에 추가되기
시작하였습니다.

그리고 2.6.x 커널대에서는 기본으로 탑재되어 있습니다.

(2.6.x 커널은 2003년 12월에 릴리즈 되었습니다. 현재까지(2007년3월) 계속되고 있습니다.)
9.x 대 리눅스라면 epoll을 사용하는데 전혀 무리가 없다는 이야기입니다.
만약 2.6.x 커널 및의 리눅스라면 위의 joinc 문서에서 사용여부 가능방법과 라이브러리
등의 설치등등의 확인 방법이 설명되어있으니 참조하기 바랍니다.

자신의 리눅스 시스템에서 epoll이 사용가능한지 체크하는 C 코드

#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>

int main(int argc, char** argv)
{
   int epoll_fd;

if ( (epoll_fd = epoll_create(500)) == -1 )
   {
   printf("epoll 파일디스크립터 생성 오류 \n");
}
   else
   {
   printf("epoll 파일디스크립터 생성성공 \n");
close(epoll_fd);
/* 생성된 fd는 다른 fd와 마찬가지로 프로그램 종료전에 반드시 닫아주어야한다. */
   }
}
/* EOF */

컴파일이 안되거나 , 실행시 오류가 난다면 무엇인가 설정이 잘못되어있는 것입니다.

epoll 을 사용하기 위한 API

epoll을 사용하기 위해서 알아야 될 API는 다음 세가지입니다.
int epoll_create(int size);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

함수의 각각의 설명은 man페이지나 제작자의 다음 링크에서 볼 수 있습니다.
http://www.xmailserver.org/linux-patches/epoll_create.txt
http://www.xmailserver.org/linux-patches/epoll_ctl.txt
http://www.xmailserver.org/linux-patches/epoll_wait.txt

한글번역문서는 jacking님의 일본man 페이지 번역이 다음링크에 있습니다.
http://jacking75.cafe24.com/Network/epoll.htm

위의 각각의 3개의 API의 이해가 소스를 이해하는데 필수적입니다. 당연한
이야기이지만요.

소스는 epoll LT모드를 사용하고있습니다. ( ET를 선언하지 않은경우
자동으로 LT입니다. 소스에 LT를 따로 선언하지 않았습니다.)
ET모드는 socket이 반드시 non blocking 소켓이어야 하지만 LT는
상관없습니다. 그래서 따로 non blocking 부분을 설정하는 부분이 없고
소켓 그대로 사용하였습니다. 또한 닫혀진 소켓에 대한 epoll set에서
삭제하는 부분도 없습니다. 이부분은 epoll 제작자의 FAQ에서 보면
닫힌 소켓에대해서 epoll set에서 자동으로 없어지는가 하는 질문에
닫힌 소켓은 자동으로 epoll set에서 없어진다라고 되어있기 때문에
따로 처리하지 않았습니다. 소켓이 닫히는순간 epoll set에서 사라집니다.

주석은 영어로 되어있습니다. ^^;;

테스트서버 소스
/*-----------------------------------------------------------------

epoll server test program by EuiBeom Hwang. : 2005-2007.
Platform : Linux 2.6.x (kernel)
compiler Gcc: 3.4.3.
License: GNU General Public License
descption : simple test server. multi client accept.
sample skelecton epoll structure(conceptional)
this code is just sample implemention code.
------------------------------------------------------------------*/

/* header files */
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>

/* definition */
#define MAX_CLIENT 10000
#define DEFAULT_PORT 9006
#define MAX_EVENTS 10000

/* global definition */
int g_svr_sockfd; /* global server socket fd */
int g_svr_port; /* global server port number */

struct {
int cli_sockfd; /* client socket fds */
char cli_ip[20]; /* client connection ip */
} g_client[MAX_CLIENT];

int g_epoll_fd; /* epoll fd */

struct epoll_event g_events[MAX_EVENTS];

/* function prototype */
void init_data0(void); /* initialize data. */
void init_server0(int svr_port); /* server socket bind/listen */
void epoll_init(void); /* epoll fd create */
void epoll_cli_add(int cli_fd); /* client fd add to epoll set */

void userpool_add(int cli_fd,char *cli_ip);

/*--------------------------------------------------------------*/
/* FUNCTION PART
---------------------------------------------------------------*/

/*---------------------------------------------------------------
function : init_data0
io: none
desc: initialize global client structure values
----------------------------------------------------------------*/
void init_data0(void)
{
register int i;

for(i = 0 ; i < MAX_CLIENT ; i++)
{
g_client[i].cli_sockfd = -1;
}
}

/*-------------------------------------------------------------
function: init_server0
io: input : integer - server port (must be positive)
output: none
desc : tcp/ip listening socket setting with input variable
----------------------------------------------------------------*/

void init_server0(int svr_port)
{
struct sockaddr_in serv_addr;

/* Open TCP Socket */
if( (g_svr_sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0 )
{
printf("[ETEST] Server Start Fails. : Can't open stream socket \n");
exit(0);
}

/* Address Setting */
memset( &serv_addr , 0 , sizeof(serv_addr)) ;

serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(svr_port);

/* Set Socket Option */
int nSocketOpt = 1;
if( setsockopt(g_svr_sockfd, SOL_SOCKET, SO_REUSEADDR, &nSocketOpt, sizeof(nSocketOpt)) < 0 )
{
printf("[ETEST] Server Start Fails. : Can't set reuse address\n");
close(g_svr_sockfd);
exit(0);
}

/* Bind Socket */
if(bind(g_svr_sockfd,(struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
   printf("[ETEST] Server Start Fails. : Can't bind local address\n");
   close(g_svr_sockfd);
   exit(0);
}

/* Listening */
listen(g_svr_sockfd,15); /* connection queue is 15. */

printf("[ETEST][START] Now Server listening on port %d\n",svr_port);
}
/*------------------------------- end of function init_server0 */

void epoll_init(void)
{
struct epoll_event events;

g_epoll_fd = epoll_create(MAX_EVENTS);
if(g_epoll_fd < 0)
{
   printf("[ETEST] Epoll create Fails.\n");
   close(g_svr_sockfd);
   exit(0);
}
printf("[ETEST][START] epoll creation success\n");

/* event control set */
events.events = EPOLLIN;
events.data.fd = g_svr_sockfd;

/* server events set(read for accept) */
if( epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, g_svr_sockfd, &events) < 0 )
{
   printf("[ETEST] Epoll control fails.\n");
   close(g_svr_sockfd);
   close(g_epoll_fd);
   exit(0);
}

printf("[ETEST][START] epoll events set success for server\n");
}
/*------------------------------- end of function epoll_init */

void epoll_cli_add(int cli_fd)
{

struct epoll_event events;

/* event control set for read event */
events.events = EPOLLIN;
events.data.fd = cli_fd;

if( epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, cli_fd, &events) < 0 )
{
printf("[ETEST] Epoll control fails.in epoll_cli_add\n");
}

}

void userpool_add(int cli_fd,char *cli_ip)
{
/* get empty element */
register int i;

for( i = 0 ; i < MAX_CLIENT ; i++ )
{
if(g_client[i].cli_sockfd == -1) break;
}
if( i >= MAX_CLIENT ) close(cli_fd);

g_client[i].cli_sockfd = cli_fd;
memset(&g_client[i].cli_ip[0],0,20);
strcpy(&g_client[i].cli_ip[0],cli_ip);

}

void userpool_delete(int cli_fd)
{
register int i;

for( i = 0 ; i < MAX_CLIENT ; i++)
{
   if(g_client[i].cli_sockfd == cli_fd)
   {
g_client[i].cli_sockfd = -1;
break;
   }
}
}

void userpool_send(char *buffer)
{
register int i;
int len;

len = strlen(buffer);

for( i = 0 ; i < MAX_CLIENT ; i ++)
{
if(g_client[i].cli_sockfd != -1 )
{
len = send(g_client[i].cli_sockfd, buffer, len,0);
/* more precise code needed here */
}
}

}

void client_recv(int event_fd)
{
char r_buffer[1024]; /* for test. packet size limit 1K */
int len;
/* there need to be more precise code here */
/* for example , packet check(protocol needed) , real recv size check , etc. */

/* read from socket */
len = recv(event_fd,r_buffer,1024,0);
if( len < 0 || len == 0 )
{
userpool_delete(event_fd);
close(event_fd); /* epoll set fd also deleted automatically by this call as a spec */
return;
}

userpool_send(r_buffer);

}

void server_process(void)
{
struct sockaddr_in cli_addr;
int i,nfds;
int cli_sockfd;
int cli_len = sizeof(cli_addr);

nfds = epoll_wait(g_epoll_fd,g_events,MAX_EVENTS,100); /* timeout 100ms */

if(nfds == 0) return; /* no event , no work */
if(nfds < 0)
{
printf("[ETEST] epoll wait error\n");
return; /* return but this is epoll wait error */
}

for( i = 0 ; i < nfds ; i++ )
{
if(g_events[i].data.fd == g_svr_sockfd)
{
cli_sockfd = accept(g_svr_sockfd, (struct sockaddr *)&cli_addr,(socklen_t *)&cli_len);
if(cli_sockfd < 0) /* accept error */
{
}
else
{
   printf("[ETEST][Accpet] New client connected. fd:%d,ip:%s\n",cli_sockfd,inet_ntoa(cli_addr.sin_addr));
   userpool_add(cli_sockfd,inet_ntoa(cli_addr.sin_addr));
   epoll_cli_add(cli_sockfd);
}
continue; /* next fd */
}
/* if not server socket , this socket is for client socket, so we read it */
   client_recv(g_events[i].data.fd);

} /* end of for 0-nfds */
}
/*------------------------------- end of function server_process */

void end_server(int sig)
{
close(g_svr_sockfd); /* close server socket */
printf("[ETEST][SHUTDOWN] Server closed by signal %d\n",sig);
exit(0);
}

int main( int argc , char *argv[])
{

printf("[ETEST][START] epoll test server v1.0 (simple epoll test server)\n");
/* entry , argument check and process */
if(argc < 3) g_svr_port = DEFAULT_PORT;
else
{
   if(strcmp("-port",argv[1]) == 0 )
   {
g_svr_port = atoi(argv[2]);
if(g_svr_port < 1024)
{
   printf("[ETEST][STOP] port number invalid : %d\n",g_svr_port);
   exit(0);
}
   }
}

init_data0();

/* init server */
init_server0(g_svr_port);
epoll_init(); /* epoll initialize */

/* main loop */
while(1)
{
server_process(); /* accept process. */
} /* infinite loop while end. */

}

출처 : Tong - e돌람바님의 UNIX/LINUX C/C++통

'리눅스 서버에 대해서' 카테고리의 다른 글

Epoll 채팅 서버 소스 (0)	2008.05.25
Select 채팅 서버 (0)	2008.05.25
쓰레드 에코서버 (0)	2008.05.25
밑의 epoll 예제가 좀 복잡해서 좀 간단하게 수정함 (0)	2008.03.29
겜서버 숙제 (0)	2008.03.24

이거 할때마다 느끼지만 조낸 빡세다... orz

invalid-file

'리눅스 서버에 대해서' 카테고리의 다른 글

Epoll 채팅 서버 소스 (0)	2008.05.25
Select 채팅 서버 (0)	2008.05.25
쓰레드 에코서버 (0)	2008.05.25
밑의 epoll 예제가 좀 복잡해서 좀 간단하게 수정함 (0)	2008.03.29
epoll 서버 프로그래밍 (0)	2008.03.29

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

invalid-file

기말 턴프로젝트로 만든 게임
성의 없다고 생각할지도 모르겠지만...
나름대로 최선을 다했다고 생각하는 게임입니다.. orz
사용방법은 ppt내에 있고, 핵심 소스 내용도 ppt에 있습니다.

컴파일을 못시키겠다 싶으시면..
ODE(www.ode.org)를 가져오신뒤, sample소스(설치 디렉토리밑에 bulid ->...)
의 아무 샘플 main에다가 copy and phase 하시면 됩니다.
(아.. 마지막 textures 디렉토리 설정은 sample소스의 것을 따라가야 할껍니다.)
사실 천마를 구현한다고 했지만 실제 미사일은 총알처럼 나간다는것...

예전 방공대대 출신으로서... 향수젖는군요.

마지막으로 ppt에 딴지 걸듯한 사람들이 있을꺼 같네요.
음.. 사실 천마로는 미그기 잡기엔 과분한 용도죠 ㅡ_ㅡ..
그냥 그려러니 하세요.
참고로 mig-19기는 북한정도만 쓰고 있습니다. ㅡ_ㅡ.....

'알고리즘 > 게임 수학 / 물리' 카테고리의 다른 글

일본에서 3D 프로그래밍을 다시 공부하고 있습니다. (0)	2010.07.04
변환행렬 (0)	2007.11.11
삼각함수 항등식들 (0)	2007.09.20
게임 수학 / 물리 2강내용 (0)	2007.09.14
게임 수학 & 물리 (0)	2007.09.06

기억창고

소스

밑의 epoll 예제가 좀 복잡해서 좀 간단하게 수정함

'리눅스 서버에 대해서' 카테고리의 다른 글

epoll 서버 프로그래밍

epoll 서버 샘플 프로그래밍

'리눅스 서버에 대해서' 카테고리의 다른 글

겜서버 숙제

'리눅스 서버에 대해서' 카테고리의 다른 글

Anti Game hacking 프로그램의 구현.

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

ODE를 사용한 간단한 게임

'알고리즘 > 게임 수학 / 물리' 카테고리의 다른 글

+ Recent posts

티스토리툴바