[🥇 Gold 4] 안티디버깅이 스스로 무너지는 자리 — DreamHack ptrace_block 풀이

2026-08-07·1분 읽기·

[🥇 Gold 4] 안티디버깅이 스스로 무너지는 자리 — DreamHack ptrace_block 풀이

생성자가 AES-128 키를 만들고 main 은 그 키로 입력을 암호화해 out.txt 에 쓴다. 키를 흔드는 값은 ptrace(PTRACE_TRACEME) 의 반환값을 4096 번 곱해 만드는데, 32비트 곱셈이 넘쳐 디버거가 있든 없든 0 이 된다. 남은 건 하위 1바이트짜리 XOR 뿐이라 256 번 시도로 끝난다.

문제: DreamHack — ptrace_block 분류: reversing 난이도: 🥇 Gold 4 FLAG: DH{4e979cd79e571e07d362d3240921c7b9e643082e31029adadfbc4af89b7d0b7f}

문제 설명은 두 줄이 전부다. "제작자가 입력한 내용이 어떤 내용이었는지 맞춰주세요", 그리고 그 문자열은 DH{..} 형식의 printable ascii 라는 것.

받은 건 prob 바이너리 하나와 out.txt 256바이트. 서버도 없고 접속할 곳도 없다. 저 256바이트가 제작자가 친 문자열의 암호문이고, 그걸 되돌리면 끝이다.


문제 개요

항목내용
문제명ptrace_block
난이도🥇 Gold 4
분류reversing
제공 파일prob (x86-64 PIE, stripped), out.txt (256바이트)
스택glibc + OpenSSL 3 (libcrypto.so.3)
핵심 취약점 / 기법안티디버깅용 곱셈 누산기가 32비트 오버플로로 0 에 고정 + 키 XOR 값이 하위 1바이트만 저장

흐름은 짧다. .init_array 에 등록된 생성자 둘이 .data 의 고정 시드에서 AES-128 키를 만들고, main 은 사용자 입력을 그 키로 AES-CBC 암호화해 out.txt 에 쓴다. 우리가 가진 out.txt 는 제작자가 자기 플래그를 넣고 돌린 결과물이다.

키가 시간 기반 난수에 의존하니 겉보기엔 복원이 불가능해 보인다. 실제로는 두 가지가 무너져 있어서 후보가 256개로 줄어든다.



🔬 정찰 — 배포본에 뭐가 들어 있나

먼저 파일 종류와 의존 라이브러리를 본다. 링크된 라이브러리가 곧 "이 문제가 무슨 암호를 쓰는가"를 알려준다.

file extracted/prob && readelf -d extracted/prob | grep NEEDED && wc -c extracted/out.txt
file 과 readelf 로 확인한 prob 바이너리 정보 — x86-64 PIE 실행파일이고 stripped 라 심볼이 없으며, 동적 의존성에 libcrypto.so.3 이 걸려 있어 OpenSSL 을 쓴다는 것과 out.txt 가 정확히 256바이트라는 사실이 한 화면에 나온다
file 과 readelf 로 확인한 prob 바이너리 정보 — x86-64 PIE 실행파일이고 stripped 라 심볼이 없으며, 동적 의존성에 libcrypto.so.3 이 걸려 있어 OpenSSL 을 쓴다는 것과 out.txt 가 정확히 256바이트라는 사실이 한 화면에 나온다

세 가지가 잡힌다. PIE 에 stripped 라 함수 이름이 하나도 없다는 것, libcrypto.so.3 이 걸려 있으니 OpenSSL 암호 함수를 부른다는 것, 그리고 out.txt 가 딱 256바이트라는 것.

256은 AES 블록(16바이트)의 정확히 16배다. 패딩 흔적이 없는 걸 보니 입력 버퍼를 통째로 한 번에 암호화했을 가능성이 높다.

out.txt 자체도 봐 둔다.

xxd extracted/out.txt
xxd 로 뜬 out.txt 전체 256바이트 덤프 — 첫 줄이 e1 6d fc ec b9 34 22 bd 로 시작하고 마지막 줄까지 고른 분포의 이진 데이터로 채워져 있어, 평문 흔적이나 반복 블록 없이 전부 암호화된 상태임을 보여준다
xxd 로 뜬 out.txt 전체 256바이트 덤프 — 첫 줄이 e1 6d fc ec b9 34 22 bd 로 시작하고 마지막 줄까지 고른 분포의 이진 데이터로 채워져 있어, 평문 흔적이나 반복 블록 없이 전부 암호화된 상태임을 보여준다

전 구간이 고르게 흩어져 있다. 뒤쪽이 같은 블록의 반복이었다면 ECB 를 의심했겠지만 그렇지 않으니 CBC 쪽이다.

다음은 어떤 함수를 부르는지다. stripped 라도 동적 심볼은 남는다.

objdump -T extracted/prob
objdump -T 로 뽑은 prob 의 동적 심볼 목록 — AES_set_encrypt_key 와 AES_cbc_encrypt 가 OPENSSL_3.0.0 버전으로, ptrace 와 srand 와 rand 와 time 이 GLIBC 로 들어와 있어 암호 루틴과 안티디버깅과 난수 시드가 한자리에 모여 있음을 보여준다
objdump -T 로 뽑은 prob 의 동적 심볼 목록 — AES_set_encrypt_key 와 AES_cbc_encrypt 가 OPENSSL_3.0.0 버전으로, ptrace 와 srand 와 rand 와 time 이 GLIBC 로 들어와 있어 암호 루틴과 안티디버깅과 난수 시드가 한자리에 모여 있음을 보여준다

