문제: DreamHack 워게임 — Times 분류: reversing 난이도: 🥇 Gold 4 FLAG:
DH{a20f984e48f83e69566e2aee17b491b7fc722ab2}
문제 설명은 이렇다. 2030년에 열리는 콘서트 티켓을 등록하고 싶은데, 등록 프로그램이 "아직 시간이 되지 않았다"며 거절한다. 프로그램을 분석해서 등록 키를 알아내라.
그리고 참고 링크가 딱 두 개 붙어 있다.
문제가 답의 절반을 알려주고 시작하는 셈이다. main 이 아닌 곳에서 뭔가 벌어지고,
디버거를 붙이면 그게 달라진다. 그런데 실제로 풀어 보니 이 문제의 재미는
"안티디버깅이 있다"가 아니라 안티디버깅이 무엇을 망가뜨리는가에 있었다.
./recon.sh
문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | Times |
| 난이도 | 🥇 Gold 4 |
| 분류 | reversing |
| 제공 | 실행파일 times 하나 (x86-64, PIE, stripped) |
| 서버 | 없음 — 로컬에서 끝나는 문제 |
| 핵심 기법 | .init_array 생성자 + ptrace(PTRACE_TRACEME) 결과를 키에 섞기 |
| 부수 기법 | 같은 시드로 두 번 거는 MD5 XOR(자기상쇄) · dword 비트반전 · 데이터 겹치기 |
풀이 흐름은 네 단계다.
-
.init_array에 엔트리가 둘이다. 하나는 컴파일러가 넣은frame_dummy, 나머지 하나가 진짜 생성자다. 여기서 2030년 검사와ptrace가 돈다. -
main은 입력에 세 겹의 변환을 건다. 그중 두 겹이 같은 시드로 만든 같은 MD5 키라 서로 지워진다. 남는 건 dword 단위 비트반전 하나. -
생성자가 만지는 전역 워드는 초기값이 정확히
1234라서, 정상 실행이면 0이 된다. 그런데 그 전역의 주소가memcmp비교 대상의 마지막 바이트와 겹친다. -
그래서 파일에 박힌 41바이트를 dword 비트반전으로 되돌리면 답이 나온다. 단, 마지막 한 바이트는 파일이 아니라 실행 중 값을 봐야 한다.
🧩 배경 — .init_array 는 main 보다 먼저 돈다
문제가 링크한 GCC 문서가 가리키는 건 이거다. C 소스에 이렇게 쓰면
__attribute__((constructor))
void setup(void) { /* ... */ }컴파일러는 setup 의 주소를 .init_array 섹션에 넣는다. 그리고 프로그램이 시작되면
__libc_csu_init(요즘 glibc 는 call_init)이 이 배열을 순서대로 전부 호출한 다음
main 으로 넘어간다.
리버싱 입장에서 이게 왜 중요하냐면, 디스어셈블러를 열고 main 부터 읽기 시작하는 습관이
그대로 함정이 되기 때문이다. main 진입 시점에 이미 전역 상태가 손질돼 있는데,
main 만 보면 그 손질이 어디서 왔는지 알 수 없다.
stripped 바이너리라 심볼이 없으니 더더욱 그렇다. 그래서 rev 문제를 잡으면
.init_array 와 .fini_array 부터 확인하는 게 습관이 될 만하다.
./show_initarray.sh
0x1300 은 endbr64 다음이 곧장 jmp 0x1280 이다. 0x1280 은 __TMC_END__ 를
비교하는 전형적인 register_tm_clones 라서 문제 로직과 무관하다. GCC 가 항상 넣는
frame_dummy 다.
남는 건 0x17d0. 여기가 출제자가 심은 생성자다.
🔬 정찰 — 생성자 한 함수에 문제의 절반이 들어 있다
objdump 로 그 함수만 잘라 본다. 눈에 띄는 명령에는 sed 로 주석을 달았다.
#!/bin/sh
# init_array 두 번째 엔트리(0x17d0)를 잘라 보고, 핵심 명령에 주석을 붙인다.
objdump -d -M intel --start-address=0x17d0 --stop-address=0x183e extracted/times \
| sed -e '1,6d' \
-e 's|\(cmp *rax,0x71ca77ff\)|\1 # <-- 2030-06-30 23:59:59 UTC 게이트|' \
-e 's|\(call.*<puts@plt>\)|\1 # <-- "Not yet !!! Please wait more time."|' \
-e 's|\(call.*<ptrace@plt>\)|\1 # <-- ptrace(PTRACE_TRACEME,"pt","ar","ce")|' \
-e 's|\(add *rax,0x1\)|\1 # <-- 정상 0 -> 1 / 추적당함 -1 -> 0|' \
-e 's|\(imul *rax,rax,0x4d2\)|\1 # <-- x1234|' \
-e 's|\(xor *eax,edx\)|\1 # <-- 전역워드 ^= 결과|'
두 부분으로 나뉜다.
앞쪽 — 시간 게이트.
mov edi, 0x0
call time@plt
cmp rax, 0x71ca77ff ; 1909094399
jg .ok
lea rdi, [rip+0xa2f] ; "Not yet !!! Please wait more time."
call puts@plt
mov edi, 0x0
call exit@plt0x71ca77ff 는 1909094399 초, UTC 기준 2030-06-30 23:59:59 다. 그보다 커야 통과하니
정확히는 "2030년 7월 1일부터". 문제 설명의 2030년 콘서트가 여기서 나온 것이다.
통과 못 하면 exit(0) 이라 main 은 실행조차 안 된다.
뒤쪽 — ptrace.
mov ecx, 0x6563 ; "ce"
mov edx, 0x6172 ; "ar"
mov esi, 0x7470 ; "pt"
mov edi, 0x0 ; PTRACE_TRACEME
mov eax, 0x0
call ptrace@plt
add rax, 0x1
imul rax, rax, 0x4d2 ; 1234
mov edx, eax
movzx eax, WORD PTR [rip+0x2816] ; 전역 0x4048
xor eax, edx
mov WORD PTR [rip+0x280d], ax인자 셋이 "pt", "ar", "ce" 다. PTRACE_TRACEME 는 나머지 인자를 무시하니
아무 값이나 넣어도 되는데, 출제자가 ptrace 를 세 조각으로 쪼개 넣어 뒀다.
기능상 의미는 없고 읽는 사람 보라고 넣은 사인이다.
중요한 건 반환값 처리다.
| 상황 | ptrace 반환 | +1 | ×1234 |
|---|---|---|---|
| 정상 실행 | 0 (성공) | 1 | 1234 |
| 디버거가 붙어 있음 | -1 (EPERM) | 0 | 0 |
즉 정상이면 전역 워드에 1234를 XOR 하고, 추적당하는 중이면 아무것도 안 한다.
보통의 안티디버깅은 "추적당하면 죽는다"인데 이건 반대다. 죽지 않고, 조용히 계산 하나를 건너뛴다. 프로그램은 끝까지 잘 돌고 결과만 틀리게 나온다.
🧱 배경 — PTRACE_TRACEME 를 안티디버깅으로 쓰는 두 가지 방식
ptrace(PTRACE_TRACEME, 0, 0, 0) 은 원래 "나를 내 부모가 추적하게 해 달라"는 요청이다.
디버거는 이미 자기가 추적자로 붙어 있는 프로세스에 이 호출이 들어오면 -1 을 돌려준다.
한 프로세스에 추적자는 하나뿐이기 때문이다.
이걸 방어에 쓰는 방법은 크게 둘이다.
1) 자폭형. 반환값이 -1 이면 exit 하거나 SIGKILL 을 쏜다. 구현이 쉽고 눈에 잘 띈다.
그래서 우회도 쉽다 — ptrace PLT 를 xor eax,eax; ret 로 패치하거나,
LD_PRELOAD 로 ptrace 를 0 반환 함수로 덮어쓰면 끝난다.
2) 혼입형. 반환값을 연산에 섞는다. 이 문제가 그렇다.
혼입형이 성가신 이유는 우회 지점이 명확하지 않아서다. 자폭형은 "여기서 죽는다"는 지점이
보이는데, 혼입형은 프로그램이 정상 종료하기 때문에 어디가 틀어졌는지 표시가 안 난다.
Registration failed.. 만 보고 "키가 틀렸나 보다" 하고 엉뚱한 데를 파게 된다.
게다가 이 문제는 ptrace 를 생성자 안에서 호출한다. main 에 브레이크포인트를 걸고
거기서부터 보기 시작하면 이미 늦었다.
말로만 하면 믿기 어려우니 실제로 잡아 보는 게 낫다. gdb 를 배치 모드로 돌려
ptrace 반환 직후와 전역 갱신 직후에 각각 멈추고 값을 찍었다.
# cmds_antidebug.gdb — ptrace 안티디버깅이 전역 워드를 바꾸는 순간을 실제로 잡는다.
#
# gdb -q -batch -x cmds_antidebug.gdb --args ./extracted/times <아무 코드>
#
# PIE 라 로드 베이스를 가정하면 안 된다. starti 는 동적로더(ld.so)의 _start 에서
# 멈추므로 그 시점 $pc 로 베이스를 계산하면 ld.so 의 베이스가 나온다(실제로 한 번 틀렸다).
# info proc mappings 에서 실행파일 경로가 붙은 첫 매핑을 읽어야 맞다.
set confirm off
set pagination off
set environment LD_PRELOAD=./timewarp.so
starti
python
import gdb
GLOBAL_RVA = 0x4048 # ctor 가 XOR 하는 전역 워드
AFTER_PTRACE = 0x181e # call ptrace 바로 다음 (add rax,0x1)
AFTER_STORE = 0x183b # mov WORD PTR [rip+0x280d],ax 바로 다음
maps = gdb.execute("info proc mappings", to_string=True)
base = None
for line in maps.splitlines():
if line.rstrip().endswith("/times"):
base = int(line.split()[0], 16)
break
if base is None:
raise gdb.GdbError("실행파일 매핑을 못 찾았다")
print("[gdb] 실행파일 로드 베이스 = 0x%x (info proc mappings 에서 읽음)" % base)
def word():
return int(gdb.parse_and_eval("*(unsigned short *)0x%x" % (base + GLOBAL_RVA)))
print("[gdb] ctor 실행 전 전역워드 = 0x%04x" % word())
gdb.Breakpoint("*0x%x" % (base + AFTER_PTRACE), temporary=True)
gdb.execute("continue")
rax = int(gdb.parse_and_eval("$rax"))
print("[gdb] ptrace(PTRACE_TRACEME) 반환 = %d (0=성공 / -1=이미 추적당하는 중)" % rax)
print("[gdb] 따라서 (rax+1)*1234 = %d" % (((rax + 1) * 1234) & 0xFFFF))
gdb.Breakpoint("*0x%x" % (base + AFTER_STORE), temporary=True)
gdb.execute("continue")
print("[gdb] ctor 실행 후 전역워드 = 0x%04x <- 1234 가 살아남았다" % word())
end
kill
quit
ptrace(PTRACE_TRACEME) 반환 -1, (rax+1)*1234 = 0, 전역 워드는 0x04d2 유지.
디버거를 붙였다는 사실이 그대로 데이터에 남았다.
🔬 정찰 — main 의 세 겹 변환
이제 main(0x183e)을 읽는다. 인자 검사부터 memcmp 까지 흐름이 길지 않아
그대로 C 로 옮겨 적을 수 있다.
int main(int argc, char **argv) {
if (argc != 2) {
printf("%s [registration code]", argv[0]);
return 1;
}
char *buf = strdup(argv[1]);
int len = strlen(buf);
puts("Welcome to registration center");
/* ---- 라운드 1 : MD5 키로 바이트별 XOR ---- */
int t = time(0);
srand(t);
int seed = rand() + rand();
unsigned char key[16] = {0};
md5(&seed, 4, key);
for (int i = 0; i < len; i++) {
buf[i] ^= key[(4*i + 0) & 15];
buf[i] ^= key[(4*i + 1) & 15];
buf[i] ^= key[(4*i + 2) & 15];
buf[i] ^= key[(4*i + 3) & 15];
}
/* ---- 워드 층 : 전역 워드로 16비트 XOR ---- */
for (int j = 0; j < len / 2; j++)
((uint16_t *)buf)[j] ^= g_word; /* g_word = *(uint16_t*)0x4048 */
/* ---- 라운드 2 : 라운드 1과 완전히 동일 ---- */
t = time(0);
srand(t);
seed = rand() + rand();
memset(key, 0, 16);
md5(&seed, 4, key);
for (int i = 0; i < len; i++) {
buf[i] ^= key[(4*i + 0) & 15];
buf[i] ^= key[(4*i + 1) & 15];
buf[i] ^= key[(4*i + 2) & 15];
buf[i] ^= key[(4*i + 3) & 15];
}
/* ---- 비트반전 층 : dword 단위 32비트 전체 반전 ---- */
for (int k = 0; k < len / 4; k++)
((uint32_t *)buf)[k] = bitreverse32(((uint32_t *)buf)[k]);
if (memcmp(buf, TARGET, 0x29) == 0)
puts("Registration done !");
else
puts("Registration failed..");
return 0;
}md5 라고 단정한 함수는 0x13ad 다. 근거는 상수다.
#!/bin/sh
# 0x13ad 이 MD5 라는 근거: 초기 상태 상수 4개 + .rodata 의 K 테이블/시프트 테이블
echo "### 초기 상태 A,B,C,D (0x13e8) ###"
objdump -d -M intel --start-address=0x13e8 --stop-address=0x1410 extracted/times | sed -e '1,6d'
echo
echo "### K 테이블 (0x2020) — 리틀엔디언으로 d76aa478, e8c7b756, ... = MD5 상수 ###"
readelf -x .rodata extracted/times | sed -n '4,7p'
echo
echo "### 라운드 시프트량 테이블 (0x2120) — 7,12,17,22 로 시작하면 MD5 ###"
readelf -x .rodata extracted/times | sed -n '20,21p'
초기 상태 네 개(0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476)에
0xd76aa478 로 시작하는 64개 K 테이블, 그리고 7, 12, 17, 22 시프트량까지.
교과서 MD5 그대로다. 라운드 함수 분기도 i <= 15 / 31 / 47 로 나뉘어 있어
F·G·H·I 네 함수가 순서대로 나온다.
그런데 실은 MD5 를 구현할 필요가 없다. 이유는 다음 절에 있다.
💣 핵심 1 — 두 겹은 스스로 지워진다
main 을 다시 보면 시드를 만드는 코드가 두 번 나온다. 완전히 같은 모양이다.
./show_srand.sh
time(0) → srand → rand() 두 번 → 더해서 [rbp-0x54] 에 저장.
명령 하나까지 같다. 두 블록 사이 간격은 XOR 루프 몇 개뿐이라
실행 시간이 마이크로초 단위다.
time(0) 은 초 단위 값이다. 두 호출이 같은 초에 들어가면 시드가 같고,
시드가 같으면 rand() 수열이 같고, 따라서 MD5 키 16바이트도 완전히 같다.
그리고 두 라운드가 거는 연산은 XOR이다. 같은 값을 두 번 XOR 하면 원래대로 돌아온다.
결과 = 원본 ^ K ^ G ^ K (K = MD5 키에서 나온 바이트별 마스크, G = 전역 워드 마스크)
= 원본 ^ GXOR 은 교환·결합이 되니 순서를 바꿔 묶으면 K 가 서로 지워진다.
MD5 를 아무리 열심히 읽어도 결과에는 영향이 없다는 뜻이다.
이게 이 문제의 첫 번째 장치다. 분량으로 겁을 주는 코드다. 디스어셈블 화면의 절반이 MD5인데, 그 절반이 통째로 항등변환이다.
덧붙이면, 설령 상쇄되지 않았더라도 이 XOR 층은 생각보다 얕다.
바이트 i 가 쓰는 키 인덱스를 펼쳐 보면 이렇다.
i 번째 바이트 마스크 = key[(4i+0)&15] ^ key[(4i+1)&15]
^ key[(4i+2)&15] ^ key[(4i+3)&15]4i mod 16 은 4 × (i mod 4) 다. 그러니 네 인덱스는 항상
key[4m], key[4m+1], key[4m+2], key[4m+3] 라는 4바이트 정렬된 한 묶음이고,
m = i mod 4 다.
결국 서로 다른 마스크 바이트는 넷뿐이고, 그게 i 에 대해 주기 4로 반복된다.
16바이트 키를 썼지만 실질 엔트로피는 4바이트다.
시드가 32비트 time() 기반인 것까지 감안하면, 상쇄를 못 봤더라도
전수 탐색으로 넘어갈 수 있는 층이었다.
물론 두 time(0) 이 초 경계를 사이에 두고 갈라지면 키가 달라져 실패한다.
가능성이 없지는 않아서 실제로 반복 실행해 봤다.
#!/bin/sh
# main 이 srand(time(0)) 를 두 번 호출한다. 두 호출이 같은 초에 들어가야 MD5 층이 상쇄된다.
# 실제로 갈라지는 일이 있는지 반복 실행으로 확인한다.
N=${1:-400}
ok=0; ng=0
i=0
while [ $i -lt $N ]; do
out=$(LD_PRELOAD=./timewarp.so ./extracted/times a20f984e48f83e69566e2aee17b491b7fc722ab2 | tail -1)
if [ "$out" = "Registration done !" ]; then ok=$((ok+1)); else ng=$((ng+1)); fi
i=$((i+1))
done
echo "$N 회 실행 -> 성공 $ok / 실패 $ng"
400회 전부 성공했다. 두 호출 사이 실행 시간이 워낙 짧아서 실측으로는 안 걸린 것이고, 이론적으로 0은 아니다. 이 문제에서는 신경 쓰지 않아도 되는 수준이라는 정도로 정리했다.
💣 핵심 2 — 비교 대상의 마지막 바이트가 전역 워드다
남은 층은 bitreverse32 하나다. 0x174a 의 그 함수는 마스크 여덟 단계로
32비트를 통째로 뒤집는다.
; 0x174a — 32비트 전체 비트반전
add eax, eax
and eax, 0xaaaaaaaa ; 홀수 비트를 왼쪽으로
shr eax, 1
and eax, 0x55555555 ; 짝수 비트를 오른쪽으로
or eax, edx ; 1비트 단위 교환
... ; 2 → 4 → 8비트 단위로 같은 패턴 반복
rol DWORD PTR [rbp-0x4], 0x10 ; 마지막 16비트 회전비트반전은 자기역함수다. 한 번 더 걸면 원래대로 돌아온다. 그러니 파일에 박힌 비교 대상을 그대로 뒤집으면 답이 나와야 한다.
비교 대상은 memcmp(buf, 0x4020, 0x29) — .data 의 0x4020 부터 41바이트다.
./show_data.sh
여기서 걸린다. 41바이트면 0x4020 부터 0x4048 까지인데,
0x4048 은 아까 생성자가 XOR 하던 그 전역 워드의 주소다.
비교 대상의 마지막 바이트와 전역 워드의 하위 바이트가 같은 자리다.
그리고 그 자리 초기값이 d2 04, 즉 0x04d2 = 1234.
생성자가 XOR 하는 값과 정확히 같다.
정리하면 이렇게 된다.
| 전역 워드 실행 중 값 | 비교 대상 41번째 바이트 | 워드 XOR 층 | |
|---|---|---|---|
| 정상 실행 | 0x0000 | 0x00 | 항등 (아무 일도 안 일어남) |
| 디버거 부착 | 0x04d2 | 0xd2 | 모든 워드가 오염 |
즉 하나의 상수가 두 군데에서 동시에 역할을 한다.
-
정상 실행이면 워드 XOR 층이 항등이 되고, 비교 대상 마지막 바이트는
0x00이 된다. 이건strdup이 복사한 문자열의 NUL 종료 바이트와 맞아떨어진다. 다시 말해 정답은 40글자이고, 41번째로 비교되는 건 문자열 끝의 NUL 이다. -
디버거를 붙이면 워드 XOR 층이 살아나 입력을 전부 오염시키고, 동시에 비교 대상 마지막 바이트가
0xd2로 남아 어차피 맞을 수 없게 된다.
한 줄로 줄이면 — 관찰하는 순간 정답이 바뀐다.
🐛 삽질
▶🐛 삽질 1 — 41바이트를 그대로 뒤집었더니 마지막 글자가 0xd2
memcmp 길이가 0x29 니까 정답도 41자겠거니 하고 그대로 되돌려 봤다.
40바이트까지는 멀쩡한 hex 문자열이 나오는데 마지막 한 바이트가 0xd2 다.
#!/usr/bin/env python3
"""
naive_reverse.py — memcmp 길이(0x29=41)를 그대로 '정답 길이'로 믿었을 때 나오는 결과.
파일에 박힌 41바이트를 그대로 dword 비트반전해서 되돌리면 40자까지는 멀쩡한
hex 문자열이 나오는데, 41번째 바이트만 0xd2 로 남는다. 명령행 인자로는 넣을 수 없는 값이다.
"""
from pathlib import Path
blob = Path(__file__).with_name("extracted").joinpath("times").read_bytes()
target = blob[0x3020:0x3020 + 0x29] # .data 파일오프셋 0x3000 + (0x4020-0x4000)
def brev32(x):
return int(format(x, "032b")[::-1], 2)
out = bytearray()
for k in range(len(target) // 4): # 41 // 4 = 10 dword
out += brev32(int.from_bytes(target[k * 4:k * 4 + 4], "little")).to_bytes(4, "little")
out += target[40:] # 남는 1바이트는 변환 대상이 아니다
print("되돌린 41바이트:", out.hex())
print("앞 40바이트 :", out[:40].decode())
print("41번째 바이트 : 0x%02x <- 출력 불가, argv 로 전달할 수 없다" % out[40])
print()
print("파일의 41번째 바이트가 곧 ctor 이 만지는 전역 워드의 하위 바이트다.")
print("실행 중에는 그 값이 바뀌어 있을 수 있다 -> 파일만 보고 판단하면 안 된다.")
0xd2 는 출력 가능한 문자가 아니다. 셸에서 인자로 넘길 방법이 마땅치 않다.
길이 계산이나 비트반전 순서가 틀렸나 싶어 한참 다시 봤는데 그쪽은 멀쩡했다.
풀린 건 주소를 다시 봤을 때다. 0x4020 + 0x29 - 1 = 0x4048.
생성자가 만지는 그 주소다. 파일에 있는 값과 실행 중 값이 다른 자리였다.
정적 분석만으로 답을 뽑으려던 게 문제였다. 비교 대상이 상수라고 믿었는데 그중 한 바이트는 상수가 아니었다.
▶🐛 삽질 2 — faketime 이 없다
시간 게이트를 넘겨야 프로그램이 돈다. 보통 faketime 으로 해결하는데
설치돼 있지 않았고, 이 확인 하나 하자고 패키지를 새로 깔고 싶지도 않았다.
선택지는 셋이었다.
- 시스템 시계를 2030년으로 돌린다 — 다른 작업이 다 망가진다. 제외.
- 바이너리를 패치한다 —
jg를jmp로 바꾸면 되지만, 패치한 바이너리로 검증하면 "원본이 정말 이 답을 받아들이는가"를 증명하지 못한다. time()만 가로챈다 — 원본 바이너리를 그대로 두고 라이브러리 호출만 바꾼다.
3번을 택했다. LD_PRELOAD 로 time() 하나만 덮는 20줄짜리 심이면 충분하다.
/*
* timewarp.c — times 바이너리의 2030년 게이트를 넘기기 위한 최소 LD_PRELOAD 심.
*
* 생성자(0x17d0)가 time(0) <= 0x71CA77FF(2030-06-30 23:59:59 UTC) 면
* "Not yet !!! Please wait more time." 를 찍고 exit 해 버린다.
* libfaketime 이 없는 환경이라 time() 하나만 가로채도록 직접 만들었다.
*
* 상수를 돌려주지 않고 "실제 시각 + 오프셋" 을 돌려주는 이유:
* main 이 srand(time(0)) 을 두 번 호출해 그 값이 같아야 MD5 층이 상쇄되는데,
* 상수로 고정하면 그 조건이 항상 참이 되어 원래 프로그램의 성질을 감춘다.
*
* gcc -shared -fPIC -O2 -o timewarp.so timewarp.c
* LD_PRELOAD=./timewarp.so ./extracted/times <code>
*/
#define _GNU_SOURCE
#include <time.h>
#include <dlfcn.h>
/* 2030-06-30 23:59:59 UTC 이후로 넉넉히 밀어 준다 (약 6.5년) */
#define WARP_SECONDS 205000000L
time_t time(time_t *tloc) {
static time_t (*real_time)(time_t *) = NULL;
if (!real_time)
real_time = (time_t (*)(time_t *))dlsym(RTLD_NEXT, "time");
time_t t = real_time(NULL) + WARP_SECONDS;
if (tloc)
*tloc = t;
return t;
}상수를 반환하지 않고 실제 시각에 오프셋을 더한 게 의도적이다.
상수를 돌려주면 두 srand 호출이 무조건 같은 시드를 받게 되어,
앞에서 확인한 초 경계 문제가 원천적으로 사라진다.
검증 환경이 원본보다 관대해지는 셈이라 그러고 싶지 않았다.
ptrace 는 건드리지 않았다. LD_PRELOAD 자체는 추적이 아니라서
안티디버깅이 발동하지 않는다.
▶🐛 삽질 3 — starti 로 PIE 베이스를 구했다가 ld.so 를 잡았다
PIE 바이너리에 주소로 브레이크포인트를 걸려면 로드 베이스를 알아야 한다.
starti 로 첫 명령에서 멈춘 뒤 $pc - 엔트리RVA 로 계산하면 된다고 생각했다.
ENTRY_RVA = 0x1220 # readelf -h 의 Entry point address
base = int(gdb.parse_and_eval("$pc")) - ENTRY_RVA # <- 여기가 틀렸다결과는 이랬다.

베이스가 0x7ffff7fdff20. PIE 실행파일이 보통 잡는 0x555555554000 대역이 아니다.
전역 워드를 읽으니 0xbe6c 라는 엉뚱한 값이 나왔고,
브레이크포인트는 ./elf/rtld.c, line 267 에 걸렸다.
starti 가 멈추는 곳은 실행파일의 _start 가 아니라 동적로더(ld.so)의 _start 다.
동적 링크 바이너리는 커널이 먼저 인터프리터에 제어를 넘기기 때문이다.
gdb 출력 첫 줄에 _start () from /lib64/ld-linux-x86-64.so.2 라고 친절하게 적혀 있는데
그냥 지나쳤다.
브레이크포인트가 ld.so 안 엉뚱한 곳에 걸렸으니 당연히 그 지점을 지나가지 않았고,
프로그램이 그대로 끝난 뒤 $rax 를 읽으려다 No registers. 로 죽었다.
고친 방법은 가정하지 말고 물어보는 것이다.
maps = gdb.execute("info proc mappings", to_string=True)
for line in maps.splitlines():
if line.rstrip().endswith("/times"):
base = int(line.split()[0], 16)
break0x555555554000 이 나왔다. 관례로 아는 값이지만, 관례를 코드에 박지 않고
매핑에서 읽은 값이라 ASLR 설정이 달라져도 그대로 돈다.
🎯 되돌리기
정리된 결론은 짧다.
- 정상 실행에서 남는 변환은 dword 단위 비트반전 하나뿐이다.
- 비트반전은 자기역함수라 한 번 더 걸면 원문이 나온다.
- 비교 대상 41바이트 중 마지막 하나는 실행 중
0x00이 되고, 이건 문자열 NUL 이다. - 따라서 정답은 앞 40바이트를 dword 비트반전한 것.
solve.py 는 이걸 그대로 옮긴 것이다. 바이너리에서 직접 값을 읽게 만들어서
글에 박힌 상수를 믿지 않아도 되도록 했다.
#!/usr/bin/env python3
"""
DreamHack wargame "Times" (Gold 4, reversing) - solver
바이너리가 argv[1] 에 하는 일 (main = 0x183e):
buf = strdup(argv[1]); len = strlen(buf);
[라운드1] srand(time(0)); seed = rand() + rand();
MD5(&seed, 4) -> key[16]
for i in 0..len-1:
buf[i] ^= key[(4i+0)&15] ^ key[(4i+1)&15]
^ key[(4i+2)&15] ^ key[(4i+3)&15]
[워드층] for j in 0..len/2-1:
((u16*)buf)[j] ^= WORD[0x4048]
[라운드2] srand(time(0)); seed = rand() + rand(); <- 같은 초면 같은 시드
MD5(&seed, 4) -> key[16]
(라운드1과 완전히 동일한 XOR) <- 그래서 서로 상쇄된다
[비트반전] for k in 0..len/4-1:
((u32*)buf)[k] = bitreverse32(((u32*)buf)[k])
memcmp(buf, TARGET(0x4020), 0x29) == 0 -> "Registration done !"
WORD[0x4048] 은 생성자(0x17d0)가
WORD[0x4048] ^= (ptrace(PTRACE_TRACEME,...) + 1) * 1234
로 갱신한다. 초기값이 0x04D2(=1234)이므로
디버거 없음: ptrace= 0 -> (0+1)*1234 = 1234 -> 0x04D2 ^ 1234 = 0x0000
디버거 붙음: ptrace=-1 -> (-1+1)*1234 = 0 -> 0x04D2 그대로
즉 정상 실행에서는 워드층이 항등이고, MD5 층은 두 번 걸려 상쇄되므로
남는 변환은 dword 단위 비트반전 하나뿐이다.
게다가 0x4048 은 TARGET(0x4020, 41바이트)의 **마지막 바이트를 겸한다.**
정상 실행이면 그 자리가 0x00 이 되어 strdup 문자열의 NUL 과 맞물린다
-> 입력 길이는 40 이어야 한다.
따라서 답은 TARGET 앞 40바이트를 dword 단위로 비트반전한 것.
"""
from pathlib import Path
ELF = Path(__file__).with_name("extracted") / "times"
# .data: 가상주소 0x4000 <-> 파일오프셋 0x3000 (readelf -S 로 확인)
DATA_VADDR, DATA_OFF = 0x4000, 0x3000
TARGET_VADDR, TARGET_LEN = 0x4020, 0x29 # memcmp 인자 그대로
GLOBAL_VADDR = 0x4048 # ctor 가 건드리는 전역 워드
def bitreverse32(x: int) -> int:
"""0x174a 의 shift/mask 8단계와 동치인 32비트 전체 비트 반전 (자기역함수)."""
return int(format(x & 0xFFFFFFFF, "032b")[::-1], 2)
def main() -> None:
blob = ELF.read_bytes()
off = TARGET_OFF = TARGET_VADDR - DATA_VADDR + DATA_OFF
target = bytearray(blob[off:off + TARGET_LEN])
g_off = GLOBAL_VADDR - DATA_VADDR + DATA_OFF
g_init = int.from_bytes(blob[g_off:g_off + 2], "little")
g_run = g_init ^ ((0 + 1) * 1234 & 0xFFFF) # 비디버깅 실행값
print(f"[*] TARGET @0x{TARGET_VADDR:x} ({TARGET_LEN}바이트)")
print(f" {target.hex()}")
print(f"[*] 전역워드 @0x{GLOBAL_VADDR:x}: 초기 0x{g_init:04x}"
f" -> ctor 통과 후 0x{g_run:04x}"
f" ({'항등' if g_run == 0 else '오염'})")
# ctor 가 전역을 갱신하면 TARGET 의 마지막 바이트도 같이 바뀐다(주소가 겹친다)
target[GLOBAL_VADDR - TARGET_VADDR] = g_run & 0xFF
n = TARGET_LEN - 1 # NUL 을 뺀 실제 코드 길이 = 40
print(f"[*] 겹침 반영 후 마지막 바이트 0x{target[n]:02x} -> 입력 길이 {n}")
# dword 비트반전은 자기역함수라 그대로 한 번 더 걸면 원문이 나온다
out = bytearray()
for k in range(n // 4):
d = int.from_bytes(target[k * 4:k * 4 + 4], "little")
out += bitreverse32(d).to_bytes(4, "little")
code = bytes(out)
print(f"[+] 등록키({len(code)}자): {code.decode()}")
print(f"[+] FLAG: DH{{{code.decode()}}}")
if __name__ == "__main__":
main()
a20f984e48f83e69566e2aee17b491b7fc722ab2 — 40자 hex 문자열이다.
길이와 문자 구성으로 보아 출제자가 어떤 값의 SHA-1 을 넣어 둔 것으로 보인다.
🚀 검증 — 원본 바이너리가 실제로 받아 주는가
계산이 맞아떨어졌다고 끝은 아니다. 원본 바이너리에 그대로 넣어서 확인한다.
#!/bin/sh
# 로컬 검증: 시간 게이트 -> 오답 -> 정답 순으로 실제 실행한다.
gcc -shared -fPIC -O2 -o timewarp.so timewarp.c
KEY=a20f984e48f83e69566e2aee17b491b7fc722ab2
echo "### 1) 심 없이 그대로 실행 — 2030년 게이트 ###"
./extracted/times $KEY
echo
echo "### 2) timewarp.so 로 시간만 밀어주고, 틀린 코드 ###"
LD_PRELOAD=./timewarp.so ./extracted/times AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
echo
echo "### 3) solve.py 가 계산한 코드 ###"
LD_PRELOAD=./timewarp.so ./extracted/times $KEY
세 줄이 예상대로 나왔다. 같은 40자 길이의 더미(AAAA…)를 먼저 넣어서
"길이만 맞으면 통과하는 것 아니냐"는 가능성을 지웠다.
🔬 관찰 — 디버거 없이 memcmp 직전을 들여다보기
여기서 한 걸음 더 갔다. Registration done ! 은 결과일 뿐이고,
앞에서 세운 주장(워드 층이 항등이다, 마지막 바이트가 NUL 이다)을 직접 보고 싶었다.
문제는 gdb 를 붙이는 순간 그 주장이 성립하지 않게 된다는 것이다. 관찰 도구가 관찰 대상을 바꾼다.
LD_PRELOAD 는 추적이 아니라 심볼 해석 순서를 바꾸는 것뿐이라
ptrace(PTRACE_TRACEME) 가 그대로 성공한다. 그래서 memcmp 를 가로채는
관찰자를 하나 더 만들었다.
/*
* probe.c — 디버거를 붙이지 않고 memcmp 직전 상태를 들여다보는 LD_PRELOAD 관찰자.
*
* 이 문제의 안티디버깅은 ptrace(PTRACE_TRACEME) 반환값을 키 계산에 섞는다.
* 그래서 gdb 로 붙는 순간 결과가 달라진다 — 관찰 행위가 대상을 바꾼다.
* LD_PRELOAD 는 ptrace 를 건드리지 않으므로 "정상 실행 그대로"를 관찰할 수 있다.
*
* 하는 일:
* 1) 실행파일의 로드 베이스를 dl_iterate_phdr 로 구해 전역 워드(+0x4048) 를 읽는다
* 2) memcmp(_, _, 0x29) 호출을 가로채 변환된 입력과 비교 대상을 나란히 찍는다
*
* gcc -shared -fPIC -O2 -o probe.so probe.c
* LD_PRELOAD="./timewarp.so ./probe.so" ./extracted/times <code>
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <link.h>
#include <dlfcn.h>
#define GLOBAL_RVA 0x4048 /* ctor 가 XOR 하는 전역 워드 */
#define TARGET_LEN 0x29 /* main 의 memcmp 길이 */
static uintptr_t exe_base;
static int find_exe(struct dl_phdr_info *info, size_t sz, void *unused) {
(void)sz; (void)unused;
if (info->dlpi_name && info->dlpi_name[0] == '\0') { /* 이름이 빈 것 = 본체 */
exe_base = info->dlpi_addr;
return 1;
}
return 0;
}
__attribute__((constructor))
static void probe_init(void) {
dl_iterate_phdr(find_exe, NULL);
}
static void dump(const char *label, const unsigned char *p, size_t n) {
printf(" %-14s ", label);
for (size_t i = 0; i < n; i++)
printf("%02x", p[i]);
printf("\n");
}
int memcmp(const void *a, const void *b, size_t n) {
static int (*real)(const void *, const void *, size_t);
if (!real)
real = (int (*)(const void *, const void *, size_t))dlsym(RTLD_NEXT, "memcmp");
if (n == TARGET_LEN && exe_base) {
uint16_t g = *(uint16_t *)(exe_base + GLOBAL_RVA);
printf("[probe] memcmp(len=0x%zx) 가로챔\n", n);
printf(" 전역워드@+0x%x 0x%04x (%s)\n", GLOBAL_RVA, g,
g ? "디버거 감지됨 — 워드층이 오염된다" : "정상 실행 — 워드층은 항등");
dump("변환된 입력", (const unsigned char *)a, n);
dump("비교 대상", (const unsigned char *)b, n);
printf(" 판정: %s\n", real(a, b, n) == 0 ? "일치" : "불일치");
}
return real(a, b, n);
}n == 0x29 일 때만 찍는다. 이 조건이 없으면 동적로더와 libc 내부의
memcmp 호출까지 전부 걸려 출력이 쓰레기가 된다.
정상 실행에서 돌린 결과다.

전역 워드 0x0000, 두 줄이 마지막 00 까지 한 글자도 다르지 않다.
정적 분석으로 세운 주장이 실행 중 메모리에서 그대로 확인됐다.
이제 같은 관찰자를 gdb 아래에서 돌린다. 입력은 그대로 정답 키다.

같은 바이너리, 같은 입력, 같은 관찰자인데 결과가 정반대다.
- 전역 워드가
0x04d2로 남았다 → 워드 XOR 층이 살아나 변환된 입력이 통째로 달라졌다. - 비교 대상 마지막 바이트가
00이 아니라d2다 → 한 상수가 두 군데를 동시에 망가뜨린다.
이 두 화면을 나란히 놓는 게 이 문제의 핵심을 가장 정확하게 보여준다고 생각한다.
Registration done ! 과 Registration failed.. 만으로는 무엇이 달라졌는지 알 수 없다.
ptrace 를 LD_PRELOAD 로 덮어 0 을 반환시키면 gdb 아래에서도 정상 결과를 볼 수 있다.
다만 이 문제는 거기까지 갈 필요가 없었다. 정적 분석으로 답이 나왔고,
검증은 디버거 없이도 충분했다.
🚀 재현
작업 폴더를 그대로 옮겨 놓고 아래 하나만 돌리면 빌드부터 검증까지 끝난다.
#!/bin/sh
# reproduce.sh — DreamHack "Times"(Gold 4, reversing) 재현 스크립트.
# 빌드 -> 정답 계산 -> 로컬 실행 검증 -> 관찰까지 한 번에.
#
# 사용법: ./reproduce.sh
# 필요: gcc, python3, objdump/readelf (binutils)
set -e
cd "$(dirname "$0")"
if [ ! -f extracted/times ]; then
echo "extracted/times 가 없다. challenge_247.zip 을 extracted/ 로 풀어라." >&2
exit 1
fi
chmod +x extracted/times
echo "=== [1/4] LD_PRELOAD 심 빌드 ==="
gcc -shared -fPIC -O2 -o timewarp.so timewarp.c
gcc -shared -fPIC -O2 -o probe.so probe.c
echo
echo "=== [2/4] 바이너리에서 정답 계산 ==="
KEY=$(python3 solve.py | sed -n 's/^\[+\] 등록키([0-9]*자): //p')
echo "계산된 등록키: $KEY"
echo
echo "=== [3/4] 실제 실행으로 검증 ==="
OUT=$(LD_PRELOAD=./timewarp.so ./extracted/times "$KEY" | tail -1)
echo "프로그램 출력: $OUT"
[ "$OUT" = "Registration done !" ] || { echo "검증 실패" >&2; exit 1; }
echo
echo "=== [4/4] memcmp 직전 상태 관찰 (디버거 없이) ==="
LD_PRELOAD="./timewarp.so ./probe.so" ./extracted/times "$KEY" | sed -n '/probe/,$p'
echo
echo "FLAG: DH{$KEY}"gcc, python3, binutils 만 있으면 된다. 문제 서버는 필요 없다.
플래그는 등록 키에 DH{} 를 씌운 것이다.
DH{a20f984e48f83e69566e2aee17b491b7fc722ab2}📝 결론
main 부터 읽는 습관이 이 문제의 첫 번째 함정이다.
.init_array 는 문법 하나로 실행 흐름의 앞단을 통째로 확보한다.
main 에 브레이크포인트를 걸고 거기서부터 보기 시작하면 이미 전역 상태가 손질된 뒤다.
stripped 바이너리에서는 그 손질이 어디서 왔는지 추적할 단서도 없다.
문제가 GCC 문서를 대놓고 링크해 준 건 이 습관을 건드리려는 의도였다고 본다.
rev 문제를 열면 readelf -x .init_array 부터 찍어 보는 게 손해가 아니다.
두 번째는 안티디버깅이 죽이는 대신 값을 바꾼다는 점이다.
ptrace(PTRACE_TRACEME) 를 자폭 스위치로 쓰면 우회 지점이 눈에 보인다.
반환값을 연산에 섞으면 프로그램은 끝까지 정상 종료하고 결과만 달라진다.
Registration failed.. 만 보고서는 키가 틀린 건지 관찰 때문에 틀어진 건지 구분이 안 된다.
방어자 관점에서는 이게 훨씬 낫고, 분석자 관점에서는 관찰 방식을 바꾸는 것이 답이다.
이번에는 LD_PRELOAD 로 memcmp 를 가로채서, ptrace 를 건드리지 않은 채로
필요한 값을 다 봤다. 디버거만이 관찰 수단은 아니다.
세 번째는 데이터를 겹쳐 놓는 수법이다.
0x4048 이라는 주소 하나가 "생성자가 만지는 전역"이면서 동시에
"비교 대상의 마지막 바이트"였다. 초기값 0x04d2 가 XOR 상수 1234와 같아서,
정상 실행이면 그 자리가 0x00 — 문자열 NUL 과 맞물린다.
정적 덤프만 보고 상수라고 믿었던 게 삽질의 원인이었다.
.data 는 쓰기 가능한 섹션이고, 파일에 박힌 값은 초기값일 뿐이다.
비교 대상의 주소 범위와 코드가 쓰는 전역의 주소 범위가 겹치지 않는지
한 번 확인하는 습관이 필요하다.
마지막으로, 분량으로 겁주는 코드를 알아보는 것.
디스어셈블의 절반이 MD5였는데 그게 통째로 항등변환이었다. 같은 시드로 같은 XOR 을 두 번 걸면 서로 지워진다는 걸 알아채는 데 필요한 건 MD5 구현 지식이 아니라 두 블록이 같은 코드인지 비교하는 눈이었다.
역산 문제에서 암호 루틴이 나오면 구현부터 뜯어보고 싶어지는데, 그 전에 "이게 결과에 영향을 주긴 하나"를 먼저 확인하는 게 빠를 때가 있다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…