[🥇 Gold 4] 디버거를 붙이면 정답이 바뀐다 — DreamHack Times 풀이

2026-08-02·1분 읽기·

[🥇 Gold 4] 디버거를 붙이면 정답이 바뀐다 — DreamHack Times 풀이

생성자가 ptrace(PTRACE_TRACEME) 반환값으로 전역 워드를 갱신하는데, 그 전역이 memcmp 비교 대상의 마지막 바이트를 겸한다. MD5 XOR 층은 같은 초에 두 번 걸려 스스로 상쇄되고, 남는 변환은 dword 비트반전 하나뿐이었다.

문제: DreamHack 워게임 — Times 분류: reversing 난이도: 🥇 Gold 4 FLAG: DH{a20f984e48f83e69566e2aee17b491b7fc722ab2}

문제 설명은 이렇다. 2030년에 열리는 콘서트 티켓을 등록하고 싶은데, 등록 프로그램이 "아직 시간이 되지 않았다"며 거절한다. 프로그램을 분석해서 등록 키를 알아내라.

그리고 참고 링크가 딱 두 개 붙어 있다.

문제가 답의 절반을 알려주고 시작하는 셈이다. main 이 아닌 곳에서 뭔가 벌어지고, 디버거를 붙이면 그게 달라진다. 그런데 실제로 풀어 보니 이 문제의 재미는 "안티디버깅이 있다"가 아니라 안티디버깅이 무엇을 망가뜨리는가에 있었다.

./recon.sh
배포 파일은 stripped PIE 실행파일 하나뿐이다. Full RELRO에 카나리·NX까지 다 켜져 있지만 이 문제에서 보호기법은 장식이고, stripped라 심볼이 하나도 없다는 점만 실제로 걸림돌이 된다
배포 파일은 stripped PIE 실행파일 하나뿐이다. Full RELRO에 카나리·NX까지 다 켜져 있지만 이 문제에서 보호기법은 장식이고, stripped라 심볼이 하나도 없다는 점만 실제로 걸림돌이 된다

문제 개요

항목내용
문제명Times
난이도🥇 Gold 4
분류reversing
제공실행파일 times 하나 (x86-64, PIE, stripped)
서버없음 — 로컬에서 끝나는 문제
핵심 기법.init_array 생성자 + ptrace(PTRACE_TRACEME) 결과를 키에 섞기
부수 기법같은 시드로 두 번 거는 MD5 XOR(자기상쇄) · dword 비트반전 · 데이터 겹치기

풀이 흐름은 네 단계다.

  1. .init_array 에 엔트리가 둘이다. 하나는 컴파일러가 넣은 frame_dummy, 나머지 하나가 진짜 생성자다. 여기서 2030년 검사와 ptrace 가 돈다.

  2. main 은 입력에 세 겹의 변환을 건다. 그중 두 겹이 같은 시드로 만든 같은 MD5 키라 서로 지워진다. 남는 건 dword 단위 비트반전 하나.

  3. 생성자가 만지는 전역 워드는 초기값이 정확히 1234 라서, 정상 실행이면 0이 된다. 그런데 그 전역의 주소가 memcmp 비교 대상의 마지막 바이트와 겹친다.

  4. 그래서 파일에 박힌 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
.init_array 에 8바이트 엔트리가 둘 들어 있다. 리틀엔디언으로 읽으면 0x1300 과 0x17d0 이고, 앞의 것은 register_tm_clones 로 점프하는 컴파일러 생성 코드라 실제 로직은 0x17d0 하나뿐이다
.init_array 에 8바이트 엔트리가 둘 들어 있다. 리틀엔디언으로 읽으면 0x1300 과 0x17d0 이고, 앞의 것은 register_tm_clones 로 점프하는 컴파일러 생성 코드라 실제 로직은 0x17d0 하나뿐이다

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                  # <-- 전역워드 ^= 결과|'
생성자 0x17d0 의 전체 디스어셈블. time(0) 결과를 0x71ca77ff 와 비교해 작으면 안내 문구를 찍고 exit 하며, 통과하면 ptrace 를 호출해 반환값에 1을 더하고 1234를 곱한 값을 전역 워드에 XOR 한다
생성자 0x17d0 의 전체 디스어셈블. time(0) 결과를 0x71ca77ff 와 비교해 작으면 안내 문구를 찍고 exit 하며, 통과하면 ptrace 를 호출해 반환값에 1을 더하고 1234를 곱한 값을 전역 워드에 XOR 한다

두 부분으로 나뉜다.

앞쪽 — 시간 게이트.

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@plt

0x71ca77ff 는 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 (성공)11234
디버거가 붙어 있음-1 (EPERM)00