목록만으로 문제의 뼈대가 드러난다. AES_set_encrypt_key 와 AES_cbc_encrypt 가 암호화를 맡고, srand · rand · time 이 키를 만드는 데 쓰이고, ptrace 가 그 사이에 끼어 있다. 문제 이름이 왜 ptrace_block 인지도 여기서 짐작이 간다.


🧩 배경 — main 보다 먼저 도는 코드

C 프로그램에서 main 이 첫 코드라고 생각하기 쉽지만 아니다. __attribute__((constructor)) 가 붙은 함수는 .init_array 섹션에 함수 포인터로 등록되고, 동적 로더가 main 을 부르기 전에 순서대로 실행한다.

이 문제는 거기에 키 생성 로직을 숨겼다. main 만 읽으면 키가 어디서 왔는지 영영 안 보인다.

objdump -s -j .init_array -j .data extracted/prob
objdump -s 로 덤프한 .init_array 와 .data 섹션 — init_array 에 0x12c0, 0x12c9, 0x1392 세 함수 포인터가 들어 있고 .data 의 0x4010 자리에 16바이트 고정 시드 41 28 19 4e a5 7c a1 41 이 박혀 있다
objdump -s 로 덤프한 .init_array 와 .data 섹션 — init_array 에 0x12c0, 0x12c9, 0x1392 세 함수 포인터가 들어 있고 .data 의 0x4010 자리에 16바이트 고정 시드 41 28 19 4e a5 7c a1 41 이 박혀 있다

.init_array 에 포인터가 셋이다. 0x12c0 은 컴파일러가 넣는 frame_dummy 라 무시해도 되고, 실제 생성자는 0x12c9 와 0x1392 두 개다. 배열 순서대로 도니 0x12c9 가 먼저다.

그리고 .data 의 0x4010 자리에 16바이트가 박혀 있다.

41 28 19 4e a5 7c a1 41 13 cf 88 ac 2a f0 b7 da

정확히 AES-128 키 길이다. 생성자 둘이 이 16바이트를 주물러 최종 키를 만든다고 보면 된다.


🧱 배경 — CBC 모드와 IV

암호화 본체를 읽기 전에 CBC 를 짚어 둔다. 평문 블록을 그냥 암호화하는 ECB 와 달리, CBC 는 직전 암호문 블록을 평문에 XOR 한 뒤 블록 암호를 태운다. 첫 블록에는 직전 암호문이 없으니 그 자리에 IV 를 넣는다.

CBC 운용 모드의 암호화 과정 도식 — 각 평문 블록이 직전 암호문 블록과 XOR 된 뒤 블록 암호를 통과하고, 첫 블록만 초기화 벡터 IV 와 XOR 되는 연결 구조를 화살표로 보여주는 표준 참조 그림
CBC 운용 모드의 암호화 과정 도식 — 각 평문 블록이 직전 암호문 블록과 XOR 된 뒤 블록 암호를 통과하고, 첫 블록만 초기화 벡터 IV 와 XOR 되는 연결 구조를 화살표로 보여주는 표준 참조 그림

출처: Wikimedia Commons, WhiteTimberwolf (SVG version), public domain

복호는 이 그림을 거꾸로 타면 된다. 키와 IV 만 알면 되고, 블록이 체인으로 묶여 있으니 키가 한 비트라도 틀리면 첫 블록부터 완전히 깨진다. 뒤집어 말하면 256개 후보를 훑을 때 "맞았는지"를 첫 블록만 보고 즉시 판정할 수 있다는 뜻이다.

이제 암호화 함수를 본다. main 이 부르는 0x13f1 이 그 자리다.

objdump -d --start-address=0x13f1 --stop-address=0x1490 -M intel --no-show-raw-insn extracted/prob | sed -f annotate_enc.sed
objdump 로 디스어셈블한 0x13f1 암호화 함수에 주석을 얹은 화면 — IV 로 쓸 스택 16바이트를 0 으로 채우고 128비트로 AES_set_encrypt_key 를 부른 뒤 길이 0x100, enc 인자 1 로 AES_cbc_encrypt 를 호출한다
objdump 로 디스어셈블한 0x13f1 암호화 함수에 주석을 얹은 화면 — IV 로 쓸 스택 16바이트를 0 으로 채우고 128비트로 AES_set_encrypt_key 를 부른 뒤 길이 0x100, enc 인자 1 로 AES_cbc_encrypt 를 호출한다

화면의 <-- 주석은 내가 annotate_enc.sed 로 얹은 것이다. objdump 가 원래 그렇게 찍어 주지는 않는다. 주석 규칙 파일은 이렇게 생겼다.

s|^\( *1423:.*\)$|\1        <-- IV 앞 8바이트 = 0|
s|^\( *142b:.*\)$|\1        <-- IV 뒤 8바이트 = 0   ★ IV 가 통째로 0 이다|
s|^\( *143d:.*\)$|\1        <-- 키 길이 0x80 = 128비트|
s|^\( *1442:.*\)$|\1        <-- 키는 .data:0x4010 (생성자가 만든 그 16바이트)|
s|^\( *144c:.*\)$|\1        <-- AES_set_encrypt_key(key, 128, \&ks)|
s|^\( *1457:.*\)$|\1        <-- 길이 0x100 = 256바이트|
s|^\( *1473:.*\)$|\1        <-- enc = 1 (암호화 방향)|
s|^\( *147f:.*\)$|\1        <-- AES_cbc_encrypt(in, out, 0x100, \&ks, IV, 1)|

