[🥉 Bronze 2] 암호도 플래그도 .data 에 누워 있다 — DreamHack Gyul Brix Calculator 풀이

file extracted/brix_calc.exe && md5sum extracted/brix_calc.exe && objdump -h extracted/brix_calc.exe

strings -n 6 extracted/brix_calc.exe | grep -nE "GAMHYUL|INPUT|GRANTED|recipe|Here is|Grade"; echo "--- 플래그 문자열 검색: $(strings -a extracted/brix_calc.exe | grep -cE "B1N4RY|DH\{")건 ---"

rabin2 -i extracted/brix_calc.exe | grep -E "strlen|putchar|printf|puts|scanf|atof|getchar|fflush"

objdump -s -j .data extracted/brix_calc.exe; objdump -s -j .rdata --start-address=0x405270 --stop-address=0x405280 extracted/brix_calc.exe | tail -2

s|mov    DWORD PTR \[esp+0x90\],0xd|&        <-- 기대 길이 = 13|
s|call   0x403ca8|&                       <-- msvcrt!strlen|
s|add    edx,0x404020|&        <-- .data 의 암호 테이블|
s|xor    edx,0x55|&                       <-- 키 0x55 로 복호|
s|cmp    al,dl|&                          <-- 입력 한 글자 vs 복호 한 글자|
s|mov    DWORD PTR \[esp+0x9c\],0x0|&        <-- 하나라도 틀리면 플래그 0|

objdump -d -M intel --start-address=0x4014d2 --stop-address=0x401575 extracted/brix_calc.exe | sed -f annot_check.sed

s|add    eax,0x404040|&           <-- .data 의 플래그 테이블|
s|xor    eax,0x77|&                       <-- 키 0x77 로 복호|
s|call   0x403ce0|&                       <-- msvcrt!putchar (한 글자씩 출력)|
s|cmp    eax,0x21|&                       <-- 0x21 까지, jbe 라서 34바이트|
s|mov    DWORD PTR \[esp\],0xa|&           <-- 마지막에 개행|

objdump -d -M intel --start-address=0x401599 --stop-address=0x4015e3 extracted/brix_calc.exe | sed -f annot_flag.sed

break *0x40148d
cont
x /13b 0x404020
x /34b 0x404040
kill
quit

WINEPREFIX="$HOME/.wine_brix" WINEDEBUG=-all winedbg ./brix_calc.exe < ../dbg_check.txt

#!/usr/bin/env python3
"""
Gyul Brix Calculator (DreamHack Bronze 2, reversing) — solver
 
brix_calc.exe 는 PE32(MinGW) 콘솔 프로그램이다. main 이 하는 일:
  1) scanf("%99s", buf)
  2) strlen(buf) == 13 이고 buf[i] == (data[0x404020+i] ^ 0x55) 이면 관리자 모드
  3) 관리자 모드에서 data[0x404040 + j] ^ 0x77 을 j=0..0x21(34바이트) 만큼 putchar
 
즉 암호도, 플래그도 XOR 한 겹으로 .data 에 그대로 들어 있다.
이 스크립트는 exe 파일에서 직접 두 블롭을 읽어 복호한다 — 하드코딩 없음.
"""
import struct
import sys
 
EXE = sys.argv[1] if len(sys.argv) > 1 else "extracted/brix_calc.exe"
 
PASS_VA, PASS_LEN, PASS_KEY = 0x404020, 13, 0x55     # 0x4014dd: mov [esp+0x90],0xd / 0x40153b: xor edx,0x55
FLAG_VA, FLAG_LEN, FLAG_KEY = 0x404040, 0x21 + 1, 0x77  # 0x4015d2: cmp eax,0x21 / jbe → 0..0x21
 
 
def section_table(blob):
    """PE 섹션 테이블을 struct 로 직접 파싱해 (name, VA, vsize, raw_ptr) 목록을 만든다."""
    e_lfanew = struct.unpack_from("<I", blob, 0x3C)[0]
    assert blob[e_lfanew:e_lfanew + 4] == b"PE\0\0", "PE 시그니처 없음"
    n_sec = struct.unpack_from("<H", blob, e_lfanew + 6)[0]
    opt_size = struct.unpack_from("<H", blob, e_lfanew + 20)[0]
    image_base = struct.unpack_from("<I", blob, e_lfanew + 24 + 28)[0]
    off = e_lfanew + 24 + opt_size
    secs = []
    for i in range(n_sec):
        name, vsize, va, rsize, rptr = struct.unpack_from("<8sIIII", blob, off + i * 40)
        secs.append((name.rstrip(b"\0").decode(), image_base + va, vsize, rptr, rsize))
    return secs
 
 
def va_to_off(secs, va):
    for name, sva, vsize, rptr, rsize in secs:
        if sva <= va < sva + max(vsize, rsize):
            return rptr + (va - sva)
    raise ValueError(f"VA {va:#x} 가 어느 섹션에도 없음")
 
 
def xor_read(blob, secs, va, length, key):
    off = va_to_off(secs, va)
    return bytes(b ^ key for b in blob[off:off + length])
 
 
blob = open(EXE, "rb").read()
secs = section_table(blob)
 
print(f"[*] {EXE}  ({len(blob)} bytes)")
for name, va, vsize, rptr, rsize in secs:
    print(f"    {name:<9} VA={va:#010x} vsize={vsize:#07x} rawptr={rptr:#07x}")
 
raw_pass = blob[va_to_off(secs, PASS_VA):va_to_off(secs, PASS_VA) + PASS_LEN]
raw_flag = blob[va_to_off(secs, FLAG_VA):va_to_off(secs, FLAG_VA) + FLAG_LEN]
print(f"\n[*] .data {PASS_VA:#x} raw : {raw_pass.hex(' ')}")
print(f"[*] .data {FLAG_VA:#x} raw : {raw_flag.hex(' ')}")
 
password = xor_read(blob, secs, PASS_VA, PASS_LEN, PASS_KEY).decode()
flag = xor_read(blob, secs, FLAG_VA, FLAG_LEN, FLAG_KEY).decode()
 
print(f"\n[+] PASSWORD (^{PASS_KEY:#04x}, {PASS_LEN}B) = {password}")
print(f"[+] FLAG     (^{FLAG_KEY:#04x}, {FLAG_LEN}B) = {flag}")

python3 solve.py extracted/brix_calc.exe

#!/usr/bin/env python3
"""brix_calc.exe 를 wine 으로 실제 실행해 solve.py 가 뽑은 암호를 검증한다.
 
echo 파이프 대신 subprocess input 을 쓴다(메모리 rev_wine_setup).
인자로 넘긴 문자열을 그대로 stdin 에 흘려 넣는다 — 프로그램이 마지막에
getchar() 두 번을 하므로 개행을 넉넉히 붙인다.
"""
import os
import subprocess
import sys
 
answer = sys.argv[1] if len(sys.argv) > 1 else "GiveMeVitamin"
env = dict(os.environ, WINEPREFIX=os.path.expanduser("~/.wine_brix"), WINEDEBUG="-all")
r = subprocess.run(
    ["wine", "extracted/brix_calc.exe"],
    input=answer + "\n\n\n",
    capture_output=True, text=True, env=env, timeout=120,
)
print(r.stdout.strip())

python3 run_wine.py GiveMeVitamin

#!/usr/bin/env python3
"""정적 분석으로 읽은 두 관문(길이 13 · 바이트별 비교)과 등급 임계값을
wine 으로 실제 실행해 확인한다. 입력마다 프로그램이 어느 분기로 갔는지 한 줄로 요약.
 
  - 길이 관문 : 0x4014dd 의 mov [esp+0x90],0xd
  - 바이트 관문: 0x40153b 의 xor edx,0x55 뒤 cmp al,dl
  - 등급 임계값: .rdata 0x405270/0x405274/0x405278 의 float 10 / 12 / 14
"""
import os
import subprocess
 
ENV = dict(os.environ, WINEPREFIX=os.path.expanduser("~/.wine_brix"), WINEDEBUG="-all")
 
CASES = [
    ("GiveMeVitami",  "12글자 — 길이 관문에서 탈락"),
    ("GiveMeVitaminX", "14글자 — 길이 관문에서 탈락"),
    ("GiveMeVitamiX",  "13글자·마지막 글자만 다름"),
    ("GiveMeVitamin",  "정답"),
    ("9.9",  "등급 임계 < 10"),
    ("10",   "등급 임계 10 <= x < 12"),
    ("12",   "등급 임계 12 <= x < 14"),
    ("14",   "등급 임계 14 <="),
    ("abc",  "atof 가 0.0 -> 에러 분기"),
]
 
 
def run(answer):
    r = subprocess.run(["wine", "extracted/brix_calc.exe"],
                       input=answer + "\n\n\n", capture_output=True,
                       text=True, env=ENV, timeout=120)
    for line in r.stdout.splitlines():
        line = line.strip()
        if line.startswith(("[!]", "[Result]", "[Error]")):
            return line
    return "(분기 없음)"
 
 
for answer, note in CASES:
    print(f"{answer:<15} | {run(answer):<48} | {note}")

python3 verify_gate.py