[🥈 Silver 2] 시리얼 검증 루프를 거꾸로 돌리기 — DreamHack babycmp 풀이

file extracted/babycmp.exe && objdump -h extracted/babycmp.exe

strings -n 4 -el extracted/babycmp.exe | grep -nE 'SERIAL|Check|GOT IT|Congra|failed|opps'

objdump -x extracted/babycmp.exe | grep 'DLL Name'; strings -n 8 extracted/babycmp.exe | grep -E 'neko_hat|[.]pdb'

export WINEPREFIX="$HOME/.wine_babycmp" WINEDEBUG=-all
wineboot -i
winetricks -q -f vcrun2022

#!/usr/bin/env python3
"""babycmp.exe 를 Xvfb 위 wine 으로 띄우고 시리얼을 실제로 입력해 화면을 찍는다.
 
합성이 아니라 진짜 앱 화면이다. xdotool 로 입력창을 클릭 → 시리얼 타이핑 →
Check 버튼 클릭까지 실제 마우스/키보드 이벤트를 넣는다.
 
    python3 gui_capture.py <시리얼> <출력PNG> [--wrong]
 
WM 이 없어 창에 제목표시줄이 없다. 좌표는 1280x1040 화면에 다이얼로그가
가운데 뜨는 것을 기준으로 잡았고, 찍은 뒤 검은 배경을 trim 해서 잘라낸다.
"""
import os
import shutil
import signal
import subprocess
import sys
import time
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
EXE = HERE / "extracted" / "babycmp.exe"
PREFIX = Path.home() / ".wine_babycmp"
 
SCREEN = "1280x1040x24"
EDIT_XY = (630, 543)     # SERIAL 입력창
CHECK_XY = (852, 543)    # Check 버튼
 
 
def free_display(start=141, end=180):
    for n in range(start, end):
        if not Path(f"/tmp/.X11-unix/X{n}").exists():
            return n
    raise RuntimeError("빈 디스플레이 없음")
 
 
def sh(cmd, env, **kw):
    return subprocess.run(cmd, env=env, capture_output=True, text=True, **kw)
 
 
