[🥉 Bronze 3] 약관 27개 조문에 숨은 36글자 — DreamHack 서비스 이용 약관 풀이

file extracted/tos.txt && wc -c extracted/tos.txt && head -c 96 extracted/tos.txt && echo

xxd -l 224 extracted/tos.txt

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""hex 를 되돌린 뒤 어떤 문자 인코딩인지 실제로 찔러본다.
 
부수 효과로 extracted/tos.bin (hex 를 푼 날바이트) 을 남긴다.
iconv 같은 외부 도구로 교차확인할 때 이 파일을 쓴다.
"""
import binascii
from pathlib import Path
 
import chardet
 
HERE = Path(__file__).resolve().parent
TOS = HERE / "extracted" / "tos.txt"
BIN = HERE / "extracted" / "tos.bin"
 
raw = TOS.read_bytes()
hex_line = raw.split(b"\r\n")[2]
blob = binascii.unhexlify(hex_line)
BIN.write_bytes(blob)
print(f"[hex] {len(hex_line)}자 -> {len(blob)}바이트, {BIN.name} 로 저장")
print(f"[hex] 앞 16바이트 : {blob[:16].hex(' ')}")
print()
 
for enc in ("utf-8", "utf-16-le", "euc-kr", "cp949", "johab"):
    try:
        s = blob.decode(enc)
    except UnicodeDecodeError as e:
        print(f"[{enc:<9}] FAIL  {e.reason} @ offset {e.start}")
    except LookupError:
        print(f"[{enc:<9}] SKIP  코덱 없음")
    else:
        print(f"[{enc:<9}] OK    {len(s)}글자 | 첫 줄 = {s.splitlines()[0]}")
 
print()
guess = chardet.detect(blob)
print(f"[chardet] encoding={guess['encoding']} confidence={guess['confidence']:.2f} language={guess['language']}")

python3 probe_encoding.py

iconv -f UTF-8 -t UTF-8 extracted/tos.bin | wc -c; iconv -f EUC-KR -t UTF-8 extracted/tos.bin | sed -n "1,4p"

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""복원된 약관 본문의 글자를 종류별로 세어 '튀는 글자' 를 찾아낸다.
 
약관은 한글 + ASCII 로만 이뤄져야 정상이다. 그 밖의 글자가 남으면
그게 곧 출제자가 심어 둔 것이다.
"""
import unicodedata
from collections import Counter
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
BIN = HERE / "extracted" / "tos.bin"
 
text = BIN.read_bytes().decode("euc-kr")
 
 
def kind(ch: str) -> str:
    o = ord(ch)
    if o < 0x80:
        return "ASCII"
    if 0xAC00 <= o <= 0xD7A3:
        return "한글"
    if 0xFF01 <= o <= 0xFF5E:
        return "전각ASCII"
    return "기타"
 
 
tally = Counter(kind(c) for c in text)
print(f"본문 {len(text)}글자")
for k, n in tally.most_common():
    print(f"  {k:<9} {n:>6}")
print()
 
print("한글/ASCII 가 아닌 글자 (많은 순):")
odd = Counter(c for c in text if kind(c) not in ("ASCII", "한글"))
for ch, n in odd.most_common(12):
    print(f"  U+{ord(ch):04X}  {ch}  x{n:<3} {unicodedata.name(ch, '?')}")
print(f"  ... 총 {len(odd)}종")
print()
 
hits = [i for i, c in enumerate(text) if kind(c) == "전각ASCII"]
print(f"전각 ASCII {len(hits)}글자, 위치 {hits[0]}~{hits[-1]}")
print(f"그 구간 원문 : {text[hits[0]:hits[-1] + 1]}")

python3 charscan.py

xxd -s 19968 -l 144 extracted/tos.bin

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
DreamHack "서비스 이용 약관" (Bronze 3, misc/crypto) — solve
 
tos.txt 는 이렇게 생겼다.
 
    Encoded toc (hex)\r\n
    \r\n
    c0ccbfebbee0b0fc0d0ac1a631c0e5...      <- 51050자 한 줄
 
풀이는 세 겹이다.
  1) 헤더를 떼고 hex 를 바이트로 되돌린다.
  2) 그 바이트는 UTF-8 이 아니라 EUC-KR 이다 (= 문제가 말하는 "잘못된 인코딩").
  3) 복원된 약관 본문 안에서 flag 는 '전각(fullwidth) 라틴' 으로 심어져 있다.
     본문 제18조 ⑤ 가 "다음 문자열을 NFKC 정규화한 것" 이라고 알려 준다.
 
EUC-KR 에서 전각 ASCII 는 A3 행에 있고, 뒷바이트는 정확히 (ASCII | 0x80) 이다.
  'D' = 0x44        ->  'Ｄ' = 0xA3 0xC4