읽어 보면 이렇다.

void enc(char *in, char *out, int len) {
    AES_KEY ks;
    unsigned char ivec[16] = {0};              // 스택에서 0 으로 초기화
    AES_set_encrypt_key(g_key /* .data:0x4010 */, 128, &ks);
    AES_cbc_encrypt(in, out, len /* 0x100 */, &ks, ivec, AES_ENCRYPT);
}

IV 가 0 으로 고정이라 변수가 하나 줄었다. 이제 알아내야 할 건 .data:0x4010 의 최종 16바이트뿐이다.

main 쪽도 단순하다. puts("generate your flag!") 로 인사하고 scanf("%255s") 로 한 줄 받은 뒤, 256바이트 버퍼를 통째로 enc 에 넘기고 open("./out.txt", O_WRONLY) 로 열어 256바이트를 쓴다. 입력 버퍼는 미리 0 으로 채워져 있으므로 플래그 뒤는 전부 널 바이트다. 이것도 나중에 정답 판정에 쓴다.


🐛 삽질 — 바이너리를 돌려 보려다 두 번 걸렸다

정적 분석만으로도 풀리는 문제지만, 중간에 동작을 확인하려고 prob 를 직접 돌리다 두 번 넘어졌다. 둘 다 문제 로직과는 상관없는 배포·구현 함정이라 따로 묶어 둔다.

▶🐛 삽질 1·2 — 실행 비트가 없고, out.txt 는 저절로 안 생긴다

첫 번째. 배포 zip 에서 갓 푼 prob 에는 실행 비트가 없다. gdb 로 붙이려다 허가 거부 만 보고 잠깐 헤맸다. 드림핵 배포본에서 종종 겪는 일이라 이제는 chmod +x 를 습관처럼 먼저 한다.

두 번째가 더 고약하다. main 은 출력 파일을 이렇게 연다.

fd = open("./out.txt", 1);      // O_WRONLY. O_CREAT 가 없다
write(fd, out, 0x100);
close(fd);

O_CREAT 가 없으니 out.txt 가 미리 없으면 open 이 -1 을 돌려주고, 그 뒤 write(-1, ...) 는 조용히 실패한다. 반환값을 아무도 안 보므로 프로그램은 태연히 정상 종료한다. 빈 폴더에서 돌려 놓고 "왜 결과 파일이 안 생기지" 하고 한참 봤다.

두 함정을 그대로 재현하는 스크립트를 만들어 뒀다.

#!/usr/bin/env bash
# trap_demo.sh
cd "$(dirname "$(readlink -f "$0")")"
rm -rf trapdemo && mkdir trapdemo
 
echo '--- 1) 배포본 그대로의 권한으로 실행 ---'
cp --no-preserve=mode extracted/prob trapdemo/prob
chmod 664 trapdemo/prob
ls -l trapdemo/prob
( cd trapdemo && ./prob )
echo "exit=$?"
 
echo
echo '--- 2) chmod +x 후, out.txt 없이 실행 ---'
chmod +x trapdemo/prob
printf 'DH{test}\n' > trapdemo/in.txt
( cd trapdemo && timeout 20 ./prob < in.txt )
echo
echo "out.txt 가 생겼나? -> $(ls trapdemo/out.txt 2>&1)"
 
echo
echo '--- 3) out.txt(256B) 를 미리 만들어 두고 다시 ---'
head -c 256 /dev/zero > trapdemo/out.txt
( cd trapdemo && timeout 20 ./prob < in.txt )
echo
echo "out.txt 크기 -> $(wc -c < trapdemo/out.txt) 바이트, 내용 앞 32B:"
head -c 32 trapdemo/out.txt | xxd
./trap_demo.sh
trap_demo.sh 실행 결과 — 배포본 권한 그대로 실행하면 허가 거부와 exit 126 이 뜨고, chmod 후 실행해도 out.txt 가 생기지 않아 ls 가 No such file 을 반환하며, 256바이트 out.txt 를 미리 만들어 둔 세 번째 시도에서만 암호문이 실제로 기록되는 과정이 순서대로 보인다
trap_demo.sh 실행 결과 — 배포본 권한 그대로 실행하면 허가 거부와 exit 126 이 뜨고, chmod 후 실행해도 out.txt 가 생기지 않아 ls 가 No such file 을 반환하며, 256바이트 out.txt 를 미리 만들어 둔 세 번째 시도에서만 암호문이 실제로 기록되는 과정이 순서대로 보인다

세 번째 시도에서야 암호문이 들어간다. 재현할 때는 256바이트 더미 파일을 먼저 깔아 두면 된다.

▶🐛 삽질 3 — 디버거를 붙이면 키가 망가질 줄 알았는데 멀쩡했다

ptrace 가 키 계산에 끼어 있는 걸 보고, gdb 안에서는 키가 엉뚱하게 나올 거라고 예상했다. 그걸 눈으로 확인하려고 브레이크포인트를 걸었는데 중간 키가 예상값과 한 바이트도 다르지 않았다.

