Belajar Assembly - Debugging & Reverse Engineering (gdb/objdump)

#Pendahuluan

Semua keterampilan yang kalian bangun — register (5), stack (8), ABI (9), syscall (10) — sekarang dipakai untuk hal yang sebaliknya: membaca program, bukan menulisnya. Episode 16 mengajarkan debugging assembly dengan gdb dan reverse engineering dengan objdump, readelf, strace, dan tool modern.

Mengapa penting? Karena di dunia nyata, kalian tidak selalu punya source code. Binary library, malware, firmware, dan software yang "harus dibongkar" adalah keseharian security researcher dan engineer debugging masalah produksi yang hanya muncul di production binary. Kemampuan membaca assembly dari tool ini adalah superpower.

#gdb untuk Assembly: Mode Mesin

gdb normal berjalan di level source code; untuk assembly kita turun ke level instruksi. Siapkan program dari episode 3 (Hello World):

gdb -q ./hello
(gdb) break _start
(gdb) run
(gdb) layout asm          # (opsional) tampilan TUI
(gdb) info registers
(gdb) stepi               # eksekusi satu instruksi
(gdb) info registers rax
(gdb) x/3i $rip           # lihat 3 instruksi berikutnya
(gdb) x/14bx msg          # lihat 14 byte memori dari msg
(gdb) continue
(gdb) quit

#Perintah Inti untuk Debugging Assembly

x/14bx msg     # 14 byte hex (0x48 0x65 ... = "Hello, World!")
x/s msg        # sebagai string
x/6i $rip      # 6 instruksi berikutnya
x/5gx $rsp     # 5 qword di stack

#objdump: Disassembler dari binutils

objdump mengubah binary kembali menjadi assembly — cara tercepat melihat apa yang sebenarnya dilakukan program:

objdump -d -M intel hello

Output (ringkas):

hello:     file format elf64-x86-64
 
Disassembly of section .text:
0000000000401000 <_start>:
  401000:	b8 01 00 00 00    	mov    eax,0x1
  401005:	bf 01 00 00 00    	mov    edi,0x1
  40100a:	48 be 00 20 40 00 	movabs rsi,0x402000
  401014:	ba 0e 00 00 00    	mov    edx,0xe
  401019:	0f 05             	syscall

Perhatikan hal menarik: kolom hex adalah opcode, dan instruksi mov eax, 0x1 memakai eax 32-bit (yang otomatis menghapus bit atas rax — ingat episode 5!). Ini adalah pemandangan normal disassembly: compiler dan assembler memilih encoding terpendek.

Perintah objdump lain yang berguna: objdump -s -j .data untuk dump section data, objdump -t untuk tabel simbol, dan -M intel untuk dialek Intel.

#readelf: Membaca Struktur ELF

readelf membuka tabir format file — struktur yang kalian pelajari di episode 10:

readelf -h hello    # header ELF
readelf -l hello    # segment (program headers)
readelf -S hello    # section (section headers)
readelf -s hello    # symbol table

ELF Header:
  Class:                             ELF64
  Data:                              2's complement, little endian
  Type:                              EXEC (Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Entry point address:               0x401000

Dari sini kalian bisa mengonfirmasi entry point (0x401000 = _start) dan tipe file. readelf adalah tool pertama saat menganalisis binary tak dikenal — sering dipakai bersama file:

file hello
readelf -h hello | grep -E "Class|Machine|Entry"

#strace: Menonton Syscall

strace sudah diperkenalkan di episode 10. Kali ini sebagai tool RE: ia menunjukkan perilaku program tanpa membuka source — sering jauh lebih cepat daripada menganalisis seluruh binary:

strace -f -e trace=write,openat,read ./hello

Output memisahkan syscall penting dari yang lain. Untuk binary yang menyembunyikan logika, strace sering mengungkap file yang dibuka, alamat network, dan urutan operasi — titik awal sebelum membongkar kode.

#Tool Reverse Engineering Modern

Untuk binary besar dan kompleks, tool interaktif jauh lebih produktif:

Saat membongkar binary, alur kerjanya khas:

file target                    # identifikasi format
strings target | head -50      # string menarik (cepat, kasar)
readelf -h target              # entry point, arsitektur
objdump -d -M intel target | less  # mulai disassembly
strace -f ./target             # lihat syscall saat runtime

#Latihan Mini: Membaca Fungsi dari Disassembly

Mari baca kode kecil dan terjemahkan maknanya. Compile C berikut:

simple.c

int add(int a, int b) {
    return a + b + 100;
}

gcc -O0 -c simple.c -o simple.o
objdump -d -M intel simple.o

push   rbp
mov    rbp, rsp
mov    DWORD PTR [rbp-4], edi    ; a  → local var
mov    DWORD PTR [rbp-8], esi    ; b  → local var
mov    eax, DWORD PTR [rbp-4]
add    eax, DWORD PTR [rbp-8]    ; a + b
add    eax, 100                  ; + 100
pop    rbp
ret

Kalian sekarang bisa membaca ini sebagai: frame dibuat (push rbp/mov rbp,rsp), argumen disimpan ke variabel lokal, dijumlahkan, dan dikembalikan. Kemampuan membaca pola seperti ini — prologue, variabel lokal, return — adalah inti dari reverse engineering. (Bandingkan: compile dengan -O2, dan kalian akan melihat hampir semua frame hilang — pelajaran untuk episode 18.)

#Common Pitfalls

• Lupa -M intel — objdump default AT&T (episode 4).
• Bingung entry point — program tanpa simbol perlu break di _start atau entry dari readelf -h.
• Breakpoint di alamat yang salah — pastikan offset benar; executable PIE berpindah (lihat episode 17).
• Menafsirkan eax sebagai rax — ingat zeroing otomatis bit atas.
• Asumsi disassembly = source — dengan -O2, output jauh berbeda dari kode C.

#Penutup

Pada episode 16 ini, kalian telah menjadi pembaca kode mesin.

Inti yang harus dibawa pulang:

• gdb di level mesin: stepi, info registers, x/ untuk memori, layout asm.
• objdump -d -M intel untuk disassembly; perhatikan opcode vs dialek.
• readelf -h/-S/-s membaca struktur ELF; strace mengungkap perilaku syscall.
• Ghidra/IDA/radare2 untuk analisis binary skala besar.
• Kemampuan menerjemahkan prologue/epilogue dan pola variabel lokal.

Di episode 17 selanjutnya, semua pengetahuan ini dipakai untuk hal paling sensitif: security — exploits, mitigations & shellcode. Kita bedah buffer overflow dan stack layout, ROP, konsep shellcode, mitigasi NX/ASLR/canary/PIE, dan cara mengeceknya dengan checksec — di lingkungan lab yang aman. Di sinilah pemahaman stack dari episode 8 mulai membuahkan hasil.