그래서 EUC-KR 스트림을 걸으며 선두 바이트가 0xA3 인 글자만 모으면
유니코드 테이블 없이도 같은 답이 나온다 (verify_a3_row 가 그걸 확인한다).
"""
import binascii
import sys
import unicodedata
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
TOS = HERE / "extracted" / "tos.txt"
 
 
def load_hex(path: Path) -> bytes:
    """헤더 2줄을 떼고 hex 본문만 바이트로 되돌린다."""
    raw = path.read_bytes()
    parts = raw.split(b"\r\n")
    hex_line = parts[2]
    print(f"[1] {path.name}: {len(raw)}바이트, 헤더={parts[0].decode()!r}")
    print(f"[1] hex 본문 {len(hex_line)}자 -> {len(hex_line)//2}바이트")
    return binascii.unhexlify(hex_line)
 
 
def pick_encoding(blob: bytes) -> str:
    """UTF-8 은 깨지고 EUC-KR 로만 읽힌다는 것을 실제로 보여 준다."""
    for enc in ("utf-8", "euc-kr"):
        try:
            blob.decode(enc)
        except UnicodeDecodeError as e:
            print(f"[2] {enc:<7} 디코드 실패 - {e.reason} (offset {e.start})")
        else:
            print(f"[2] {enc:<7} 디코드 성공")
            good = enc
    return good
 
 
def walk_euckr(blob: bytes):
    """EUC-KR 스트림을 걸으며 (바이트열, 글자) 를 순서대로 내놓는다.
 
    바이트를 그냥 grep 하면 안 된다. 0xA3 은 다른 한글의 '뒷바이트' 로도
    나오기 때문에(파일 전체에 79개, 그 중 선두는 36개뿐) 선두/후행 구분을 지켜야 한다.
    """
    i = 0
    while i < len(blob):
        n = 2 if blob[i] >= 0x80 else 1
        chunk = blob[i:i + n]
        yield chunk, chunk.decode("euc-kr")
        i += n
 
 
def verify_a3_row(blob: bytes) -> str:
    """선두 바이트가 0xA3(전각 ASCII 행)인 글자만 모은다."""
    out = []
    for chunk, ch in walk_euckr(blob):
        if len(chunk) == 2 and chunk[0] == 0xA3:
            out.append(chr(chunk[1] - 0x80))
    naive = blob.count(b"\xa3")
    print(f"[5] 0xA3 을 단순 바이트로 세면 {naive}개 (후행바이트 오탐 포함)")
    print(f"[5] EUC-KR 스트림을 걸어서 고른 전각 글자: {len(out)}개")
    return "".join(out)
 
 
def extract_flag(text: str) -> str:
    """전각 라틴이 연속으로 이어지는 가장 긴 구간을 뽑아 NFKC 정규화한다."""
    runs, cur = [], ""
    for ch in text:
        if 0xFF01 <= ord(ch) <= 0xFF5E:
            cur += ch
        else:
            if cur:
                runs.append(cur)
            cur = ""
    if cur:
        runs.append(cur)
    runs.sort(key=len, reverse=True)
    print(f"[4] 전각 구간 {len(runs)}개, 가장 긴 것 {len(runs[0])}자")
    print(f"[4] 원문 그대로 : {runs[0]}")
    return unicodedata.normalize("NFKC", runs[0])
 
 
def find_decoy(text: str) -> str:
    """제27조가 '이건 플래그가 아니다' 라고 못박아 둔 미끼."""
    decoy = "DH{New_Dreamhack_Terms_Of_Service}"
    line = next(l for l in text.splitlines() if decoy in l)
    print(f"[3] 본문에 박힌 미끼 {decoy}")
    print(f"[3] 제27조 원문 : {line.strip()}")
    return decoy
 
 
def main() -> int:
    blob = load_hex(TOS)
    enc = pick_encoding(blob)
    text = blob.decode(enc)
 
    find_decoy(text)
    flag = extract_flag(text)
 
    a3 = unicodedata.normalize("NFKC", verify_a3_row(blob))
    assert flag in a3, "A3 행 교차검증 실패"
    print(f"[6] 교차검증(0xA3 행 전체) : {a3}")
 
    print()
    print(f"FLAG: {flag}")
    return 0
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 solve.py

DH{Do_Y0u_Know_EUC-KR_enc0ding?}

#!/usr/bin/env bash
# 서비스 이용 약관 (DreamHack Bronze 3, misc/crypto) — 한 방 재현
# tos.txt 만 있으면 flag 까지 간다. 서버·네트워크 불필요.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
if [ ! -f extracted/tos.txt ]; then
  echo "❌ extracted/tos.txt 가 없습니다 (challenge_2189.zip 을 풀어 주세요)"
  exit 1
fi
 
# tos.bin(hex 를 푼 날바이트)은 probe_encoding.py 가 만든다. solve.py 는 tos.txt 만으로도 돈다.
_probe=$(python3 probe_encoding.py 2>&1) || true
 
OUT=$(timeout 120 python3 solve.py 2>&1) || true
 
echo "$OUT" | tail -8
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | tail -1)
 
if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

./reproduce.sh