[🥉 Bronze 2] 난해한 언어 엄랭 읽어내기 — DreamHack 엄... 풀이

#!/usr/bin/env bash
# 배포본 정찰 — 무슨 파일이고, 어떤 글자로만 이루어졌나.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
file extracted/main.umm
wc -lc extracted/main.umm
echo
echo "[앞 48바이트]"
xxd -l 48 extracted/main.umm
echo
echo "[문자 인구조사 — 등장 횟수 순]"
python3 - <<'PY'
from collections import Counter
src = open('extracted/main.umm', encoding='utf-8').read()
for ch, n in Counter(src).most_common():
    name = {'\n': r'\n', ' ': '(공백)'}.get(ch, ch)
    print(f'  {name:<8} {n:>4}  U+{ord(ch):04X}  {len(ch.encode()):d}바이트')
PY

./recon.sh

어떻게
 
엄..... .............
어엄.......... ..........
어어엄..
어어어엄...........
어어어어엄..... .........
 
식어...ㅋ
식어.......ㅋ
식어어.......................ㅋ
식어.......ㅋ
식어어...........ㅋ
식어어...................ㅋ
식어어,,,,,ㅋ
식어어.....ㅋ
식어어...............ㅋ
식어어,,,,,ㅋ
식어어,,,,,,,,,,,,,,,ㅋ
식어어.........ㅋ
식어어,,,,,ㅋ
식어.........ㅋ
식어어.................ㅋ
식어어..........ㅋ
식어어...............ㅋ
식어어.....ㅋ
식어어.......ㅋ
식어어,,,,,ㅋ
식어어,,,ㅋ
식어어,,,,,ㅋ
식어어....ㅋ
식어어.................ㅋ
식어어.........ㅋ
식어어,,,ㅋ
식어어..........ㅋ
식어어,,,,,ㅋ
식어어..........ㅋ
식어어,,,ㅋ
식어어.........ㅋ
식어어.ㅋ
식어어,,,,,ㅋ
식어어........ㅋ
식어어...........ㅋ
식어어........ㅋ
어어어엄어어어어,
식어어어어!
동탄어어어어?준어어어어어....
준어어어어어
식어어.........................ㅋ
 
이 사람이름이냐ㅋㅋ

sed -n "122,161p" ref/umjunsik-README.md

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""umm_disasm.py — 엄랭(.umm) 정적 디스어셈블러.
 
실행하지 않고 줄 단위 구조만 뽑는다. 엄랭 v2 문법:
  엄   대입   (엄 앞의 '어' 개수 = 변수 인덱스 - 1)
  어   변수참조('어' 개수 = 변수 인덱스)
  .    +1     ,  -1      ' '(공백)  곱하기
  식...!   정수 출력     식...ㅋ  유니코드 문자 출력(빈 값이면 개행)
  동탄X?CMD  X가 0이면 CMD 실행     준N  N번째 줄로 점프
사용: python3 umm_disasm.py extracted/main.umm
      python3 umm_disasm.py extracted/main.umm --from 40 --to 51   # 구간만
