[💠 Platinum 3] 실행 중에 자기 바이트코드를 갈아끼우는 .pyc — DreamHack pyc 풀이

file extracted/prob.pyc; xxd -l 48 extracted/prob.pyc; docker run --rm python:3.10-slim python -c "import importlib.util,sys;print(\"py\",sys.version.split()[0],\"MAGIC\",importlib.util.MAGIC_NUMBER.hex(\" \"))"

# dis_pyc.py — prob.pyc 를 Python 3.10 인터프리터에서 마샬 해제해 dis.dis 로 뿌린다.
import dis, marshal, sys, importlib.util
 
path = sys.argv[1] if len(sys.argv) > 1 else "prob.pyc"
with open(path, "rb") as f:
    magic = f.read(4)
    flags = int.from_bytes(f.read(4), "little")
    f.read(8)                     # timestamp + source size
    code = marshal.load(f)
 
print(f"# magic={magic.hex()} flags={flags} python={sys.version.split()[0]}")
dis.dis(code)

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python dis_pyc.py extracted/prob.pyc > dis_top.txt 2>&1; sed -n '1,26p' dis_top.txt

sed -n '27,86p' dis_top.txt

ipt = input().encode()          # 22행
 
import ctypes                   # 24행
def throw(): ...                # 25행
 
try:                            # 44행
    if ipt.find('GoN{') != -1 and chk(ipt) == bytes(k):
        print('Good!')          # 46행
except:                         # 47행
    throw()                     # 48행

# why_throw.py — main 의 try 블록이 '항상' 예외로 빠지는 이유를 확인한다.
ipt = "GoN{aaaa}".encode()
print(f"ipt = {ipt!r}  (type={type(ipt).__name__})")
try:
    print(ipt.find("GoN{"))
except TypeError as e:
    print(f"ipt.find('GoN{{') → TypeError: {e}")
print(f"참고: 올바른 호출 ipt.find(b'GoN{{') = {ipt.find(b'GoN{')}")

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python why_throw.py

sed -n '163,184p' dis_top.txt

 26           0 JUMP_ABSOLUTE            3 (to 6)
Traceback (most recent call last):
  ...
IndexError: tuple index out of range

오프셋  바이트   dis 의 해석            실제
  0    71 03   JUMP_ABSOLUTE 3        6번지로 점프 (인자는 명령 단위 × 2)
  2    65 ff   LOAD_NAME 255          ← 실행되지 않는 쓰레기
  4    ff 09   (opcode 255 = 미정의)   ← 실행되지 않는 쓰레기
  6    09 09   NOP                    여기가 진짜 시작

# dump_code.py — dis 가 포기한 코드 객체까지 전부 훑어 원시 필드를 그대로 뽑는다.
import marshal, sys, types
 
def load(path):
    with open(path, "rb") as f:
        f.read(16)
        return marshal.load(f)
 
def walk(co, depth=0):
    pad = "  " * depth
    print(f"{pad}=== code {co.co_name!r} (line {co.co_firstlineno}) ===")
    print(f"{pad}argcount={co.co_argcount} nlocals={co.co_nlocals} stacksize={co.co_stacksize} flags={co.co_flags:#x}")
    print(f"{pad}names    = {co.co_names}")
    print(f"{pad}varnames = {co.co_varnames}")
    print(f"{pad}consts   = {[c if not isinstance(c, types.CodeType) else f'<code {c.co_name}>' for c in co.co_consts]}")
    print(f"{pad}co_code({len(co.co_code)}B) = {co.co_code.hex()}")
    print()
    for c in co.co_consts:
        if isinstance(c, types.CodeType):
            walk(c, depth + 1)
 
walk(load(sys.argv[1]))

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python dump_code.py extracted/prob.pyc > dump_code.txt 2>&1; sed -n '/=== code .throw./,$p' dump_code.txt

('ctypes', 'c_char', 'len', 'm', 'from_address', 'id', 'chk',
 '__code__', 'co_code', 'zip', 'raw', 'append', 'bytes', 'ipt', 'k',
 'print', 'co_consts')

# disasm_raw.py — dis 가 포기한 코드 객체를, 실제 실행 흐름이 착지하는 오프셋부터 직접 디코드한다.
import dis, marshal, sys, types
 
def load(path):
    with open(path, "rb") as f:
        f.read(16)
        return marshal.load(f)
 
def find(co, name):
    if co.co_name == name:
        return co
    for c in co.co_consts:
        if isinstance(c, types.CodeType):
            r = find(c, name)
            if r:
                return r
 
