[🥈 Silver 1] 상쇄되는 연산 14개와 미끼 키 2개 — DreamHack Ransom 풀이

unzip -l extracted/public.Zip; file extracted/ransom.exe; xxd extracted/flag.txt

upx -d -o ransom_unpacked.exe ransom_packed.exe; file ransom_unpacked.exe

strings -a -n 5 ransom_unpacked.exe | sed -n "10,28p"

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x4019a0 --stop-address=0x4019b6 ransom_unpacked.exe | tail -n +8 | sed -f annot.sed

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x4017a4 --stop-address=0x4017d7 ransom_unpacked.exe | tail -n +8 | sed -f annot.sed

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x401804 --stop-address=0x4018c8 ransom_unpacked.exe | tail -n +8 \
  | grep -E "add|xor|div|cmp" | sed -f annot.sed

for i in range(n):
    buf[i] ^= key1[i % 16]
for i in range(n):
    buf[i] += 1 if i % 2 == 0 else 2
    buf[0] ^= buf[3]
    buf[2] ^= buf[7]

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x4011e3 --stop-address=0x401288 ransom_unpacked.exe | tail -n +8 | sed -f annot.sed

objdump -d --no-show-raw-insn -M intel \
  --start-address=0x401362 --stop-address=0x401573 ransom_unpacked.exe | tail -n +8 \
  | grep -E "(add|sub|xor)    e[a-d]x,0x|xor    ecx,edx" | sed -f annot.sed

#!/usr/bin/env python3
"""Ransom (DreamHack, Silver 1 / reversing) — flag.txt 복호
 
UPX 를 벗기면 진짜 main 은 0x4019a0 이고, 파일을 두 번 건드린다.
 
    main:  call 0x401080   # 프로세스 이름으로 분석도구 탐지 (파일과 무관)
           call 0x401610   # 1단계
           call 0x4011d0   # 2단계 (IsDebuggerPresent 먼저)
 
1단계 (0x401610) — key1 은 .rdata 0x4031e0 의 "abc!@#qwe012fgh456"
 
    for i in range(n): buf[i] ^= key1[i % 16]      # ★ %16 이라 뒤 두 글자 '5','6' 은 안 쓰인다
    for i in range(n):
        buf[i] += 1 if i % 2 == 0 else 2
        buf[0] ^= buf[3]                           # 고정 인덱스, 매 회차 실행
        buf[2] ^= buf[7]
 
2단계 (0x4011d0) — key2 는 스택에 한 바이트씩 박아 넣은 19바이트
 
    for i in range(n):
        buf[i] ^= key2[i]                          # 나머지 연산 없이 인덱스 그대로
        <고정 인덱스 연산 15개>                      # 아래 OPS
 
OPS 는 15개인데 14개가 서로 역연산 짝이라 상쇄되고, 실질은 buf[5] += 0x11 하나뿐이다.
그래도 짝이 맞는지 눈으로 세는 것보다 그대로 시뮬레이션하는 쪽이 안전해서 전부 적어 뒀다.
 
.rdata 의 "1@!@#a134234" / "zBNdlwi102394" 는 0x401610 스택에 복사만 되고 읽히지 않는다(미끼).
key2 는 19바이트만 초기화되는데 파일은 20바이트라, 마지막 한 바이트는 초기화 안 된 스택을
읽는다. 실행 환경에서 0 이었다는 가정이 맞는지는 --scan 으로 확인한다.
 
    python3 solve.py                 # extracted/flag.txt 복호
    python3 solve.py --selftest      # 복호본을 다시 암호화해 원본과 대조
    python3 solve.py --scan          # key2 의 미초기화 마지막 바이트를 0~255 전수
"""
import argparse
import pathlib
import string
import sys
 
KEY1 = b"abc!@#qwe012fgh456"
KEY2 = bytes([0x50, 0x70, 0x20, 0x62, 0x74, 0x58, 0x48, 0x45, 0x90, 0x90,
              0x70, 0x40, 0x36, 0x45, 0x55, 0x71, 0x18, 0x19, 0x70])
 
# 2단계 루프 몸통의 고정 인덱스 연산 (0x401371 ~ 0x40156c 순서 그대로)
OPS = [(0, '-', 0x15), (3, '^', 0x18), (8, '-', 0x33), (11, '^', 0x44),
       (9, '+', 0x47), (4, '^', 0x88), (7, '^', 0x68), (0, '+', 0x15),
       (11, '^', 0x44), (9, '-', 0x47), (8, '+', 0x33), (5, '+', 0x11),
       (3, '^', 0x18), (4, '^', 0x88), (7, '^', 0x68)]
 
HERE = pathlib.Path(__file__).resolve().parent
 
 
def _apply(b, idx, op, v, inverse=False):
    if op == '^':
        b[idx] ^= v                       # XOR 은 자기 자신이 역연산
    elif (op == '+') != inverse:
        b[idx] = (b[idx] + v) & 0xFF
    else:
        b[idx] = (b[idx] - v) & 0xFF
 
 
def stage1(b):
    n = len(b)
    for i in range(n):
        b[i] ^= KEY1[i % 16]
    for i in range(n):
        b[i] = (b[i] + (1 if i % 2 == 0 else 2)) & 0xFF
        b[0] ^= b[3]
        b[2] ^= b[7]
 
 
def stage1_inv(b):
    n = len(b)
    for i in reversed(range(n)):
        b[2] ^= b[7]
        b[0] ^= b[3]
        b[i] = (b[i] - (1 if i % 2 == 0 else 2)) & 0xFF
    for i in range(n):
        b[i] ^= KEY1[i % 16]
 
 
def stage2(b, tail=0x00):
    key = KEY2 + bytes([tail]) * (len(b) - len(KEY2))
    for i in range(len(b)):
        b[i] ^= key[i]
        for idx, op, v in OPS:
            _apply(b, idx, op, v)
 
 