처음엔 브레이크포인트를 잘못 걸었나 싶어 주소를 몇 번 다시 확인했다. 아니었다. 안티디버깅이 실제로 아무 일도 못 하고 있었던 것이고, 그게 이 문제의 핵심이었다. 아래 "핵심" 절이 그 얘기다.



💣 핵심 — ptrace 는 아무것도 막지 못한다

첫 번째 생성자 0x12c9 를 뜯어본다.

objdump -d --start-address=0x12c9 --stop-address=0x138a -M intel --no-show-raw-insn extracted/prob | sed -f annotate_ctor1.sed
objdump 로 디스어셈블한 첫 생성자 0x12c9 에 주석을 얹은 화면 — srand 를 time 으로 시드한 뒤 4096 회 루프가 ptrace 반환값에 rand 를 곱해 누산기 v 에 쌓고, 이어서 키 배열을 누적합으로 갱신한다
objdump 로 디스어셈블한 첫 생성자 0x12c9 에 주석을 얹은 화면 — srand 를 time 으로 시드한 뒤 4096 회 루프가 ptrace 반환값에 rand 를 곱해 누산기 v 에 쌓고, 이어서 키 배열을 누적합으로 갱신한다

주석은 annotate_ctor1.sed 로 얹었다. 규칙 파일은 이렇다.

s|^\( *12db:.*\)$|\1        <-- time(0)|
s|^\( *12e2:.*\)$|\1        <-- srand(time(0))|
s|^\( *12e7:.*\)$|\1        <-- v = 1|
s|^\( *1310:.*\)$|\1        <-- ptrace(PTRACE_TRACEME,0,0,0)|
s|^\( *1315:.*\)$|\1        <-- rbx = 반환값 (정상 0 / 추적중 -1)|
s|^\( *1318:.*\)$|\1        <-- rand()|
s|^\( *131f:.*\)$|\1        <-- rax = rand() * rbx|
s|^\( *1328:.*\)$|\1        <-- v *= 그 값   ★ 여기가 안티디버깅|
s|^\( *1332:.*\)$|\1        <-- 4096 번 반복|
s|^\( *1353:.*\)$|\1        <-- ecx = key[j+1]|
s|^\( *1363:.*\)$|\1        <-- eax = key[j]|
s|^\( *136a:.*\)$|\1        <-- edx = v + key[j]|
s|^\( *137d:.*\)$|\1        <-- key[j+1] = key[j+1] + key[j] + v|
s|^\( *1384:.*\)$|\1        <-- j = 0..14|

C 로 옮기면 이렇다.

__attribute__((constructor)) void ctor1(void) {
    srand(time(0));
 
    int v = 1;
    for (int i = 0; i <= 0xfff; i++)                 // 4096 회
        v *= rand() * ptrace(PTRACE_TRACEME, 0, 0, 0);
 
    for (int j = 0; j <= 0xe; j++)                   // j = 0..14
        key[j + 1] = key[j + 1] + key[j] + v;        // 전부 unsigned char
}

의도는 읽힌다. PTRACE_TRACEME 는 디버거가 안 붙어 있으면 0 을, 이미 누가 추적 중이면 -1 을 돌려준다. 그 값을 곱셈에 태워서 디버거 유무에 따라 v 가 달라지게 만들려 한 것이다.

디버거가 없을 때는 자명하다. 첫 반복에서 ptrace 가 0 을 돌려주고, 0 이 곱해진 v 는 그대로 0 이 된다. 그 뒤 4095번을 더 돌아도 0 이다.

문제는 디버거가 붙었을 때다. ptrace 가 -1 이니 곱셈이 살아남는다. 여기서 v 가 난수가 되어야 안티디버깅이 성립한다. 실제로 그런지 gdb 로 확인한다.

stripped PIE 라 심볼이 없으니 주소는 전부 "PIE 베이스 + 파일 오프셋"으로 잡아야 한다. 베이스를 0x555555554000 으로 넘겨짚지 않고 info proc mappings 에서 실측하는 배치 스크립트를 썼다.

## runtime.gdb
set confirm off
set pagination off
 
starti
 
python
import gdb
base = None
for line in gdb.execute("info proc mappings", to_string=True).splitlines():
    p = line.split()
    if p and p[-1].endswith("prob"):
        base = int(p[0], 16)
        break
if base is None:
    raise gdb.GdbError("PIE base 를 못 찾음")
gdb.execute("set $base = %#x" % base)
end
 
printf "PIE base = %p\n", $base
 
## ctor1(0x12c9) 안, call ptrace 바로 다음 명령
tbreak *($base + 0x1315)
continue
printf "\n[1] ptrace(PTRACE_TRACEME,0,0,0) -> %ld\n", (long)$rax
printf "    0 이면 정상 실행, -1 이면 이미 누가 추적 중(= 지금 gdb)\n"
 
## ctor1 의 키 섞기 루프가 끝난 지점(0x138a nop)
tbreak *($base + 0x138a)
continue
printf "\n[2] ctor1 통과 후 key @ .data:0x4010\n"
x/16xb $base + 0x4010
printf "    디버거가 없을 때의 정답은 41 69 82 d0 75 f1 92 d3 e6 b5 3d e9 13 03 ba 94\n"
 