즉 정상이면 전역 워드에 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
gdb 배치 실행 결과. ptrace 가 -1 을 돌려주고 (rax+1)*1234 가 0 이 되면서, 생성자 실행 전후로 전역 워드가 0x04d2 그대로 남는다
gdb 배치 실행 결과. ptrace 가 -1 을 돌려주고 (rax+1)*1234 가 0 이 되면서, 생성자 실행 전후로 전역 워드가 0x04d2 그대로 남는다

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'
MD5 판별 근거 세 가지. 초기 상태 0x67452301·0xefcdab89·0x98badcfe·0x10325476 이 스택에 박히고, .rodata 0x2020 에 K 테이블이, 0x2120 에 7·12·17·22 로 시작하는 시프트량 테이블이 들어 있다
MD5 판별 근거 세 가지. 초기 상태 0x67452301·0xefcdab89·0x98badcfe·0x10325476 이 스택에 박히고, .rodata 0x2020 에 K 테이블이, 0x2120 에 7·12·17·22 로 시작하는 시프트량 테이블이 들어 있다

초기 상태 네 개(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
main 0x18be 와 0x1a4f 의 디스어셈블을 나란히 놓은 화면. time·srand·rand·rand·add 순서와 저장 위치까지 두 블록이 완전히 동일하다
main 0x18be 와 0x1a4f 의 디스어셈블을 나란히 놓은 화면. time·srand·rand·rand·add 순서와 저장 위치까지 두 블록이 완전히 동일하다

time(0) → srand → rand() 두 번 → 더해서 [rbp-0x54] 에 저장. 명령 하나까지 같다. 두 블록 사이 간격은 XOR 루프 몇 개뿐이라 실행 시간이 마이크로초 단위다.

time(0) 은 초 단위 값이다. 두 호출이 같은 초에 들어가면 시드가 같고, 시드가 같으면 rand() 수열이 같고, 따라서 MD5 키 16바이트도 완전히 같다.

그리고 두 라운드가 거는 연산은 XOR이다. 같은 값을 두 번 XOR 하면 원래대로 돌아온다.

결과 = 원본 ^ K ^ G ^ K       (K = MD5 키에서 나온 바이트별 마스크, G = 전역 워드 마스크)
     = 원본 ^ G

XOR 은 교환·결합이 되니 순서를 바꿔 묶으면 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"
race_check.sh 로 400회 반복 실행한 결과. 성공 400 실패 0 으로, 두 time(0) 호출이 초 경계에 걸리는 경우는 한 번도 관측되지 않았다
race_check.sh 로 400회 반복 실행한 결과. 성공 400 실패 0 으로, 두 time(0) 호출이 초 경계에 걸리는 경우는 한 번도 관측되지 않았다

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
readelf -x .data 출력. 비교 대상 41바이트가 0x4020 에서 0x4048 까지 걸쳐 있고, 그 마지막 바이트 자리인 0x4048 에 d2 04 즉 0x04d2 가 들어 있다
readelf -x .data 출력. 비교 대상 41바이트가 0x4020 에서 0x4048 까지 걸쳐 있고, 그 마지막 바이트 자리인 0x4048 에 d2 04 즉 0x04d2 가 들어 있다

여기서 걸린다. 41바이트면 0x4020 부터 0x4048 까지인데, 0x4048 은 아까 생성자가 XOR 하던 그 전역 워드의 주소다.

비교 대상의 마지막 바이트와 전역 워드의 하위 바이트가 같은 자리다.

그리고 그 자리 초기값이 d2 04, 즉 0x04d2 = 1234. 생성자가 XOR 하는 값과 정확히 같다.

정리하면 이렇게 된다.

전역 워드 실행 중 값비교 대상 41번째 바이트워드 XOR 층
정상 실행0x00000x00항등 (아무 일도 안 일어남)
디버거 부착0x04d20xd2모든 워드가 오염

즉 하나의 상수가 두 군데에서 동시에 역할을 한다.

  • 정상 실행이면 워드 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("실행 중에는 그 값이 바뀌어 있을 수 있다 -> 파일만 보고 판단하면 안 된다.")
naive_reverse.py 실행 결과. 앞 40바이트는 정상 hex 문자열로 복원되지만 41번째 바이트가 0xd2 로 남아 명령행 인자로 넣을 수 없는 값이 된다
naive_reverse.py 실행 결과. 앞 40바이트는 정상 hex 문자열로 복원되지만 41번째 바이트가 0xd2 로 남아 명령행 인자로 넣을 수 없는 값이 된다

0xd2 는 출력 가능한 문자가 아니다. 셸에서 인자로 넘길 방법이 마땅치 않다. 길이 계산이나 비트반전 순서가 틀렸나 싶어 한참 다시 봤는데 그쪽은 멀쩡했다.

풀린 건 주소를 다시 봤을 때다. 0x4020 + 0x29 - 1 = 0x4048. 생성자가 만지는 그 주소다. 파일에 있는 값과 실행 중 값이 다른 자리였다.

정적 분석만으로 답을 뽑으려던 게 문제였다. 비교 대상이 상수라고 믿었는데 그중 한 바이트는 상수가 아니었다.

▶🐛 삽질 2 — faketime 이 없다

시간 게이트를 넘겨야 프로그램이 돈다. 보통 faketime 으로 해결하는데 설치돼 있지 않았고, 이 확인 하나 하자고 패키지를 새로 깔고 싶지도 않았다.

선택지는 셋이었다.

  1. 시스템 시계를 2030년으로 돌린다 — 다른 작업이 다 망가진다. 제외.
  2. 바이너리를 패치한다 — jg 를 jmp 로 바꾸면 되지만, 패치한 바이너리로 검증하면 "원본이 정말 이 답을 받아들이는가"를 증명하지 못한다.
  3. 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      # <- 여기가 틀렸다

결과는 이랬다.

잘못된 gdb 스크립트 실행 결과. 로드 베이스가 0x7ffff7fdff20 으로 나오고 전역 워드는 0xbe6c 라는 엉뚱한 값을 읽으며, 브레이크포인트가 ld.so 의 rtld.c 에 걸려 프로그램이 그냥 끝나 버린다
잘못된 gdb 스크립트 실행 결과. 로드 베이스가 0x7ffff7fdff20 으로 나오고 전역 워드는 0xbe6c 라는 엉뚱한 값을 읽으며, 브레이크포인트가 ld.so 의 rtld.c 에 걸려 프로그램이 그냥 끝나 버린다

베이스가 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)
        break

