[🥇 Gold 3] 게임을 켜지 않고 게임 화면을 읽는다 — DreamHack My_First_Game_v0.1 풀이

file extracted/* && sha256sum extracted/* && du -b extracted/*

HRESULT D3DXCreateMeshFVF(
    DWORD            NumFaces,      // 삼각형 개수
    DWORD            NumVertices,   // 정점 개수
    DWORD            Options,       // D3DXMESH_* 플래그
    DWORD            FVF,           // 정점 하나의 구성
    LPDIRECT3DDEVICE9 pD3DDevice,
    LPD3DXMESH      *ppMesh);

#!/usr/bin/env python3
"""WindowsProject1.exe 의 섹션 배치와 임포트를 훑는다. 무엇으로 만든 게임인지부터 본다."""
import sys
 
import pefile
 
pe = pefile.PE(sys.argv[1] if len(sys.argv) > 1 else "extracted/WindowsProject1.exe")
 
print(f"ImageBase {hex(pe.OPTIONAL_HEADER.ImageBase)}   "
      f"EntryPoint {hex(pe.OPTIONAL_HEADER.AddressOfEntryPoint)}   "
      f"Machine {hex(pe.FILE_HEADER.Machine)} (x86-64)")
 
print(f"\n{'섹션':10s} {'VA':>12s} {'가상크기':>10s} {'파일크기':>10s}")
for s in pe.sections:
    name = s.Name.decode(errors="replace").rstrip("\x00")
    print(f"{name:10s} {hex(pe.OPTIONAL_HEADER.ImageBase + s.VirtualAddress):>12s} "
          f"{hex(s.Misc_VirtualSize):>10s} {hex(s.SizeOfRawData):>10s}")
 
WANT = ("d3d9", "d3dx9", "dinput8", "USER32")
print("\n그래픽·입력 관련 임포트만:")
for e in pe.DIRECTORY_ENTRY_IMPORT:
    dll = e.dll.decode()
    if not any(w.lower() in dll.lower() for w in WANT):
        continue
    names = [i.name.decode() for i in e.imports if i.name]
    print(f"  {dll}")
    for n in names:
        print(f"      {n}")

python3 dump_pe.py

objdump -d -M intel --start-address=0x140001c49 --stop-address=0x140001ce4 \
  extracted/WindowsProject1.exe | sed -E -f annot.sed | tail -n +7 | grep -vE ":\t00 *$"

objdump -d -M intel --start-address=0x140001ce4 --stop-address=0x140001d43 \
  extracted/WindowsProject1.exe | sed -E -f annot.sed | tail -n +7 | grep -vE ":\t00 *$"

; 렌더 루프 (0x140001780 ~ 0x1400017fd)
movd    xmm3, ebx                 ; xmm3 = (float)i
cvtdq2ps xmm3, xmm3
xorps   xmm2, xmm2                ; y = 0
xorps   xmm1, xmm1                ; x = 0
call    D3DXMatrixTranslation     ; T = Translate(0, 0, i)
call    D3DXMatrixMultiply        ; world = T * S      (S = Scaling(10,10,10))
call    SetTransform              ; D3DTS_WORLD
call    mesh[i]->DrawSubset(0)

구멍 개수 = (F - (V - 2)) / 2

#!/usr/bin/env python3
"""My_First_Game_v0.1 (DreamHack Gold 3, reversing)
 
InitScene(0x140001900) 이 하드코딩된 배열로 68개 D3DX 메시를 만든다.
그 원본 배열을 PE 에서 그대로 꺼내 meshes.json 으로 떨군다.
 
  NumVertices[68] : .rdata 0x140003410
  NumFaces[68]    : .rdata 0x140003520
  정점 스트림      : .data  0x1400068f0  (FVF 0x142 = XYZ|DIFFUSE|TEX1 → 24B/정점)
  인덱스 스트림    : .data  0x14001ae10  (uint16 × 3 × 면)
 
메시 i 는 두 커서를 앞에서부터 잘라 쓴다(루프 0x140001c50 의 ebx/r14d 누적).
"""
import json
import struct
import sys
 
import pefile
 
EXE = sys.argv[1] if len(sys.argv) > 1 else "extracted/WindowsProject1.exe"
OUT = sys.argv[2] if len(sys.argv) > 2 else "meshes.json"
 
NUM_MESH = 0x44          # 0x140001c49: mov r12d, 0x44
VA_NUMVERT = 0x140003410  # 0x140001c5d: mov edx,[rsi+r13+0x3410]
VA_NUMFACE = 0x140003520  # 0x140001c6b: mov ecx,[rsi+r13+0x3520]
VA_VERTS = 0x1400068F0    # 0x140001c9d: lea rdx,[r13+0x68f0]
VA_INDEX = 0x14001AE10    # 0x140001cec: lea rdx,[r13+0x1ae10]
VSTRIDE = 24              # FVF 0x142 → pos(12) + diffuse(4) + uv(8)
 
pe = pefile.PE(EXE)
base = pe.OPTIONAL_HEADER.ImageBase
read = lambda va, n: pe.get_data(va - base, n)
 
num_vert = struct.unpack(f"<{NUM_MESH}I", read(VA_NUMVERT, NUM_MESH * 4))
num_face = struct.unpack(f"<{NUM_MESH}I", read(VA_NUMFACE, NUM_MESH * 4))
vbuf = read(VA_VERTS, sum(num_vert) * VSTRIDE)
ibuf = read(VA_INDEX, sum(num_face) * 6)
 
meshes = []
vcur = fcur = 0
for i in range(NUM_MESH):
    nv, nf = num_vert[i], num_face[i]
    verts = []
    for j in range(nv):
        x, y, z, diffuse, u, v = struct.unpack_from("<fffIff", vbuf, (vcur + j) * VSTRIDE)
        verts.append([x, y, z, diffuse, u, v])
    tris = list(struct.unpack_from(f"<{nf * 3}H", ibuf, fcur * 6))
    tris = [tris[k:k + 3] for k in range(0, len(tris), 3)]
    meshes.append({"index": i, "num_vert": nv, "num_face": nf, "verts": verts, "tris": tris})
    vcur += nv
    fcur += nf
 
with open(OUT, "w") as fp:
    json.dump(meshes, fp)
 
print(f"메시 {len(meshes)}개, 정점 {vcur}, 면 {fcur} → {OUT}")
print(f"정점 스트림 끝 = {hex(VA_VERTS + vcur * VSTRIDE)} (인덱스 시작 {hex(VA_INDEX)} 와 일치해야 정상)")
for m in meshes[:6]:
    ys = [v[1] for v in m["verts"]]
    zs = [v[2] for v in m["verts"]]
    genus = m["num_face"] - (m["num_vert"] - 2)
    print(f"  mesh {m['index']:2d}  V={m['num_vert']:3d} F={m['num_face']:3d} "
          f"구멍={genus // 2}  y[{min(ys):+.3f},{max(ys):+.3f}] z[{min(zs):+.3f},{max(zs):+.3f}]")

python3 extract_meshes.py

#!/usr/bin/env python3
"""meshes.json 의 68개 메시를 게임이 배치하는 그대로 한 줄로 펼쳐 그린다.
 
Render(0x140001520) 의 월드행렬은  Translation(0, 0, i) * Scaling(10, 10, 10) 이라
메시 i 는 z 로 i 만큼 밀린 뒤 10배 된다. 여기서는 배율을 빼고 z += i 만 적용한다
(배율은 모양을 안 바꾼다). 정점의 x 는 전부 0 이므로 (z, y) 평면에 삼각형을 채우면
그게 곧 게임 안에서 보이는 글자다.
"""
import json
import sys
 
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
 
SRC = sys.argv[1] if len(sys.argv) > 1 else "meshes.json"
OUT = sys.argv[2] if len(sys.argv) > 2 else "flag_strip.png"
PER_ROW = 17  # 68글자를 4줄로 접어 글자가 뭉개지지 않게 한다
 
meshes = json.load(open(SRC))
rows = [meshes[i:i + PER_ROW] for i in range(0, len(meshes), PER_ROW)]
 
fig, axes = plt.subplots(len(rows), 1, figsize=(22, 3.0 * len(rows)))
for ax, row in zip(axes, rows):
    z0 = row[0]["index"]
    for m in row:
        # 게임과 동일한 배치: 메시 i 는 z 축으로 i 만큼 이동한다
        pts = [(v[2] + m["index"] - z0, v[1]) for v in m["verts"]]
        for a, b, c in m["tris"]:
            ax.add_patch(Polygon([pts[a], pts[b], pts[c]],
                                 closed=True, facecolor="black", edgecolor="none"))
        ax.text(m["index"] - z0 + 0.5, -0.45, str(m["index"]),
                ha="center", va="top", fontsize=7, color="#c04040")
    ax.set_xlim(-0.3, PER_ROW + 0.3)
    ax.set_ylim(-0.55, 0.95)
    ax.set_aspect("equal")
    ax.axis("off")
 
fig.tight_layout()
fig.savefig(OUT, dpi=130, facecolor="white")
print(f"{len(meshes)}개 글리프 → {OUT}")

python3 render_glyphs.py meshes.json 06_glyph_strip.png

; WinMain 입력 처리 (0x1400013bb ~ 0x1400013e8)
test  BYTE PTR [rbp+0x4e], 0x80    ; 키보드 버퍼 +0x1e = DIK_A
je    .no_a
addss xmm0, xmm7                   ; xmm7 = -1.0   → x -= 1
.no_a:
test  BYTE PTR [rbp+0x50], 0x80    ; 키보드 버퍼 +0x20 = DIK_D
je    .no_d
addss xmm0, xmm8                   ; xmm8 = +1.0   → x += 1

#!/usr/bin/env bash
# My_First_Game_v0.1 — wine + Xvfb 로 게임을 실제로 띄우고 화면을 찍는다.
#   ./ingame_capture.sh <출력PNG> <D키를 누르고 있을 초>
# 두 번째 인자가 0 이면 시작 화면(카메라 x=0) 그대로 찍는다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
OUT="${1:?출력 PNG 경로}"
HOLD="${2:-0}"
DISP=":95"
export WINEPREFIX="$HOME/.wine_myfirstgame" WINEDEBUG=-all DISPLAY="$DISP"
 
pgrep -f "[X]vfb $DISP " >/dev/null || { Xvfb "$DISP" -screen 0 1280x900x24 >/tmp/xvfb95.log 2>&1 & sleep 2; }
[ -f "$WINEPREFIX/drive_c/windows/system32/kernel32.dll" ] || wine wineboot -u >/dev/null 2>&1
 
( cd extracted && setsid wine WindowsProject1.exe >/tmp/game.log 2>&1 </dev/null & )
sleep 20
 
WID=$(xdotool search --name '^My_First_Game_v0\.1$' | head -1)
[ -n "$WID" ] || { echo "게임 창을 못 찾았다"; exit 1; }
xdotool windowactivate "$WID" 2>/dev/null || true
xdotool windowfocus "$WID" 2>/dev/null || true
sleep 1
 
# A/D 는 프레임마다 카메라 X 를 ∓1 씩 옮긴다(0x140020694, ±300 로 클램프).
if [ "$HOLD" != "0" ]; then
  xdotool keydown --window "$WID" d
  sleep "$HOLD"
  xdotool keyup --window "$WID" d
  sleep 1
fi
 
import -window "$WID" "$OUT"
echo "저장: $OUT ($(identify -format '%wx%h' "$OUT"))"
 
# 이 실행이 띄운 게임만 종료한다(PID 지정 — 광범위 pkill 금지)
GPID=$(pgrep -f '[W]indowsProject1.exe' | head -1 || true)
[ -n "$GPID" ] && kill "$GPID" 2>/dev/null || true

./ingame_capture.sh 08_ingame_start.png 0

./ingame_capture.sh 09_ingame_strafe.png 12

convert 09_ingame_strafe.png -crop 200x40+0+270 +repage \
  -filter point -resize 400% -bordercolor '#202020' -border 12 10_ingame_zoom.png

#!/usr/bin/env python3
"""판독한 68글자가 메시 데이터와 모순이 없는지 기하로만 재확인한다.
 
1) 같은 글자면 (정점수, 면수) 가 완전히 같아야 한다 — 같은 폰트 아웃라인을 복사해 넣었으니까.
2) 거울쌍(b/d, 6/9, 어쩌면 {/}) 은 1) 로는 안 갈린다. 면적가중 무게중심으로 가른다.
     b/d : 어센더(y>0.55) 의 가로 위치 — 세로 획이 왼쪽이면 b
     6/9 : 전체 무게중심의 높이 — 배가 아래면 6
     {/} : 전체 무게중심의 가로 위치 — 팔이 오른쪽으로 뻗으면 {
"""
import json
import sys
from collections import defaultdict
 
SRC = sys.argv[1] if len(sys.argv) > 1 else "meshes.json"
GUESS = sys.argv[2] if len(sys.argv) > 2 else \
    "DH{7d32405fb8dc2608f3dcc026398bc7ce6a944a08702a1484495cf16bfe5cedf2}"
 
meshes = json.load(open(SRC))
assert len(meshes) == len(GUESS), f"메시 {len(meshes)}개 vs 글자 {len(GUESS)}개"
 
 
def props(m):
    """삼각형 면적으로 가중한 무게중심. 채워진 글리프의 실제 중심이다."""
    A = cz = cy = ztop = wtop = 0.0
    V = m["verts"]
    for a, b, c in m["tris"]:
        (za, ya), (zb, yb), (zc, yc) = ((V[i][2], V[i][1]) for i in (a, b, c))
        ar = abs((zb - za) * (yc - ya) - (zc - za) * (yb - ya)) / 2
        mz, my = (za + zb + zc) / 3, (ya + yb + yc) / 3
        A += ar
        cz += ar * mz
        cy += ar * my
        if my > 0.55:
            wtop += ar
            ztop += ar * mz
    zs = [v[2] for v in V]
    ys = [v[1] for v in V]
    z0, z1, y0, y1 = min(zs), max(zs), min(ys), max(ys)
    nz = lambda v: (v - z0) / (z1 - z0)
    return nz(cz / A), (cy / A - y0) / (y1 - y0), (nz(ztop / wtop) if wtop else None)
 
 
print("== 1) (정점수, 면수) 서명 ==")
sig = defaultdict(set)
for ch, m in zip(GUESS, meshes):
    sig[(m["num_vert"], m["num_face"])].add(ch)
clash = []
for k in sorted(sig):
    chars = sorted(sig[k])
    hole = (k[1] - (k[0] - 2)) // 2
    note = "" if len(chars) == 1 else "   <- 거울쌍 후보"
    if len(chars) > 1:
        clash.append(chars)
    print(f"   V={k[0]:3d} F={k[1]:3d} 구멍={hole}  ->  {chars}{note}")
 
print("\n== 2) 거울쌍 가르기 (면적가중 무게중심) ==")
RULE = {("b", "d"): ("ztop", "작으면 b"), ("6", "9"): ("cy", "작으면 6"),
        ("{", "}"): ("cz", "크면 {")}
for chars in clash:
    key = tuple(chars)
    rule = RULE.get(key) or RULE.get(key[::-1])
    print(f"   {key} — 기준 {rule[0] if rule else '?'} ({rule[1] if rule else ''})")
    seen, where = defaultdict(set), defaultdict(list)
    for i, (ch, m) in enumerate(zip(GUESS, meshes)):
        if ch in key:
            cz, cy, ztop = props(m)
            seen[ch].add((round(cz, 3), round(cy, 3), None if ztop is None else round(ztop, 3)))
            where[ch].append(i)
    for ch in key:
        vals = seen[ch]
        assert len(vals) == 1, f"'{ch}' 가 서로 다른 모양으로 판독됨: {vals}"
        cz, cy, ztop = next(iter(vals))
        print(f"      '{ch}' ×{len(where[ch])}  cz={cz} cy={cy} ztop={ztop}   "
              f"idx {where[ch]}")
    assert len(set().union(*seen.values())) == len(seen), f"{key} 가 서로 구분되지 않는다"
    print(f"      -> 같은 글자는 값이 완전히 같고 두 글자는 서로 다르다. OK")
 
body = GUESS[3:-1]
print(f"\n== 3) 형식 ==")
print(f"   전체 {len(GUESS)}자, DH{{ }} 껍데기 제외 {len(body)}자")
print(f"   전부 16진수인가: {all(c in '0123456789abcdef' for c in body)}  (64자 = SHA-256 자리수)")
print(f"\n{GUESS}")

python3 verify_glyphs.py

#!/usr/bin/env python3
"""My_First_Game_v0.1 (DreamHack Gold 3, reversing) — 자체 완결 solve
 
게임을 한 번도 실행하지 않는다. 배포된 PE 안에 장면 데이터가 통째로 박혀 있어서
그것만 꺼내면 화면에 뭐가 그려질지 계산으로 알 수 있다.
 
  InitScene(0x140001900)  D3DXCreateMeshFVF 를 0x44=68회 돌려 메시를 만든다
      NumVertices[68]  .rdata 0x140003410
      NumFaces[68]     .rdata 0x140003520
      정점 스트림       .data  0x1400068f0   FVF 0x142 → 24B/정점 (pos12 + diffuse4 + uv8)
      인덱스 스트림     .data  0x14001ae10   uint16 × 3 × 면
 
  Render(0x140001520)   메시 i 의 월드행렬 = Translation(0,0,i) · Scaling(10,10,10)
 
정점의 x 는 전부 0 이다. 즉 68개 메시는 평면 도형이고, z 로 한 칸씩 밀려 한 줄로 늘어선다.
(z, y) 평면에 삼각형을 채우면 그게 곧 글자다 — 폰트 아웃라인을 삼각분할해 넣어 둔 것이다.
 
판독은 눈으로 하지 않는다. 각 글리프를 베이스라인 기준 비트맵으로 굽고, 시스템 폰트로
같은 규격으로 구운 후보 글자들과 IoU 로 맞춰 문자열을 복원한다.
 
  python3 solve.py                       # flag 출력
  python3 solve.py --strip flag_strip.png  # 사람이 눈으로 볼 수 있게 글자 띠도 저장
"""
import argparse
import struct
import sys
 
import numpy as np
import pefile
from PIL import Image, ImageDraw, ImageFont
 
# ── InitScene(0x140001900) 이 참조하는 주소들 ────────────────────────────────
NUM_MESH = 0x44
VA_NUMVERT = 0x140003410
VA_NUMFACE = 0x140003520
VA_VERTS = 0x1400068F0
VA_INDEX = 0x14001AE10
VSTRIDE = 24                    # FVF 0x142 = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1
 
# 글리프를 구울 격자. 세로는 베이스라인(y=0) 기준 절대 좌표라 'c' 와 'C' 가 구분된다.
CELL_H, CELL_W = 96, 64
Y_LO, Y_HI = -0.28, 0.88
 
CANDIDATES = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ{}[]()_-+=!?.,:;#@$%&*/<>"
FONTS = [
    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
    "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
    "/usr/share/fonts/truetype/liberation2/LiberationSans-Regular.ttf",
    "/usr/share/fonts/opentype/noto/NotoSans-Regular.ttf",
    "/usr/share/fonts/truetype/noto/NotoSans-Regular.ttf",
]
 
 
def load_meshes(exe):
    """PE 에서 68개 메시의 정점·인덱스를 잘라 낸다."""
    pe = pefile.PE(exe)
    base = pe.OPTIONAL_HEADER.ImageBase
    rd = lambda va, n: pe.get_data(va - base, n)
 
    nvert = struct.unpack(f"<{NUM_MESH}I", rd(VA_NUMVERT, NUM_MESH * 4))
    nface = struct.unpack(f"<{NUM_MESH}I", rd(VA_NUMFACE, NUM_MESH * 4))
    vbuf = rd(VA_VERTS, sum(nvert) * VSTRIDE)
    ibuf = rd(VA_INDEX, sum(nface) * 6)
 
    out, vcur, fcur = [], 0, 0
    for i in range(NUM_MESH):
        nv, nf = nvert[i], nface[i]
        # 정점 앞 12바이트가 pos(x, y, z). x 는 전부 0 이라 (z, y) 두 축만 쓴다.
        pts = []
        for j in range(nv):
            _x, y, z = struct.unpack_from("<fff", vbuf, (vcur + j) * VSTRIDE)
            pts.append((z, y))
        raw = struct.unpack_from(f"<{nf * 3}H", ibuf, fcur * 6)
        out.append((pts, [raw[k:k + 3] for k in range(0, len(raw), 3)]))
        vcur, fcur = vcur + nv, fcur + nf
    return out
 
 