def stage2_inv(b, tail=0x00):
    key = KEY2 + bytes([tail]) * (len(b) - len(KEY2))
    for i in reversed(range(len(b))):
        for idx, op, v in reversed(OPS):
            _apply(b, idx, op, v, inverse=True)
        b[i] ^= key[i]
 
 
def encrypt(data: bytes, tail=0x00) -> bytes:
    b = bytearray(data)
    stage1(b)
    stage2(b, tail)
    return bytes(b)
 
 
def decrypt(data: bytes, tail=0x00) -> bytes:
    b = bytearray(data)
    stage2_inv(b, tail)
    stage1_inv(b)
    return bytes(b)
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("path", nargs="?", default=str(HERE / "extracted" / "flag.txt"))
    ap.add_argument("--selftest", action="store_true")
    ap.add_argument("--scan", action="store_true",
                    help="key2 의 미초기화 마지막 바이트를 0~255 전수해 후보를 본다")
    a = ap.parse_args()
 
    ct = pathlib.Path(a.path).read_bytes()
    print(f"[*] 암호문 {len(ct)}바이트: {ct.hex()}")
 
    if a.scan:
        ok = set(string.printable[:-5].encode())
        hits = [(t, decrypt(ct, t)) for t in range(256)]
        hits = [(t, p) for t, p in hits if all(c in ok for c in p)]
        for t, pt in hits[:4]:
            print(f"    tail=0x{t:02x} → {pt.decode()}")
        closed = [t for t, p in hits if p.endswith(b"}")]
        print(f"    ... 인쇄가능 후보 {len(hits)}개")
        print(f"    그중 '}}' 로 끝나는 것: {['0x%02x' % t for t in closed]}")
        return
 
    pt = decrypt(ct)
    print(f"[+] 복호 결과: {pt!r}")
    try:
        print(f"[+] FLAG: {pt.decode()}")
    except UnicodeDecodeError:
        print("[-] ASCII 로 안 떨어진다 — --scan 으로 마지막 키 바이트를 훑어 볼 것")
        sys.exit(1)
 
    if a.selftest:
        again = encrypt(pt)
        ok = again == ct
        print(f"[{'+' if ok else '-'}] 재암호화 대조: {again.hex()} {'일치' if ok else '불일치'}")
        sys.exit(0 if ok else 1)
 
 
if __name__ == "__main__":
    main()

[+] FLAG: DH{Do_y0u_Know_Oni?}
[+] 재암호화 대조: 745c3705448a410c81e10b1e3c576d0c08142d5e 일치

#!/usr/bin/env bash
# 복호 결과가 맞는지 바이너리로 직접 확인한다.
# 평문(복호 결과)을 flag.txt 에 넣고 ransom.exe 를 실제로 돌려서,
# 배포본 flag.txt 와 바이트가 같아지는지 본다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
PLAIN=${1:-'DH{Do_y0u_Know_Oni?}'}
WORK=wine_run
rm -rf "$WORK"; mkdir -p "$WORK"
cp extracted/ransom.exe "$WORK/"
printf '%s' "$PLAIN" > "$WORK/flag.txt"
 
echo "[*] 실행 전 flag.txt (복호로 얻은 평문)"
xxd "$WORK/flag.txt"
 
export WINEPREFIX="$HOME/.wine" WINEDEBUG=-all
( cd "$WORK" && wine ransom.exe ) 2>&1 | grep -vE '^wine:|XDG_RUNTIME_DIR' || true
 
echo
echo "[*] 실행 후 flag.txt (ransom.exe 가 다시 암호화한 결과)"
xxd "$WORK/flag.txt"
echo "[*] 배포본 flag.txt"
xxd extracted/flag.txt
 
python3 - "$WORK/flag.txt" extracted/flag.txt <<'PY'
import sys, pathlib
got = pathlib.Path(sys.argv[1]).read_bytes()
want = pathlib.Path(sys.argv[2]).read_bytes()
head_ok = got[:19] == want[:19]
print()
print(f"앞 19바이트 : {'일치' if head_ok else '불일치'}")
print(f"20번째      : 이번 실행 0x{got[19]:02x} / 배포본 0x{want[19]:02x}"
      f"  → 미초기화 키 바이트 차이 0x{got[19] ^ want[19]:02x}")
if not head_ok:
    sys.exit(1)
print()
print("✅ 이 평문이 배포본 암호문을 만든다 (마지막 1바이트는 환경 의존이라 제외)")
PY

#!/usr/bin/env bash
# Ransom (DreamHack, Silver 1) — 한 방 재현
#   ./reproduce.sh            복호 → flag 대조 (인자 없이 그냥 돌리면 된다)
#   ./reproduce.sh --wine     추가로 ransom.exe 를 wine 으로 실제 실행해 암호문 재현까지
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT='DH{Do_y0u_Know_Oni?}'
 
# 배포본이 zip 안에 있으면 먼저 푼다
[ -f extracted/flag.txt ] || ( cd extracted && unzip -o -q public.Zip )
 
OUT=$(timeout 120 python3 solve.py --selftest 2>&1) || true
echo "$OUT" | tail -6
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
if [ "$FLAG" != "$EXPECT" ]; then
    echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1
fi
if ! printf '%s' "$OUT" | grep -q '재암호화 대조.*일치'; then
    echo; echo "❌ FAIL — 복호는 됐는데 재암호화가 원본과 안 맞는다"; exit 1
fi
 
if [ "${1:-}" = "--wine" ]; then
    echo; echo "=== wine 실행 검증 ==="
    ./run_wine.sh "$EXPECT" | tail -6
fi
 
echo; echo "✅ PASS  $FLAG"