## ctor2(0x1392) 의 XOR 루프가 끝난 지점(0x13ed nop)
tbreak *($base + 0x13ed)
continue
printf "\n[3] ctor2 통과 후 key @ .data:0x4010 (AES-128 최종 키)\n"
x/16xb $base + 0x4010
 
kill
quit
gdb -q -batch -x runtime.gdb --args ./extracted/prob
gdb 배치 실행 결과 — ptrace 반환값이 -1 로 나와 안티디버깅이 발화했는데도 ctor1 통과 후 키가 41 69 82 d0 75 f1 92 d3 으로 디버거 없을 때 예상값과 같고, ctor2 를 지난 최종 키만 달라진다
gdb 배치 실행 결과 — ptrace 반환값이 -1 로 나와 안티디버깅이 발화했는데도 ctor1 통과 후 키가 41 69 82 d0 75 f1 92 d3 으로 디버거 없을 때 예상값과 같고, ctor2 를 지난 최종 키만 달라진다

[1] 에서 ptrace 는 분명히 -1 을 돌려준다. 안티디버깅은 발화했다. 그런데 [2] 의 키는 디버거가 없을 때 나와야 할 값과 완전히 같다.

이유는 오버플로다. v 는 32비트 int 이고, 루프는 4096번 돈다. rand() 가 뱉는 값의 절반쯤은 짝수이니 곱을 쌓는 동안 2의 인수가 수천 개 붙는다. 2^32 로 잘리는 곱셈에서는 2의 인수가 32개만 모여도 0 이다. 부호가 -1 이든 뭐든 상관없다.

말로만 하지 말고 실제 glibc rand() 로 세어 본다.

#!/usr/bin/env python3
import ctypes
import ctypes.util
 
libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)
libc.rand.restype = ctypes.c_int
libc.srand.argtypes = [ctypes.c_uint]
 
M32 = 0xFFFFFFFF
 
 
def simulate(seed: int, ptrace_ret: int) -> tuple[int, int, int]:
    """v 최종값, 짝수였던 rand() 개수, v 가 0 이 된 반복 번호를 돌려준다."""
    libc.srand(seed)
    v = 1
    evens = 0
    zero_at = -1
    for i in range(0x1000):
        r = libc.rand()
        if r % 2 == 0:
            evens += 1
        edx = (r * ptrace_ret) & M32          # imul rax,rbx → mov edx,eax
        v = (v * edx) & M32                   # imul eax,edx
        if v == 0 and zero_at < 0:
            zero_at = i
    return v, evens, zero_at
 
 
def main() -> None:
    print("=== 디버거 없음: ptrace() == 0 ===")
    v, evens, zero_at = simulate(1234, 0)
    print(f"  v = {v}   (반복 {zero_at} 번째에 이미 0 — 0 을 곱했으니 당연하다)")
 
    print("\n=== 디버거 부착: ptrace() == -1 ===")
    nonzero = 0
    worst = 0
    for seed in range(1, 201):
        v, evens, zero_at = simulate(seed, -1)
        if v != 0:
            nonzero += 1
        worst = max(worst, zero_at)
        if seed <= 3:
            print(f"  seed={seed:<4} v={v}  짝수 rand {evens}/4096  "
                  f"v 가 0 이 된 반복 = {zero_at}")
    print(f"\n  시드 200 개 중 v != 0 인 경우 : {nonzero} 개")
    print(f"  가장 늦게 0 이 된 반복 번호   : {worst} (4096 회보다 한참 이르다)")
    print("\n  → ptrace 가 0 이든 -1 이든 v 는 0 이다. 안티디버깅이 키를 못 바꾼다.")
 
 
if __name__ == "__main__":
    main()
python3 why_v_zero.py
why_v_zero.py 실행 결과 — 디버거가 없는 경우 v 가 첫 반복에서 0 이 되고, 디버거가 붙은 경우에도 시드 200 개 전부 v 가 0 으로 수렴했으며 가장 늦게 0 이 된 반복 번호조차 62 로 4096 회보다 한참 이르다는 통계가 출력되어 안티디버깅이 무력함을 수치로 보여준다
why_v_zero.py 실행 결과 — 디버거가 없는 경우 v 가 첫 반복에서 0 이 되고, 디버거가 붙은 경우에도 시드 200 개 전부 v 가 0 으로 수렴했으며 가장 늦게 0 이 된 반복 번호조차 62 로 4096 회보다 한참 이르다는 통계가 출력되어 안티디버깅이 무력함을 수치로 보여준다

시드 200개 전부 v = 0 이고, 가장 늦게 0 이 된 경우도 62번째 반복이었다. 4096번을 돌 필요조차 없다.

그래서 ctor1 은 사실상 이 한 줄이다.

for (int j = 0; j <= 0xe; j++)
    key[j + 1] = key[j + 1] + key[j];       // v 가 0 이므로

앞 바이트를 뒤에 더해 나가는 누적합이다. 시드가 .data 에 박혀 있으니 결과도 고정이다.

시드    : 41 28 19 4e a5 7c a1 41 13 cf 88 ac 2a f0 b7 da
누적합  : 41 69 82 d0 75 f1 92 d3 e6 b5 3d e9 13 03 ba 94

gdb 가 [2] 에서 보여준 값과 정확히 같다. 정적 분석으로 예측한 값을 런타임이 확인해 준 셈이다.


🎯 진짜 관문 — 하위 1바이트

남은 건 두 번째 생성자 0x1392 다.