"""
import argparse
 
 
def parse_num(expr):
    """숫자식을 사람이 읽는 기호식으로. 공백은 곱하기라 항끼리 '*' 로 잇는다."""
    terms = []
    for tok in expr.split(' '):
        eo, dot, com = tok.count('어'), tok.count('.'), tok.count(',')
        base = f'var{eo}' if eo else '0'
        delta = dot - com
        if eo and delta:
            terms.append(f'({base}{delta:+d})')
        elif eo:
            terms.append(base)
        else:
            terms.append(str(delta))
    return ' * '.join(terms)
 
 
def classify(line):
    """레퍼런스 런타임(umjunsik 2.0.2)과 같은 우선순위로 줄 종류를 가른다."""
    if line == '':
        return 'BLANK', ''
    if line in ('어떻게', '이 사람이름이냐ㅋㅋ'):
        return 'MARKER', line
    if '동탄' in line:
        cond, cmd = line.replace('동탄', '').split('?', 1)
        _, inner = classify(cmd.strip())
        return 'IF', f'if ({parse_num(cond)}) == 0  ->  {inner}'
    if '준' in line:
        return 'GOTO', f'goto line {parse_num(line.replace("준", ""))}'
    if '화이팅!' in line:
        return 'EXIT', f'exit {parse_num(line.split("화이팅!")[1])}'
    if '식' in line and '?' in line:
        return 'INPUT', f'var{line.replace("식?", "").count("어")} <- stdin'
    if '식' in line and line.endswith('!'):
        return 'PUTINT', f'print_int({parse_num(line[1:-1])})'
    if '식' in line and line.endswith('ㅋ'):
        body = line[1:-1]
        return 'PUTCHAR', 'newline' if body == '' else f'putchar({parse_num(body)})'
    if '엄' in line:
        var, val = line.split('엄', 1)
        return 'ASSIGN', f'var{var.count("어") + 1} <- {parse_num(val)}'
    return 'UNKNOWN', line
 
 
def main(path, lo=1, hi=10 ** 9):
    src = open(path, encoding='utf-8').read().rstrip('\n')
    lines = src.split('\n')
    print(f'{path}: {len(lines)} lines  (표시 {max(lo, 1)}~{min(hi, len(lines))})')
    print(f"{'ln':>3} {'kind':<8} {'meaning'}")
    print('-' * 62)
    for i, raw in enumerate(lines, 1):
        if not lo <= i <= hi:
            continue
        kind, meaning = classify(raw.strip())
        if kind == 'BLANK':
            print(f'{i:>3} {"":<8} .')
        else:
            print(f'{i:>3} {kind:<8} {meaning}')
 
 
if __name__ == '__main__':
    ap = argparse.ArgumentParser()
    ap.add_argument('path', nargs='?', default='extracted/main.umm')
    ap.add_argument('--from', dest='lo', type=int, default=1)
    ap.add_argument('--to', dest='hi', type=int, default=10 ** 9)
    a = ap.parse_args()
    main(a.path, a.lo, a.hi)

python3 umm_disasm.py extracted/main.umm --to 26

python3 umm_disasm.py extracted/main.umm --from 27

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""umm_interp.py — 엄랭(.umm) 인터프리터 + 실행 추적기.
 
레퍼런스 런타임(umjunsik 2.0.2)의 의미를 그대로 옮겨 적되, --trace 로
줄 번호 / 변수 상태 / 출력 바이트를 매 스텝 찍는다.
 
  python3 umm_interp.py extracted/main.umm            # 그냥 실행
  python3 umm_interp.py extracted/main.umm --trace    # 스텝 추적
  python3 umm_interp.py extracted/main.umm --trace --from 44 --to 50
"""
import sys
 
MAXVAR = 256
 
 
class Umm:
    def __init__(self, src, trace=False, lo=1, hi=10 ** 9):
        # 준(goto)이 세는 줄 번호는 '어떻게' 를 1번으로 하고 빈 줄도 그대로 센다.
        self.lines = src.rstrip('\n').split('\n')
        self.var = [0] * MAXVAR
        self.out = []
        self.trace = trace
        self.lo, self.hi = lo, hi
 
    def num(self, expr):
        """공백은 곱하기. 항 하나 = (변수값 or 0) + 온점개수 - 반점개수."""
        result = 1
        for tok in expr.split(' '):
            eo = tok.count('어')
            result *= (self.var[eo - 1] if eo else 0) + tok.count('.') - tok.count(',')
        return result
 
    def log(self, pc, msg):
        if self.trace and self.lo <= pc <= self.hi:
            v = ' '.join(f'v{i + 1}={self.var[i]}' for i in range(5))
            print(f'  [line {pc:>2}] {msg:<40} | {v}')
 
    def step(self, pc, line):
        """한 줄 실행. 점프하면 다음 줄 번호를, 아니면 None 을 돌려준다."""
        if line == '' or line in ('어떻게', '이 사람이름이냐ㅋㅋ'):
            return None
        if '동탄' in line:
            cond, cmd = line.replace('동탄', '').split('?', 1)
            taken = self.num(cond) == 0
            self.log(pc, f'if {self.num(cond)}==0 -> {"taken" if taken else "fall"}')
            return self.step(pc, cmd.strip()) if taken else None
        if '준' in line:
            dst = self.num(line.replace('준', ''))
            self.log(pc, f'goto {dst}')
            return dst
        if '화이팅!' in line:
            sys.stdout.write(str(self.num(line.split('화이팅!')[1])))
            sys.exit(0)
        if '식' in line and '?' in line:
            self.var[line.replace('식?', '').count('어')] = int(input())
            return None
        if '식' in line and line.endswith('!'):
            val = self.num(line[1:-1])
            self.emit(str(val))
            self.log(pc, f'print_int {val}')
            return None
        if '식' in line and line.endswith('ㅋ'):
            val = self.num(line[1:-1])
            ch = chr(val) if val else '\n'
            self.emit(ch)
            self.log(pc, f'putchar {val} -> {ch!r}')
            return None
        if '엄' in line:
            head, val = line.split('엄', 1)
            idx = head.count('어')
            self.var[idx] = self.num(val)
            self.log(pc, f'var{idx + 1} = {self.var[idx]}')
            return None
        raise SyntaxError(f'line {pc}: 어떻게 이게 엄랭이냐! {line!r}')
 
    def emit(self, s):
        self.out.append(s)
        if not self.trace:          # 추적 중이면 로그와 섞이지 않게 모아 뒀다 끝에 한 번
            sys.stdout.write(s)
            sys.stdout.flush()
 
    def run(self, budget=100000):
        pc = 1
        while 1 <= pc <= len(self.lines):
            if budget <= 0:
                raise RecursionError(f'스텝 예산 소진, pc={pc} (무한 루프)')
            budget -= 1
            jump = self.step(pc, self.lines[pc - 1].strip())
            pc = jump if jump is not None else pc + 1
        return ''.join(self.out)
 
 