def rasterize(pts, tris, w=CELL_W, h=CELL_H):
    """글리프를 비트맵으로 굽는다. 세로는 베이스라인 절대, 가로는 잉크 폭으로 정규화."""
    zs = [p[0] for p in pts]
    z0, z1 = min(zs), max(zs)
    sz = (w - 1) / (z1 - z0) if z1 > z0 else 1.0
    sy = (h - 1) / (Y_HI - Y_LO)
 
    img = Image.new("1", (w, h), 0)
    dr = ImageDraw.Draw(img)
    for a, b, c in tris:
        dr.polygon([((p[0] - z0) * sz, (Y_HI - p[1]) * sy) for p in (pts[a], pts[b], pts[c])],
                   fill=1)
    return np.array(img, dtype=bool)
 
 
def font_glyph(font, ch, w=CELL_W, h=CELL_H):
    """후보 글자를 같은 규격으로 굽는다. em 크기를 글리프 좌표계(1.0 em)에 맞춘다."""
    em = font.size
    pad = em * 2
    img = Image.new("1", (pad * 2, pad * 2), 0)
    ImageDraw.Draw(img).text((pad, pad), ch, font=font, fill=1, anchor="ls")  # 왼쪽·베이스라인
    arr = np.array(img, dtype=bool)
    ys, xs = np.nonzero(arr)
    if len(xs) == 0:
        return None
 
    # 세로는 베이스라인(row=pad)이 y=0 이 되도록 절대 매핑, 가로는 잉크 폭으로 정규화
    gy = (pad - ys) / em                       # 폰트 좌표 → em 단위 y
    gx = (xs - xs.min()) / max(xs.max() - xs.min(), 1)
 
    out = np.zeros((h, w), dtype=bool)
    rr = ((Y_HI - gy) * (h - 1) / (Y_HI - Y_LO)).round().astype(int)
    cc = (gx * (w - 1)).round().astype(int)
    ok = (rr >= 0) & (rr < h)
    out[rr[ok], cc[ok]] = True
    # 폰트 쪽은 점으로 찍혀 구멍이 생기니 한 번 메워 준다
    from scipy.ndimage import binary_closing  # noqa: F401  (없으면 아래 except 로)
    return binary_closing(out, np.ones((3, 3)))
 
 