objdump -d --start-address=0x1392 --stop-address=0x13f1 -M intel --no-show-raw-insn extracted/prob | sed -f annotate_ctor2.sed
objdump 로 디스어셈블한 두 번째 생성자 0x1392 에 주석을 얹은 화면 — rand 결과로 다시 srand 를 걸고 뽑은 32비트 난수 r 을 키 16바이트에 차례로 XOR 하는데, 저장 명령이 mov BYTE PTR 이라 결과의 하위 1바이트만 기록된다는 점이 화살표 주석으로 강조되어 있다
objdump 로 디스어셈블한 두 번째 생성자 0x1392 에 주석을 얹은 화면 — rand 결과로 다시 srand 를 걸고 뽑은 32비트 난수 r 을 키 16바이트에 차례로 XOR 하는데, 저장 명령이 mov BYTE PTR 이라 결과의 하위 1바이트만 기록된다는 점이 화살표 주석으로 강조되어 있다
__attribute__((constructor)) void ctor2(void) {
    srand(rand());
    int r = rand();
    for (int i = 0; i <= 0xf; i++)
        key[i] ^= r;            // 하지만 저장은 1바이트
}

r 은 32비트 int 이고 xor eax, edx 도 32비트로 돈다. 그런데 결과를 되돌려 쓰는 명령이 mov BYTE PTR [key+i], cl 이다. cl 은 ecx 의 하위 1바이트다. r 의 상위 24비트는 계산되자마자 버려진다.

srand(time(0)) 에서 출발했으니 r 자체는 실행 시각마다 다르다. 제작자가 언제 돌렸는지는 알 길이 없다. 하지만 실제로 키에 반영되는 건 r & 0xff 하나뿐이고, 16바이트 전체가 같은 값으로 XOR 된다. 후보는 256개다.

여기까지 오면 키가 만들어지는 길 전체가 보인다.

ptrace_block 키 유도 도식 — 위쪽은 .data 고정 시드에서 ctor1 누적합과 ctor2 의 1바이트 XOR 로 AES 키가 만들어지는 방향, 아래쪽은 out.txt 에서 256 후보를 훑어 되돌리는 역방향이다
ptrace_block 키 유도 도식 — 위쪽은 .data 고정 시드에서 ctor1 누적합과 ctor2 의 1바이트 XOR 로 AES 키가 만들어지는 방향, 아래쪽은 out.txt 에서 256 후보를 훑어 되돌리는 역방향이다