def main():
    args = [a for a in sys.argv[1:] if not a.startswith('--')]
    path = args[0] if args else 'extracted/main.umm'
    lo = int(sys.argv[sys.argv.index('--from') + 1]) if '--from' in sys.argv else 1
    hi = int(sys.argv[sys.argv.index('--to') + 1]) if '--to' in sys.argv else 10 ** 9
    src = open(path, encoding='utf-8').read()
    vm = Umm(src, trace='--trace' in sys.argv, lo=lo, hi=hi)
    out = vm.run()
    print(f'\n--- stdout {len(out)} chars ---')
    print(out)
 
 
if __name__ == '__main__':
    main()

python3 umm_interp.py extracted/main.umm --trace --from 3 --to 14

sed -n "225,238p" ref/umjunsik-README.md

python3 umm_interp.py extracted/main.umm --trace --from 46 --to 49

#!/usr/bin/env bash
# 교차검증용 레퍼런스 런타임(pip umjunsik)을 문제 폴더 안 venv 로 깐다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
python3 -m venv .venv
./.venv/bin/pip install -q umjunsik
./.venv/bin/pip show umjunsik | sed -n "1,2p"

.venv/bin/pip show umjunsik | sed -n "1,2p" && .venv/bin/umjunsik extracted/main.umm

#!/usr/bin/env bash
# 엄랭 공식 저장소의 C 구현체(umcc)를 받아 빌드하고 main.umm 을 네이티브로 컴파일한다.
# 산출물: build/main_umcc (실행파일), build/main_umcc.c (생성된 C 소스)
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
SRC=${1:-/tmp/umjunsik-lang}
[ -d "$SRC" ] || git clone --depth 1 https://github.com/rycont/umjunsik-lang.git "$SRC"
make -C "$SRC/umjunsik-lang-cc"
 
mkdir -p build
"$SRC/umjunsik-lang-cc/bin/umcc" extracted/main.umm -o build/main_umcc
"$SRC/umjunsik-lang-cc/bin/umcc" -c extracted/main.umm -o build/main_umcc.c
echo "built: build/main_umcc, build/main_umcc.c"

./build_umcc.sh && ./build/main_umcc

#!/usr/bin/env bash
# umcc 가 뽑아낸 C 소스는 통째로 한 줄이라 읽을 수가 없다.
# 줄 라벨(_1: _2: ...) 앞에서 개행을 넣어 사람이 읽을 수 있게 편 뒤 필요한 구간만 보여준다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
FROM=${1:-45}
TO=${2:-50}
sed 's/_\([0-9]\{1,\}\):/\n_\1:/g' build/main_umcc.c \
  | sed -n "/^_${FROM}:/,/^_${TO}:/p"

./show_umcc_c.sh 3 9 && ./show_umcc_c.sh 45 50

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""verify.py — 내 해석이 맞는지 독립 구현 두 개와 대조한다.
 
  1. solve.py            직접 구현 (의존성 없음)
  2. umjunsik 2.0.2      pip 레퍼런스 런타임 (.venv/bin/umjunsik)
  3. umcc                엄랭 -> C 컴파일러가 만든 네이티브 바이너리 (build/main_umcc)
 
셋 다 없으면 없는 대로 표시하고 있는 것끼리만 비교한다.
  python3 verify.py