def main():
    if len(sys.argv) < 3:
        print(__doc__)
        return 2
    serial, out = sys.argv[1], Path(sys.argv[2])
    out.parent.mkdir(parents=True, exist_ok=True)
 
    disp = f":{free_display()}"
    env = dict(os.environ, DISPLAY=disp, WINEPREFIX=str(PREFIX), WINEDEBUG="-all")
 
    xvfb = subprocess.Popen(
        ["Xvfb", disp, "-screen", "0", SCREEN, "-nolisten", "tcp"],
        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    app = None
    try:
        time.sleep(3)
        app = subprocess.Popen(["wine", str(EXE)], env=env,
                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                               preexec_fn=os.setsid)
        time.sleep(18)  # mfc140u.dll 로딩이 느리다
 
        sh(["xdotool", "mousemove", *map(str, EDIT_XY), "click", "1"], env)
        time.sleep(0.6)
        sh(["xdotool", "type", "--delay", "40", serial], env)
        time.sleep(1.0)
 
        sh(["xdotool", "mousemove", *map(str, CHECK_XY), "click", "1"], env)
        time.sleep(2.5)
 
        raw = out.with_suffix(".raw.png")
        sh(["import", "-window", "root", str(raw)], env)
        subprocess.run(["convert", str(raw), "-bordercolor", "black", "-fuzz", "2%",
                        "-trim", "+repage", "-bordercolor", "#0d1117",
                        "-border", "28", str(out)], check=True)
        raw.unlink(missing_ok=True)
        print(f"SAVED: {out}")
    finally:
        if app is not None:
            try:
                os.killpg(os.getpgid(app.pid), signal.SIGKILL)
            except ProcessLookupError:
                pass
        # 이 프리픽스 전용 wineserver 만 내린다 (다른 wine 작업 보호)
        if shutil.which("wineserver"):
            sh(["wineserver", "-k"], env)
        xvfb.terminate()
        xvfb.wait(timeout=10)
    return 0
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 gui_capture.py 'DH{aaaaaaaaaaaaaaaaaaaa}' /home/jinho/homepage/public/images/blog/dreamhack-babycmp-writeup/04_gui_wrong.png

s|^   140001c9d:.*|&   <-- rcx+0x10 = std::string 의 size()|
s|^   140001ca1:.*|&   <-- 길이가 0x18(=24)이 아니면 바로 탈락|
s|^   140001cd3:.*|&   <-- rbp+0xf 에 만들어 둔 3글자 문자열|
s|^   140001cdb:.*|&   <-- 접두사를 한 글자씩 대조|
s|^   140001ced:.*|&   <-- r11 = 3, 세 글자만 본다|
s|^   140001d02:.*|&   <-- 24번째(0x17) 글자는 0x7d = '}'|

objdump -d -M intel --start-address=0x140001c9d --stop-address=0x140001d08 extracted/babycmp.exe | sed -f gate.sed | tail -n +5

xxd -s 0x4150 -l 8 extracted/babycmp.exe

s|^   140001af5:.*|&   <-- 키 "neko_hat" 을 코드 즉치값으로 스택에|
s|^   140001b0b:.*|&   <-- i < size() 인 동안 반복|
s|^   140001b34:.*|&   <-- v = (int8)serial[i]  부호확장 주의|
s|^   140001b44:.*|&   <-- v = ror32(v, 4)|
s|^   140001b52:.*|&   <-- eax = i % 8|
s|^   140001b67:.*|&   <-- v ^= key[i % 8]|
s|^   140001b73:.*|&   <-- eax = i % 4|
s|^   140001b89:.*|&   <-- v += key[i % 4]|
s|^   140001b8f:.*|&   <-- v += 0x7530 = 30000|

objdump -d -M intel --start-address=0x140001af5 --stop-address=0x140001ba9 extracted/babycmp.exe | sed -f loop.sed | tail -n +5

movabs rax, 0x7461685f6f6b656e   ; "neko_hat" 을 리틀엔디언 8바이트로
mov    QWORD PTR [rsp+0x38], rax
mov    BYTE PTR [rsp+0x40], 0    ; 널 종료

for (int i = 0; i < s.size(); i++) {
    int v = (signed char)s[i];   // movsx — 부호확장
    v = _rotr(v, 4);             // ror eax, 4
    v ^= key[i % 8];             // xor
    v += key[i % 4];             // add
    v += 30000;                  // add 0x7530
    out[i] = v;
}

objdump -d -M intel --start-address=0x140001dc7 --stop-address=0x140001df6 extracted/babycmp.exe | tail -n +8; xxd -s 0x7050 -l 96 extracted/babycmp.exe

lea rcx, [rip+0x6282]      ; 0x140008050  — 기대값 배열 시작
mov r8,  [rbp-0x39]        ; 방금 만든 벡터의 데이터 포인터
mov rdx, r8
sub rdx, rcx               ; 두 배열의 거리
lea r9,  [rip+0x62d1]      ; 0x1400080b0  — 기대값 배열 끝
...
mov rax, [rcx]
cmp [rdx+rcx*1], rax       ; 8바이트씩 비교
jne <실패>
add rcx, 8
cmp rcx, r9
jl  <계속>

#!/usr/bin/env python3
"""babycmp (DreamHack, Silver 2, reversing) — solver
 
babycmp.exe 의 검증 루틴을 그대로 다시 구현하고, 바이너리에서 뽑은
기대값 배열과 맞는 문자를 자리마다 찾아 시리얼(=플래그)을 복원한다.
 
검증 루틴 (0x140001a10, 0x140001c30):
    if (len(s) != 0x18) return false
    if (s[0:3] != "DH{") return false
    if (s[0x17] != '}')   return false
    for i in range(len(s)):
        v  = (int32)(int8)s[i]
        v  = ror32(v, 4)
        v ^= key[i % 8]          # key = "neko_hat"
        v += key[i % 4]
        v += 30000               # 0x7530
        if v != expected[i]: return false
 
기대값 24개는 .data 0x140008050 에, 접두사 "DH{" 는 .rdata 0x140004f50 에 있다.
바이너리에서 직접 읽으므로 하드코딩한 값이 없다.
"""
import struct
import sys
from pathlib import Path
 
EXE = Path(__file__).with_name("extracted") / "babycmp.exe"
 
# objdump -h babycmp.exe 로 얻은 (섹션, VMA, 파일오프셋, 크기)
SECTIONS = [
    (".text", 0x140001000, 0x00400, 0x2D5C),
    (".rdata", 0x140004000, 0x03200, 0x3D84),
    (".data", 0x140008000, 0x07000, 0x0400),
]
 
KEY = b"neko_hat"          # movabs rax, 0x7461685f6f6b656e @ 0x140001af5
EXPECTED_RVA = 0x140008050  # lea rcx,[rip+0x6282]
EXPECTED_END = 0x1400080B0  # lea r9,[rip+0x62d1]
PREFIX_RVA = 0x140004F50    # movzx eax,WORD PTR [rip+0x32c5]
SERIAL_LEN = 0x18           # cmp r15,0x18
 
 
def rva_to_offset(rva: int) -> int:
    for _name, vma, off, size in SECTIONS:
        if vma <= rva < vma + size:
            return off + (rva - vma)
    raise ValueError(f"RVA {rva:#x} 가 어느 섹션에도 없다")
 
 
def ror32(value: int, count: int) -> int:
    value &= 0xFFFFFFFF
    count &= 31
    return ((value >> count) | (value << (32 - count))) & 0xFFFFFFFF
 
 
def transform(ch: int, i: int) -> int:
    """검증 루틴 한 문자분. 입력은 movsx 로 부호확장된 int32 로 다뤄진다."""
    v = ch - 0x100 if ch >= 0x80 else ch      # movsx eax, byte
    v = ror32(v, 4)
    v ^= KEY[i % 8]
    v = (v + KEY[i % 4]) & 0xFFFFFFFF
    v = (v + 30000) & 0xFFFFFFFF
    return v
 
 
def main() -> int:
    blob = EXE.read_bytes()
 
    off = rva_to_offset(PREFIX_RVA)
    prefix = blob[off:off + 3]
 
    off = rva_to_offset(EXPECTED_RVA)
    count = (EXPECTED_END - EXPECTED_RVA) // 4
    expected = struct.unpack(f"<{count}I", blob[off:off + count * 4])
 
    print(f"[*] 접두사      : {prefix.decode()}")
    print(f"[*] 시리얼 길이 : {SERIAL_LEN}")
    print(f"[*] 기대값 개수 : {count}")
 
    serial = bytearray()
    for i, target in enumerate(expected):
        hits = [c for c in range(0x20, 0x7F) if transform(c, i) == target]
        if len(hits) != 1:
            print(f"[!] index {i}: 후보 {len(hits)}개 {hits} — 중단")
            return 1
        serial.append(hits[0])
 
    flag = serial.decode()
    print(f"[*] 복원된 시리얼: {flag}")
 
    ok = (
        len(serial) == SERIAL_LEN
        and serial[:3] == prefix
        and serial[SERIAL_LEN - 1] == ord("}")
        and all(transform(c, i) == expected[i] for i, c in enumerate(serial))
    )
    print(f"[*] 자체 검증    : {'PASS' if ok else 'FAIL'}")
    print()
    print(f"FLAG: {flag}")
    return 0 if ok else 1
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 solve.py

#!/usr/bin/env python3
"""babycmp.exe 의 변환 루프를 Unicorn 으로 '그대로' 돌려 본다.
 
손으로 옮겨 적은 파이썬 재구현(solve.py)이 맞는지 확인하는 용도다.
직접 짠 코드가 아니라 바이너리에서 떠낸 .text 바이트를 그대로 실행하므로,
ror/xor/add 순서나 부호확장을 잘못 읽었으면 여기서 값이 어긋난다.
 
    python3 emulate.py 'DH{y0u_4r3_cmp__ma5t3r!}'
 
루프 구간은 0x140001b09(초기 경계검사) ~ 0x140001ba9(루프 탈출 직후).
루프가 참조하는 것은 셋뿐이라 그 셋만 만들어 주면 된다.
  rdi : std::string  — [rdi+0x10]=size, [rdi+0x18]=capacity, [rdi]=힙 데이터 포인터
  rsi : std::vector  — [rsi]=int32 배열 시작 포인터
  rsp+0x38 : 키 8바이트 "neko_hat"
 
capacity 를 0x10 미만으로 주면 MSVC 의 SSO 규약대로 rdi 자체를 문자 버퍼로 읽는데,
그러면 오프셋 0x10 의 size 필드가 17번째 문자와 겹쳐 16바이트까지만 맞는다.
24글자 시리얼은 실제로도 힙에 잡히므로 capacity 를 0x1f 로 둔다.
"""
import struct
import sys
from pathlib import Path
 
from unicorn import Uc, UC_ARCH_X86, UC_MODE_64
from unicorn.x86_const import (UC_X86_REG_RSP, UC_X86_REG_RBP, UC_X86_REG_RSI,
                               UC_X86_REG_RDI)
 
HERE = Path(__file__).resolve().parent
EXE = HERE / "extracted" / "babycmp.exe"
 
IMAGE_BASE = 0x140000000
SECTIONS = [(".text", 0x140001000, 0x00400, 0x2D5C),
            (".rdata", 0x140004000, 0x03200, 0x3D84),
            (".data", 0x140008000, 0x07000, 0x0400)]
 
LOOP_START = 0x140001B09
LOOP_END = 0x140001BA9
KEY_RVA = 0x140001AF5      # movabs rax, <key> — 즉치값에서 키를 직접 뽑는다
EXPECTED_RVA = 0x140008050
EXPECTED_END = 0x1400080B0
 
STACK = 0x00200000
HEAP = 0x00300000
STR_OBJ = HEAP + 0x000     # std::string
STR_DAT = HEAP + 0x080     # 그 문자열이 가리키는 힙 버퍼
VEC_OBJ = HEAP + 0x100     # std::vector
OUT_BUF = HEAP + 0x200     # int32 결과 배열
 
 
def main() -> int:
    serial = (sys.argv[1] if len(sys.argv) > 1 else "DH{y0u_4r3_cmp__ma5t3r!}").encode()
    blob = EXE.read_bytes()
 
    uc = Uc(UC_ARCH_X86, UC_MODE_64)
    uc.mem_map(IMAGE_BASE, 0x20000)
    uc.mem_map(STACK, 0x10000)
    uc.mem_map(HEAP, 0x10000)
    for _name, vma, off, size in SECTIONS:
        uc.mem_write(vma, blob[off:off + size])
 
    # 키는 코드 안 movabs 즉치값(0x48 0xB8 + imm64)에서 읽는다
    key = uc.mem_read(KEY_RVA + 2, 8)
    print(f"[*] 코드에서 뽑은 키 : {bytes(key).decode()}  (movabs @ {KEY_RVA:#x})")
 
    # std::string — capacity >= 0x10 이라 루프가 [rdi] 의 힙 포인터를 따라간다
    uc.mem_write(STR_DAT, serial)
    uc.mem_write(STR_OBJ, struct.pack("<Q", STR_DAT))
    uc.mem_write(STR_OBJ + 0x10, struct.pack("<Q", len(serial)))
    uc.mem_write(STR_OBJ + 0x18, struct.pack("<Q", 0x1F))
    # std::vector — 데이터 포인터만 있으면 된다
    uc.mem_write(VEC_OBJ, struct.pack("<Q", OUT_BUF))
 
    rsp = STACK + 0x8000
    uc.reg_write(UC_X86_REG_RSP, rsp)
    uc.mem_write(rsp + 0x38, bytes(key))
    uc.reg_write(UC_X86_REG_RBP, 0)          # edx=0, r9=0 을 만드는 소스 레지스터
    uc.reg_write(UC_X86_REG_RSI, VEC_OBJ)
    uc.reg_write(UC_X86_REG_RDI, STR_OBJ)
 
    print(f"[*] 입력 시리얼     : {serial.decode()}  ({len(serial)}바이트)")
    print(f"[*] 에뮬레이션 구간 : {LOOP_START:#x} → {LOOP_END:#x}")
    uc.emu_start(LOOP_START, LOOP_END)
 
    got = struct.unpack(f"<{len(serial)}i",
                        uc.mem_read(OUT_BUF, len(serial) * 4))
    n = (EXPECTED_END - EXPECTED_RVA) // 4
    want = struct.unpack(f"<{n}i", uc.mem_read(EXPECTED_RVA, n * 4))
 
    print()
    print(" idx  ch   에뮬레이션 결과      .data 기대값        일치")
    for i, (g, w) in enumerate(zip(got, want)):
        print(f" {i:3d}  {chr(serial[i])!r:>4}  {g:12d}  {w:12d}   "
              f"{'O' if g == w else 'X'}")
 
    ok = list(got) == list(want)
    print()
    print(f"RESULT: {'MATCH — 재구현이 바이너리와 동일하다' if ok else 'MISMATCH'}")
    return 0 if ok else 1
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 emulate.py 'DH{y0u_4r3_cmp__ma5t3r!}'

python3 gui_capture.py 'DH{y0u_4r3_cmp__ma5t3r!}' /home/jinho/homepage/public/images/blog/dreamhack-babycmp-writeup/11_gui_success.png

#!/usr/bin/env bash
# babycmp (DreamHack Silver 2, reversing) — 한 방 재현.
# solve.py 가 babycmp.exe 에서 직접 기대값·키·접두사를 읽어 시리얼을 복원하고,
# emulate.py 가 바이너리의 변환 루프를 Unicorn 으로 그대로 돌려 교차검증한다.
#
# 필요: python3, (교차검증까지 하려면) pip install unicorn
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
OUT=$(timeout 300 python3 solve.py 2>&1) || true
echo "$OUT" | tail -8
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
 
# 교차검증: 바이너리 기계어를 실제로 실행해 같은 값이 나오는지 (unicorn 없으면 건너뜀)
if [ -n "$FLAG" ] && python3 -c "import unicorn" 2>/dev/null; then
  echo
  if timeout 300 python3 emulate.py "$FLAG" 2>&1 | tail -1 | grep -q MATCH; then
    echo "✔ emulate.py: 바이너리 변환 루프와 일치"
  else
    echo "✘ emulate.py: 불일치 — 재구현이 틀렸다"; exit 1
  fi
else
  echo; echo "(unicorn 미설치 — 에뮬레이션 교차검증 생략)"
fi
 
if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

FLAG: DH{y0u_4r3_cmp__ma5t3r!}
 
✔ emulate.py: 바이너리 변환 루프와 일치
 
✅ PASS  DH{y0u_4r3_cmp__ma5t3r!}