0x555555554000 이 나왔다. 관례로 아는 값이지만, 관례를 코드에 박지 않고 매핑에서 읽은 값이라 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()
solve.py 실행 결과. 파일에서 읽은 비교 대상 41바이트와 전역 워드 초기값 0x04d2 를 보여준 뒤, 실행 중 값 0x0000 을 반영해 입력 길이를 40 으로 확정하고 40자 등록키를 출력한다
solve.py 실행 결과. 파일에서 읽은 비교 대상 41바이트와 전역 워드 초기값 0x04d2 를 보여준 뒤, 실행 중 값 0x0000 을 반영해 입력 길이를 40 으로 확정하고 40자 등록키를 출력한다

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
verify.sh 실행 결과. 심 없이 돌리면 Not yet 안내로 끝나고, 시간만 밀어준 뒤 40자 더미를 넣으면 Registration failed, solve.py 가 계산한 키를 넣으면 Registration done 이 나온다
verify.sh 실행 결과. 심 없이 돌리면 Not yet 안내로 끝나고, 시간만 밀어준 뒤 40자 더미를 넣으면 Registration failed, solve.py 가 계산한 키를 넣으면 Registration done 이 나온다

세 줄이 예상대로 나왔다. 같은 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 호출까지 전부 걸려 출력이 쓰레기가 된다.

정상 실행에서 돌린 결과다.

probe.so 를 얹은 정상 실행. 전역 워드가 0x0000 이라 워드 층이 항등이고, 변환된 입력과 비교 대상 41바이트가 마지막 00 까지 완전히 일치한다
probe.so 를 얹은 정상 실행. 전역 워드가 0x0000 이라 워드 층이 항등이고, 변환된 입력과 비교 대상 41바이트가 마지막 00 까지 완전히 일치한다

전역 워드 0x0000, 두 줄이 마지막 00 까지 한 글자도 다르지 않다. 정적 분석으로 세운 주장이 실행 중 메모리에서 그대로 확인됐다.

이제 같은 관찰자를 gdb 아래에서 돌린다. 입력은 그대로 정답 키다.

같은 정답 키를 gdb 아래에서 실행한 결과. 전역 워드가 0x04d2 로 남아 변환된 입력이 통째로 달라졌고, 비교 대상 마지막 바이트도 00 이 아니라 d2 로 찍혀 불일치가 난다
같은 정답 키를 gdb 아래에서 실행한 결과. 전역 워드가 0x04d2 로 남아 변환된 입력이 통째로 달라졌고, 비교 대상 마지막 바이트도 00 이 아니라 d2 로 찍혀 불일치가 난다

같은 바이너리, 같은 입력, 같은 관찰자인데 결과가 정반대다.

  • 전역 워드가 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

댓글

0개

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

댓글 불러오는 중…

Related

관련 글

3개