"""
import pathlib
import subprocess
import sys
 
import solve
 
HERE = pathlib.Path(__file__).resolve().parent
UMM = HERE / 'extracted' / 'main.umm'
 
 
def shell(cmd):
    """실행해서 stdout 을 돌려준다. 실행 파일이 없으면 None."""
    if not pathlib.Path(cmd[0]).exists():
        return None
    p = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
    return p.stdout
 
 
def main():
    results = {}
    results['solve.py (직접 구현)'] = solve.evaluate(UMM.read_text(encoding='utf-8'))
    results['umjunsik 2.0.2 (pip 레퍼런스)'] = shell([str(HERE / '.venv/bin/umjunsik'), str(UMM)])
    results['umcc (엄랭->C 컴파일)'] = shell([str(HERE / 'build/main_umcc')])
 
    for name, out in results.items():
        if out is None:
            print(f'  --  {name:<30} (없음, 건너뜀)')
        else:
            print(f'      {name:<30} {out.strip()!r}')
 
    got = [v.strip() for v in results.values() if v is not None]
    print()
    if len(got) >= 2 and len(set(got)) == 1:
        print(f'MATCH  구현 {len(got)}개가 같은 출력을 낸다: {got[0]}')
        return 0
    print(f'MISMATCH  {set(got)}')
    return 1
 
 
if __name__ == '__main__':
    sys.exit(main())

python3 verify.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""solve.py — DreamHack '엄...' (Bronze 2, misc)
 
main.umm 은 엄랭(umjunsik-lang) v2 소스다. 외부 런타임 없이 이 파일 하나로
해석해서 flag 를 뽑는다. 의존성 없음.
 
  python3 solve.py                    # extracted/main.umm
  python3 solve.py 다른파일.umm
"""
import re
import sys
 
MAXVAR = 256
 
 
def evaluate(src):
    """엄랭 v2 소스를 실행하고 표준출력 문자열을 돌려준다.
 
    문법 요약
      .  +1        ,  -1        ' '(공백)  곱하기
      어 * n            n번째 변수 참조
      (어 * (n-1)) 엄   n번째 변수에 대입
      식 <수> !         정수 출력
      식 <수> ㅋ        유니코드 문자 출력 (수가 없으면 개행)
      동탄 <수> ? <명령> 수가 0이면 명령 실행
      준 <수>           그 번호의 줄로 점프 ('어떻게' 가 1번, 빈 줄도 센다)
      화이팅! <수>      그 값을 찍고 종료
    """
    lines = src.rstrip('\n').split('\n')
    var = [0] * MAXVAR
    out = []
 
    def num(expr):
        result = 1
        for tok in expr.split(' '):          # 공백은 곱하기
            eo = tok.count('어')
            result *= (var[eo - 1] if eo else 0) + tok.count('.') - tok.count(',')
        return result
 
    def step(line):
        """한 줄 실행. 점프하면 목적지 줄 번호, 아니면 None."""
        if line == '' or line in ('어떻게', '이 사람이름이냐ㅋㅋ'):
            return None
        if '동탄' in line:                                    # 조건: 0이면 실행
            cond, cmd = line.replace('동탄', '').split('?', 1)
            return step(cmd.strip()) if num(cond) == 0 else None
        if '준' in line:                                      # 무조건 점프
            return num(line.replace('준', ''))
        if '화이팅!' in line:
            out.append(str(num(line.split('화이팅!')[1])))
            raise SystemExit
        if '식' in line and '?' in line:
            var[line.replace('식?', '').count('어')] = int(input())
            return None
        if '식' in line and line.endswith('!'):               # 정수 출력
            out.append(str(num(line[1:-1])))
            return None
        if '식' in line and line.endswith('ㅋ'):              # 문자 출력
            val = num(line[1:-1])
            out.append(chr(val) if val else '\n')
            return None
        if '엄' in line:                                      # 대입
            head, val = line.split('엄', 1)
            var[head.count('어')] = num(val)
            return None
        raise SyntaxError(f'어떻게 이게 엄랭이냐! {line!r}')
 
    pc, budget = 1, 1000000
    try:
        while 1 <= pc <= len(lines):
            budget -= 1
            if budget <= 0:
                raise RecursionError(f'무한 루프 (pc={pc})')
            jump = step(lines[pc - 1].strip())
            pc = jump if jump is not None else pc + 1
    except SystemExit:
        pass
    return ''.join(out)
 
 
def main():
    path = sys.argv[1] if len(sys.argv) > 1 else 'extracted/main.umm'
    text = evaluate(open(path, encoding='utf-8').read())
    print(f'[출력] {text}')
    flag = re.search(r'DH\{[^}]+\}', text)
    if not flag:
        print('[!] flag 형식을 못 찾았다')
        sys.exit(1)
    print(f'[FLAG] {flag.group(0)}')
 
 
if __name__ == '__main__':
    main()

python3 solve.py

#!/usr/bin/env bash
# 엄... (DreamHack Bronze 2, misc) — 한 방 재현.
# extracted/main.umm 을 직접 구현한 엄랭 인터프리터로 해석해 flag 를 뽑고 대조한다.
# 외부 런타임·네트워크 불필요. python3 만 있으면 된다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
OUT=$(timeout 60 python3 solve.py 2>&1) || true
echo "$OUT"
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -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