def classify(masks, fontpath, size=180):
    font = ImageFont.truetype(fontpath, size)
    refs = {}
    for ch in CANDIDATES:
        g = font_glyph(font, ch)
        if g is not None and g.any():
            refs[ch] = g
 
    text, score_sum = "", 0.0
    for m in masks:
        best, bs = "?", -1.0
        for ch, g in refs.items():
            inter = np.count_nonzero(m & g)
            union = np.count_nonzero(m | g)
            iou = inter / union if union else 0.0
            if iou > bs:
                bs, best = iou, ch
        text += best
        score_sum += bs
    return text, score_sum / len(masks)
 
 
def save_strip(meshes, path, per_row=17):
    """게임이 배치하는 그대로(메시 i 를 z 로 i 만큼 이동) 한 줄로 펼쳐 그린다."""
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    from matplotlib.patches import Polygon
 
    rows = [list(range(i, min(i + per_row, len(meshes)))) for i in range(0, len(meshes), per_row)]
    fig, axes = plt.subplots(len(rows), 1, figsize=(22, 3.0 * len(rows)))
    for ax, row in zip(np.atleast_1d(axes), rows):
        for i in row:
            pts, tris = meshes[i]
            off = i - row[0]
            for a, b, c in tris:
                ax.add_patch(Polygon([(pts[k][0] + off, pts[k][1]) for k in (a, b, c)],
                                     closed=True, facecolor="black", edgecolor="none"))
            ax.text(off + 0.5, -0.45, str(i), ha="center", va="top", fontsize=7, color="#c04040")
        ax.set_xlim(-0.3, per_row + 0.3)
        ax.set_ylim(-0.55, 0.95)
        ax.set_aspect("equal")
        ax.axis("off")
    fig.tight_layout()
    fig.savefig(path, dpi=130, facecolor="white")
    print(f"[*] 글자 띠 저장: {path}")
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("exe", nargs="?", default="extracted/WindowsProject1.exe")
    ap.add_argument("--strip", metavar="PNG", help="사람이 볼 수 있게 글자 띠 PNG 도 저장")
    args = ap.parse_args()
 
    meshes = load_meshes(args.exe)
    print(f"[*] 메시 {len(meshes)}개, 정점 {sum(len(m[0]) for m in meshes)}, "
          f"면 {sum(len(m[1]) for m in meshes)}")
 
    masks = [rasterize(pts, tris) for pts, tris in meshes]
 
    best_text, best_font, best_score = "", "", -1.0
    for fp in FONTS:
        try:
            text, score = classify(masks, fp)
        except OSError:
            continue
        print(f"[*] {fp.split('/')[-1]:32s} 평균 IoU {score:.3f}  {text}")
        if score > best_score:
            best_text, best_font, best_score = text, fp, score
 
    if not best_text:
        sys.exit("사용할 수 있는 폰트를 못 찾았다")
 
    print(f"[*] 채택: {best_font.split('/')[-1]} (평균 IoU {best_score:.3f})")
    print(f"\nFLAG: {best_text}")
 
    if args.strip:
        save_strip(meshes, args.strip)
 
 
if __name__ == "__main__":
    main()

python3 solve.py --strip flag_strip.png

FLAG: DH{7d32405fb8dc2608f3dcc026398bc7ce6a944a08702a1484495cf16bfe5cedf2}