def safe(seq, i):
    try:
        v = seq[i]
    except IndexError:
        return "<OOB>"
    return f"<code {v.co_name}>" if isinstance(v, types.CodeType) else repr(v)
 
def show(co, start=0):
    code = co.co_code
    i, ext = start, 0
    while i < len(code):
        op, arg = code[i], code[i + 1]
        arg |= ext
        ext = 0
        nm = dis.opname[op]
        extra = ""
        if op in dis.hasname:
            extra = f"({safe(co.co_names, arg)})"
        elif op in dis.hasconst:
            extra = f"({safe(co.co_consts, arg)})"
        elif op in dis.haslocal:
            extra = f"({safe(co.co_varnames, arg)})"
        elif op in dis.hasjabs:
            extra = f"-> {arg * 2}"
        elif op in dis.hasjrel:
            extra = f"-> {i + 2 + arg * 2}"
        elif op in dis.hascompare:
            extra = f"({dis.cmp_op[arg]})"
        print(f"{i:5}  {op:3} {nm:<24} {arg:<4} {extra}")
        if nm == "EXTENDED_ARG":
            ext = arg << 8
        i += 2
 
co = load(sys.argv[1])
target = find(co, sys.argv[2])
show(target, int(sys.argv[3]) if len(sys.argv) > 3 else 0)

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python disasm_raw.py extracted/prob.pyc throw 6 > dis_throw.txt; sed -n '1,33p' dis_throw.txt

ptr1 = (ctypes.c_char * len(m)).from_address(id(chk.__code__.co_code) + 32)
 
res = []
for i, j in zip(ptr1.raw, m):
    res.append(i ^ j)

sed -n '34,85p' dis_throw.txt

def throw():
    # chk 의 바이트코드 버퍼를 잡는다
    ptr1 = (ctypes.c_char * len(m)).from_address(id(chk.__code__.co_code) + 32)
 
    # 1차 XOR — 여기서 chk 가 '진짜 chk' 로 바뀐다
    res = []
    for i, j in zip(ptr1.raw, m):
        res.append(i ^ j)
    ptr1.raw = bytes(res)
 
    # 진짜 검사
    if chk(ipt) == bytes(k):
        print(chk.__code__.co_consts[8])      # co_consts[8] == 'Good!'
 
    # 2차 XOR — 원본으로 되돌린다
    res = []
    for i, j in zip(ptr1.raw, m):
        res.append(i ^ j)
    ptr1.raw = bytes(res)

typedef struct {
    PyObject_VAR_HEAD          /* ob_refcnt(8) + ob_type(8) + ob_size(8) */
    Py_hash_t ob_shash;        /* 8 */
    char ob_sval[1];           /* ← 여기부터 실제 바이트 */
} PyBytesObject;

# bytes_layout.py — throw() 가 쓰는 id(bytes 객체) + 32 가 정말 바이트 버퍼의 시작인지 확인한다.
import ctypes, sys, struct
 
b = b"ABCDEFGH-0123456789"
addr = id(b)
 
print(f"python           = {sys.version.split()[0]}")
print(f"id(b)            = {addr:#x}")
print(f"헤더 32B 덤프    = {ctypes.string_at(addr, 32).hex(' ')}")
refcnt, _typ, size, shash = struct.unpack("qqqq", ctypes.string_at(addr, 32))
print(f"  ob_size        = {size}   (len(b) = {len(b)})")
print(f"id(b)+32 에서 읽기 = {ctypes.string_at(addr + 32, len(b))!r}")
print(f"원본             = {b!r}")
print(f"일치?            = {ctypes.string_at(addr + 32, len(b)) == b}")
 
# throw() 와 똑같이 c_char 배열을 씌워 제자리 수정까지 해 본다
buf = (ctypes.c_char * len(b)).from_address(addr + 32)
buf.raw = bytes(c ^ 0x20 for c in b)
print(f"XOR 0x20 후 b    = {b!r}   ← 불변 객체가 바뀌었다")

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python bytes_layout.py

# patch_chk.py — throw() 가 런타임에 하는 XOR 패치를 정적으로 재현해 진짜 chk 를 만든다.
import dis, marshal, sys, types
 
with open("extracted/prob.pyc", "rb") as f:
    f.read(16)
    top = marshal.load(f)
 
consts = top.co_consts
m = consts[4]                                   # 패치 마스크
chk = next(c for c in consts if isinstance(c, types.CodeType) and c.co_name == "chk")
 
real = bytes(a ^ b for a, b in zip(chk.co_code, m))
print(f"# len(co_code)={len(chk.co_code)} len(m)={len(m)}")
print(f"# real co_code = {real.hex()}\n")
 