판정 기준은 두 개를 쓴다. 평문이 DH{ 로 시작하는가, 그리고 널 바이트를 걷어낸 나머지가 전부 printable ascii 인가. 문제 설명이 두 조건을 다 알려 줬다. 잘못된 키로 CBC 복호를 하면 첫 블록부터 난수가 되니 이 정도로 충분히 걸러진다.


🚀 Full Exploit

solve.py 전문이다. 바이너리를 돌릴 필요도, 서버에 붙을 필요도 없다. out.txt 하나면 된다.

#!/usr/bin/env python3
"""
DreamHack wargame - ptrace_block (Gold 4, reversing)
 
out.txt = AES-128-CBC(IV=0, key=K) 로 암호화된 256바이트.
K 는 .data 의 시드 16바이트에서 두 개의 .init_array 생성자가 만들어 낸다.
 
  seed(0x4010) = 41 28 19 4e a5 7c a1 41 13 cf 88 ac 2a f0 b7 da
 
  ctor1 (0x12c9)  srand(time(0));  v = 1
                  for i in 0..0xfff:  v *= rand() * ptrace(PTRACE_TRACEME,0,0,0)
                  for j in 0..14:     k[j+1] = k[j+1] + k[j] + v   (mod 256)
 
  ctor2 (0x1392)  srand(rand());  r = rand()
                  for i in 0..15:     k[i] ^= (r & 0xff)
 
핵심 1 — ptrace 가 곧 안티디버깅이자 상수다.
  디버거가 안 붙은 상태에서 첫 ptrace(PTRACE_TRACEME) 는 0 을 돌려준다.
  그 0 이 v 에 곱해지는 순간 v 는 0 이 되고, 4096 번을 더 돌아도 0 이다.
  즉 정상 실행에서 v == 0 이라 cascade 는 그냥 누적합이 된다.
  (거꾸로 gdb 안에서 돌리면 ptrace 가 -1 이라 v 가 난수 쓰레기가 된다 = 문제 제목)
 
핵심 2 — ctor2 의 r 은 time 의존이지만 실제로 쓰이는 건 하위 1바이트뿐이다.
  `mov BYTE PTR [k+i], cl` 로 잘려 들어가므로 경우의 수는 256 개.
  전수로 돌려 평문이 printable + 'DH{' 로 시작하는 것을 찾는다.
"""
 
from Crypto.Cipher import AES
 
SEED = bytes.fromhex("4128194ea57ca14113cf88ac2af0b7da")   # .data:0x4010
IV = b"\x00" * 16                                          # enc() 스택 지역변수, 0으로 초기화
 
 
def ctor1(key: bytes, v: int = 0) -> bytes:
    """k[j+1] = k[j+1] + k[j] + v (mod 256), j=0..14. v 는 정상 실행이면 0."""
    k = bytearray(key)
    for j in range(15):
        k[j + 1] = (k[j + 1] + k[j] + v) & 0xFF
    return bytes(k)
 
 
def ctor2(key: bytes, x: int) -> bytes:
    """k[i] ^= (r & 0xff). r 의 하위 1바이트만 남으므로 x 는 0..255."""
    return bytes(b ^ x for b in key)
 
 
def main() -> None:
    ct = open("extracted/out.txt", "rb").read()
    assert len(ct) == 0x100, len(ct)
 
    base = ctor1(SEED)          # 생성자 순서는 .init_array = [frame_dummy, 0x12c9, 0x1392]
    print(f"[*] seed          : {SEED.hex()}")
    print(f"[*] ctor1 (v=0)   : {base.hex()}")
 
    for x in range(256):
        key = ctor2(base, x)
        pt = AES.new(key, AES.MODE_CBC, IV).decrypt(ct)
        if not pt.startswith(b"DH{"):
            continue
        body = pt.rstrip(b"\x00")
        if not all(0x20 <= c < 0x7F for c in body):
            continue
        print(f"[+] xor byte      : 0x{x:02x}")
        print(f"[+] AES-128 key   : {key.hex()}")
        print(f"[+] FLAG          : {body.decode()}")
        return
 
    print("[-] not found")
 
 
if __name__ == "__main__":
    main()
python3 solve.py
solve.py 실행 결과 — .data 시드와 ctor1 누적합 결과를 찍은 뒤 XOR 바이트 0x4b 에서 적중해 AES-128 키 0a22c99b3ebad998adfe76a25848f1df 와 DH 로 시작하는 68글자 플래그가 한 번에 출력된다
solve.py 실행 결과 — .data 시드와 ctor1 누적합 결과를 찍은 뒤 XOR 바이트 0x4b 에서 적중해 AES-128 키 0a22c99b3ebad998adfe76a25848f1df 와 DH 로 시작하는 68글자 플래그가 한 번에 출력된다

0x4b 에서 걸렸다. 최종 키는 0a22c99b3ebad998adfe76a25848f1df 다.

정말 맞는지 왕복으로 확인

브루트포스는 "그럴듯한 게 하나 나왔다"로 끝나기 쉬워서, 복원한 문자열을 바이너리에 도로 넣어 확인했다.

주의할 게 하나 있다. 새로 만든 out.txt 는 배포본과 바이트가 다르다. ctor2 의 XOR 값이 time(0) 시드에서 나오니 실행할 때마다 키가 바뀌기 때문이다. 그래도 같은 방법으로 복호가 되면 키 유도 구조가 맞다는 뜻이다.

#!/usr/bin/env python3
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path
 
sys.path.insert(0, str(Path(__file__).parent))
from solve import SEED, IV, ctor1, ctor2          # noqa: E402
from Crypto.Cipher import AES                     # noqa: E402
 
HERE = Path(__file__).resolve().parent
PROB = HERE / "extracted" / "prob"
FLAG = "DH{4e979cd79e571e07d362d3240921c7b9e643082e31029adadfbc4af89b7d0b7f}"
 
 
def crack(ct: bytes) -> str | None:
    base = ctor1(SEED)
    for x in range(256):
        pt = AES.new(ctor2(base, x), AES.MODE_CBC, IV).decrypt(ct)
        if pt.startswith(b"DH{"):
            return pt.rstrip(b"\x00").decode()
    return None
 
 
def main() -> None:
    with tempfile.TemporaryDirectory(prefix="ptrace_block_") as td:
        work = Path(td)
        shutil.copy2(PROB, work / "prob")
        (work / "prob").chmod(0o755)
        (work / "out.txt").write_bytes(b"\x00" * 256)   # O_CREAT 가 없다
 
        r = subprocess.run(["./prob"], cwd=work, input=FLAG + "\n",
                           capture_output=True, text=True, timeout=30)
        print(f"[1] prob 실행 exit={r.returncode}  stdout={r.stdout.strip()!r}")
 
        ct = (work / "out.txt").read_bytes()
        orig = (HERE / "extracted" / "out.txt").read_bytes()
        print(f"[2] 새 out.txt {len(ct)}바이트, 배포본과 동일? {ct == orig}"
              f"   (키가 time 시드라 매번 달라진다)")
        print(f"    새 out.txt  앞 16바이트 : {ct[:16].hex()}")
        print(f"    배포 out.txt 앞 16바이트 : {orig[:16].hex()}")
 
        got = crack(ct)
        print(f"[3] 새 out.txt 를 같은 방법으로 복호 → {got}")
        print(f"[4] 입력한 플래그와 일치? {got == FLAG}")
        sys.exit(0 if got == FLAG else 1)
 
 
if __name__ == "__main__":
    main()
python3 verify.py
verify.py 왕복 검증 실행 결과 — 복원한 플래그를 prob 에 다시 입력해 만든 새 out.txt 가 배포본과 다른 바이트로 시작하는데도 같은 256 전수 방법으로 복호하면 입력했던 플래그가 그대로 복원되어 마지막 줄에 일치 True 가 찍힌다
verify.py 왕복 검증 실행 결과 — 복원한 플래그를 prob 에 다시 입력해 만든 새 out.txt 가 배포본과 다른 바이트로 시작하는데도 같은 256 전수 방법으로 복호하면 입력했던 플래그가 그대로 복원되어 마지막 줄에 일치 True 가 찍힌다

이번 실행에서 나온 암호문은 c36fb72f... 로 시작해 배포본 e16dfcec... 와 전혀 다르다. 돌릴 때마다 또 바뀐다. 그런데도 같은 절차로 복호하면 넣었던 문자열이 그대로 나온다. 키 유도가 맞다는 확인은 이걸로 충분하다.

FLAG: DH{4e979cd79e571e07d362d3240921c7b9e643082e31029adadfbc4af89b7d0b7f}



📝 결론

안티디버깅을 곱셈으로 만들면 오버플로가 먼저 이긴다

v *= rand() * ptrace(...) 는 아이디어로는 그럴듯하다. 디버거 유무가 곱셈 인자로 들어가니 결과가 갈릴 것 같다. 그런데 32비트 정수에 무작위 값을 4096번 곱하면 2의 인수가 쌓여 0 으로 수렴한다. 디버거가 있든 없든 같은 자리에 도착한다.

분기 대신 산술로 상태를 감추려는 시도는 이런 식으로 자주 무너진다. 누산기가 몇 비트인지, 몇 번 도는지를 세어 보는 게 먼저다.

시간 기반 시드는 값을 좁히면 시드가 아니다

srand(time(0)) 로 뽑은 난수는 그 자체로는 되돌리기 어렵다. 이 문제도 키를 매 실행마다 다르게 만드는 데까지는 성공했다. 무너진 건 그 다음이다. 32비트 난수를 1바이트에 저장하는 순간 엔트로피가 8비트로 줄었고, 16바이트 전부에 같은 값을 쓰는 바람에 후보가 더 늘지도 않았다.

int 를 unsigned char 배열에 넣는 코드는 어디에나 있다. 그게 암호 키를 만드는 자리라면 몇 비트가 살아남는지 한 번은 세어 봐야 한다.

IV 를 0 으로 두면 CBC 는 ECB 만큼 정직해진다

unsigned char ivec[16] = {0} 은 흔한 초기화다. 여기서는 어차피 키가 이미 뚫려서 IV 가 결정적 요인은 아니었지만, IV 가 고정이면 같은 평문이 항상 같은 암호문이 된다. 같은 키로 여러 번 암호화하는 서비스라면 그것만으로도 정보가 샌다. IV 는 매번 난수로 뽑아 암호문 앞에 붙이는 게 기본이다.

정적 분석으로 예측하고 런타임으로 확인하기

이 문제에서 제일 재미있었던 건 gdb 결과였다. ptrace 가 -1 을 돌려주는 걸 확인해 안티디버깅이 발화한 건 맞는데, 정작 키는 예측값과 똑같이 나왔다. 그 어긋남이 오버플로를 짚어 보게 만들었다.

디스어셈블리로 세운 가설을 실행 중 메모리로 한 번 대조하는 습관은 이럴 때 값을 한다. 맞으면 확신이 서고, 어긋나면 놓친 게 뭔지 알려 준다.

이 글이 도움이 됐나요?

Comments

댓글

0개

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

댓글 불러오는 중…

Related

관련 글

3개
[🥉 Bronze 1] ptrace 로 막고 XOR 0x42 로 가린 127바이트 — DreamHack Bismarck의 기출분석 풀이
blog

[🥉 Bronze 1] ptrace 로 막고 XOR 0x42 로 가린 127바이트 — DreamHack Bismarck의 기출분석 풀이

입력을 한 바이트씩 0x42 로 XOR 해서 .rodata 에 박힌 127바이트와 memcmp 하는 크랙미다. 검사식이 XOR 하나뿐이라 그대로 뒤집으면 정답 입력이 복원된다. 앞을 가로막는 건 ptrace 안티디버깅 한 줄인데, 그 한 줄을 어떻게 다루느냐가 이 문제에서 배울 거의 전부다.
#dreamhack#ctf#reversing+7
2026-10-08#dreamhack +7
[🥉 Bronze 2] 분기 미로 뒤에 숨은 상수 한 줄 — DreamHack Labyrinth 풀이
blog

[🥉 Bronze 2] 분기 미로 뒤에 숨은 상수 한 줄 — DreamHack Labyrinth 풀이

14KB 짜리 stripped PIE 하나가 전부인 리버싱 문제. ptrace 안티디버깅과 시드 %7 로 갈라지는 분기 미로가 겹겹이 깔려 있지만, 정답 입력은 .rodata 의 32바이트를 0x30 으로 XOR 한 것이 전부였다. flag 생성기까지 파이썬으로 재구현해 바이너리 출력과 바이트 단위로 대조했다.
#dreamhack#ctf#reversing+6
2026-08-20#dreamhack +7
[🥉 Bronze 2] .rodata 247바이트가 스택 VM 바이트코드였다 — DreamHack SelfStatus 풀이
blog

[🥉 Bronze 2] .rodata 247바이트가 스택 VM 바이트코드였다 — DreamHack SelfStatus 풀이

프로그램이 자기 /proc/self/status 를 읽어 TracerPid 로 디버거를 알아채고 조용히 죽는다. 진짜 검사는 .rodata 에 박힌 247바이트를 도는 스택 VM 이 맡는데, 그 VM 은 사용자 입력을 아예 쳐다보지 않고 정답 문자열을 스스로 조립한다. 그래서 역산할 것이 없다 — VM 만 옮겨 적으면 끝난다.
#dreamhack#ctf#reversing+6
2026-08-19#dreamhack +6