real_code = chk.replace(co_code=real)
dis.dis(real_code)

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python patch_chk.py

 44 LOAD_FAST 0 (ipt) / 46 LOAD_CONST 0 (None) / 48 LOAD_FAST 1 (i)
 50 BUILD_SLICE 2 / 52 BINARY_SUBSCR          →  ipt[:i]
 
 54 LOAD_FAST 2 (r0)
 56 LOAD_FAST 1 (i) / 58 LOAD_CONST 4 (16) / 60 BINARY_ADD
 62 LOAD_CONST 5 (32) / 64 BINARY_MODULO      →  (i + 16) % 32
 66 BINARY_RSHIFT                             →  r0 >> ((i + 16) % 32)
 
 68 LOAD_FAST 2 (r0)
 70 LOAD_CONST 4 (16) / 72 LOAD_FAST 1 (i) / 74 BINARY_SUBTRACT
 76 LOAD_CONST 5 (32) / 78 BINARY_MODULO      →  (16 - i) % 32
 80 BINARY_LSHIFT                             →  r0 << ((16 - i) % 32)
 
 82 BINARY_OR
 84 LOAD_CONST 6 (4294967295) / 86 BINARY_AND →  & 0xFFFFFFFF
 88 LOAD_CONST 7 (3735928559) / 90 BINARY_XOR →  ^ 0xDEADBEEF

def chk(ipt):
    for i in range(len(ipt) - 3):
        r0 = int.from_bytes(ipt[i:i+4], 'little')
        v  = (((r0 >> ((i + 16) % 32)) | (r0 << ((16 - i) % 32))) & 0xFFFFFFFF) ^ 0xDEADBEEF
        ipt = ipt[:i] + v.to_bytes(4, 'little') + ipt[i+4:]
    return ipt

def unchk(out: bytes) -> bytes:
    for i in reversed(range(len(out) - 3)):
        v = int.from_bytes(out[i:i + 4], "little")
        r0 = rotl(v ^ 0xDEADBEEF, (i + 16) % 32)
        out = out[:i] + r0.to_bytes(4, "little") + out[i + 4:]
    return out

# runtime_probe.py — throw() 가 '실행 중에' chk 의 바이트코드를 갈아끼우는지 직접 확인한다.
import marshal, hashlib, types
 
FLAG = "GoN{S3lf-m0d1fy1ng-pyc_n0_more_pyc_ch4l13ng3_p1z}"
 
with open("extracted/prob.pyc", "rb") as f:
    f.read(16)
    top = marshal.load(f)
 
chk_co = next(c for c in top.co_consts
              if isinstance(c, types.CodeType) and c.co_name == "chk")
m = top.co_consts[4]
orig = chk_co.co_code
patched = bytes(a ^ b for a, b in zip(orig, m)) + orig[len(m):]
 
sha = lambda x: hashlib.sha1(x).hexdigest()[:16]
print(f"원본  co_code sha1[:16] = {sha(orig)}")
print(f"기대  패치본  sha1[:16] = {sha(patched)}")
 
g = {"__name__": "__main__", "__builtins__": __builtins__}
g["input"] = lambda *a: FLAG
 
 
def spy(*args):
    live = g["chk"].__code__.co_code
    print(f"[print() 호출 시점] co_code sha1[:16] = {sha(live)}"
          f"  → 패치본과 일치? {live == patched}")
    print("[print() 호출 시점] chk 가 넘긴 값 =", *args)
 
 
g["print"] = spy
exec(top, g)
 
after = g["chk"].__code__.co_code
print(f"실행 끝난 뒤 co_code sha1[:16] = {sha(after)}  → 원본으로 복구? {after == orig}")

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python runtime_probe.py

#!/usr/bin/env python3
"""pyc (DreamHack, Platinum 3) 솔버.
 
throw() 가 ctypes 로 chk.__code__.co_code 를 m 과 XOR 해 갈아끼운 뒤 실행하는
'진짜' chk 는 아래와 같다 — 4바이트 창을 앞에서 뒤로 밀며 제자리 변환한다.
 
    for i in range(len(ipt) - 3):
        r0 = int.from_bytes(ipt[i:i+4], 'little')
        v  = ROTR32(r0, (i+16) % 32) ^ 0xDEADBEEF
        ipt = ipt[:i] + v.to_bytes(4, 'little') + ipt[i+4:]
    return ipt
 
각 단계가 4바이트를 전단사로 바꾸므로 순서만 뒤집으면 그대로 역산된다.
"""
import marshal, types
 
MASK = 0xFFFFFFFF
 
 
def rotr(x, n):
    n %= 32
    return ((x >> n) | (x << (32 - n))) & MASK if n else x
 
 
def rotl(x, n):
    n %= 32
    return ((x << n) | (x >> (32 - n))) & MASK if n else x
 
 
def chk(ipt: bytes) -> bytes:
    """복원한 진짜 chk (정방향)."""
    for i in range(len(ipt) - 3):
        r0 = int.from_bytes(ipt[i:i + 4], "little")
        v = rotr(r0, (i + 16) % 32) ^ 0xDEADBEEF
        ipt = ipt[:i] + v.to_bytes(4, "little") + ipt[i + 4:]
    return ipt
 
 
def unchk(out: bytes) -> bytes:
    """뒤에서 앞으로 되감는다."""
    for i in reversed(range(len(out) - 3)):
        v = int.from_bytes(out[i:i + 4], "little")
        r0 = rotl(v ^ 0xDEADBEEF, (i + 16) % 32)
        out = out[:i] + r0.to_bytes(4, "little") + out[i + 4:]
    return out
 
 
# 상수 k / m 은 pyc 에서 직접 읽는다 (하드코딩하지 않는다)
with open("extracted/prob.pyc", "rb") as f:
    f.read(16)
    top = marshal.load(f)
 
k = bytes(top.co_consts[2])
m = top.co_consts[4]
orig_chk = next(c for c in top.co_consts
                if isinstance(c, types.CodeType) and c.co_name == "chk")
 
print(f"[*] len(k)={len(k)}  len(m)={len(m)}  len(chk.co_code)={len(orig_chk.co_code)}")
print(f"[*] k  = {k.hex()}")
 
flag = unchk(k)
print(f"[*] flag bytes = {flag.hex()}")
print(f"[+] FLAG = {flag.decode()}")
 
assert chk(flag) == k, "역산 검증 실패"
print("[+] 정방향 재검증 OK: chk(flag) == bytes(k)")

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python solve.py

[*] len(k)=49  len(m)=126  len(chk.co_code)=128
[+] FLAG = GoN{S3lf-m0d1fy1ng-pyc_n0_more_pyc_ch4l13ng3_p1z}
[+] 정방향 재검증 OK: chk(flag) == bytes(k)

#!/usr/bin/env python3
"""배포된 prob.pyc 를 손대지 않고 그대로 실행해 flag 를 확인한다."""
import subprocess, sys
 
FLAG = "GoN{S3lf-m0d1fy1ng-pyc_n0_more_pyc_ch4l13ng3_p1z}"
WRONG = "GoN{this_is_definitely_not_the_right_flag_aaaaaa}"
 
for label, s in (("정답 후보", FLAG), ("오답 대조", WRONG)):
    r = subprocess.run([sys.executable, "extracted/prob.pyc"],
                       input=s + "\n", capture_output=True, text=True)
    out = r.stdout.strip() or "(출력 없음)"
    print(f"{label}: {s}")
    print(f"  → prob.pyc 출력: {out}")

docker run --rm -v "$PWD:/w" -w /w python:3.10-slim python verify.py

pyc/
├── extracted/prob.pyc      ← 배포본
├── dis_pyc.py  dump_code.py  disasm_raw.py  patch_chk.py
├── why_throw.py  decoy.py  bytes_layout.py  check_rot0.py
├── runtime_probe.py  solve.py  verify.py
└── reproduce.sh

#!/usr/bin/env bash
# pyc (DreamHack Platinum 3, id 464) — 한 방 재현.
#   prob.pyc 는 Python 3.10 바이트코드라 로컬 3.12/3.13 으로는 marshal 조차 못 읽는다.
#   그래서 python:3.10-slim 컨테이너 안에서 돌린다 (도커만 있으면 된다).
#   ① solve.py 로 k 를 역산해 flag 를 뽑고  ② 배포된 prob.pyc 를 그대로 실행해 'Good!' 을 확인한다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
IMG=python:3.10-slim
 
docker image inspect "$IMG" >/dev/null 2>&1 || docker pull "$IMG"
 
OUT=$(timeout 300 docker run --rm -v "$PWD:/w" -w /w "$IMG" python solve.py 2>&1) || true
echo "$OUT" | tail -6
 
VOUT=$(timeout 300 docker run --rm -v "$PWD:/w" -w /w "$IMG" python verify.py 2>&1) || true
echo "$VOUT"
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'GoN\{[^}]+\}' | head -1)
GOOD=$(printf '%s' "$VOUT" | grep -c 'Good!' || true)
 
if [ -n "$FLAG" ] && [ "$GOOD" -ge 1 ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '${EXPECT:-미기재}' / Good! 출력 ${GOOD}회)"; exit 1