[🥈 Silver 4] 참/거짓 한 비트만 흘려도 AES 블록이 통째로 뜯긴다 — DreamHack Padding Miracle Attack 풀이

printf "1\nsecret\n3\n00112233445566778899aabbccddeeff\n4\n" | nc -q 2 host3.dreamhack.games 20886

P[0] = AES_dec(C[0]) XOR IV
P[i] = AES_dec(C[i]) XOR C[i-1]     (i >= 1)

ls -l extracted && wc -l extracted/chall.py && grep -nE "urandom|input\(|unpad|flag" extracted/chall.py

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import os
 
flag = open("flag.txt", "r").read()
secret, key, iv = [os.urandom(16) for _ in range(3)]
 
while True:
	mode = int(input("[1] Encrypt [2] Decrypt [3] Submit: "))
 
	if mode == 1:
		pt = input("Input plaintext: ")
		if pt == "secret":
			pt = secret
		else:
			pt = bytes.fromhex(pt)
		pt = pad(pt, 16)
		cipher = AES.new(key, AES.MODE_CBC, iv)
		ct = bytes.hex(cipher.encrypt(pt))
		print("pt ==Encryption=>", ct)
		
	elif mode == 2:
		ct = bytes.fromhex(input("Input ciphertext: "))
		try:
			cipher = AES.new(key, AES.MODE_CBC, iv)
			pt = unpad(cipher.decrypt(ct), 16)
			pt = "Don't steal my secret!"
		except:
			pt = "Invalid ciphertext."
		print("ct ==Decryption=>", pt)
 
	elif mode == 3:
		if bytes.fromhex(input("Enter secret: ")) == secret:
			print("You are a human decryptor!!", flag)
			exit()
		else:
			print("Try again.. T.T")
	else:
		exit()

#!/bin/bash
# 로컬 복제 서버: 드림핵 배포 형태(socat + pty)를 흉내 낸다.
cd "$(dirname "$0")"
exec socat -T 120 TCP-LISTEN:17122,reuseaddr,fork EXEC:"python3 chall.py",pty,echo=0,raw

cat local/run_server.sh && (local/run_server.sh >local/server.log 2>&1 &) && sleep 2 && ss -ltn | grep 17122

#!/usr/bin/env python3
"""정찰 — 이 서비스가 무엇을 내주고 무엇을 숨기는지 직접 찔러 본다."""
import argparse
import os
 
from solve import Service, BS
 
ap = argparse.ArgumentParser()
ap.add_argument("--host", default="127.0.0.1")
ap.add_argument("--port", type=int, default=17122)
a = ap.parse_args()
 
svc = Service(a.host, a.port)
print(f"[*] 접속 {a.host}:{a.port}")
 
ct_secret = svc.encrypt("secret")
print(f"[1] Encrypt('secret')     = {ct_secret.hex()}  ({len(ct_secret)}바이트 = 2블록)")
 
z1 = svc.encrypt(bytes(BS))
z2 = svc.encrypt(bytes(BS))
print(f"[2] Encrypt(00*16) 1회차  = {z1.hex()}")
print(f"[3] Encrypt(00*16) 2회차  = {z2.hex()}")
print(f"    -> 두 결과가 같은가: {z1 == z2}  (같으면 key·IV 가 세션 내내 고정)")
 
good = svc.decrypt_batch([ct_secret])[0]
bad_ct = bytearray(ct_secret)
bad_ct[-1] ^= 0x01
bad = svc.decrypt_batch([bytes(bad_ct)])[0]
print(f"[4] Decrypt(정상 암호문)   = 패딩통과 {good}")
print(f"[5] Decrypt(끝 1비트 뒤집음) = 패딩통과 {bad}")
 
trials = 512
rnd = [os.urandom(2 * BS) for _ in range(trials)]
hits = sum(svc.decrypt_batch(rnd))
print(f"[6] 무작위 암호문 {trials}개 중 패딩 통과 = {hits}개  (이론값 ~{trials / 256:.1f}개 = 1/256)")
print(f"[*] 총 질의 {svc.queries}회 — 서버가 흘리는 정보는 오직 이 참/거짓 1비트다")

python3 probe.py

P = AES_dec(C) XOR R

Dec(C)[15] = R[15] XOR 0x01

#!/usr/bin/env python3
"""마지막 바이트 복원과, 0x01 인 척하는 0x02 0x02 함정을 눈으로 본다."""
import argparse
 
from solve import Service, recover_block, BS
 
ap = argparse.ArgumentParser()
ap.add_argument("--host", default="127.0.0.1")
ap.add_argument("--port", type=int, default=17122)
a = ap.parse_args()
 
svc = Service(a.host, a.port)
target = svc.encrypt(bytes(BS))[:BS]          # C_z = E(IV)
print(f"[*] 대상 블록 C_z = {target.hex()}")
 
 
def scan(base: bytearray):
    """R[15] 를 0x00~0xFF 로 돌려 unpad 가 통과하는 값만 모은다."""
    cts = []
    for g in range(256):
        r = bytearray(base)
        r[15] = g
        cts.append(bytes(r) + target)
    return [g for g, ok in enumerate(svc.decrypt_batch(cts)) if ok]
 
 
plain = bytearray(BS)
cand = scan(plain)
print(f"[1] R = 00*16 일 때 통과한 R[15] = {[hex(c) for c in cand]}")
 
dec = recover_block(svc, target, "C_z      ")
print(f"[2] 이 블록의 Dec(C_z) = {dec.hex()}")
print(f"    -> 위 후보 {hex(cand[0])} 는 Dec[15]({hex(dec[15])}) ^ 0x01 = {hex(dec[15] ^ 1)} 과 일치")
 
# 앞 바이트가 하필 0x02 가 되는 상황을 일부러 만들어 함정을 재현한다
trap = bytearray(BS)
trap[14] = dec[14] ^ 0x02
cand2 = scan(trap)
print(f"[3] R[14] 를 손봐 P[14]=0x02 로 만들면 통과한 R[15] = {[hex(c) for c in cand2]}  <- 후보가 둘")
for g in cand2:
    probe = bytearray(trap)
    probe[15] = g
    probe[14] ^= 0xFF
    alive = svc.decrypt_batch([bytes(probe) + target])[0]
    verdict = "진짜 0x01" if alive else "0x02 0x02 였다"
    print(f"    R[15]={hex(g)} -> R[14] 를 0xFF 로 흔든 뒤 통과 {alive}  ({verdict})")
print(f"[*] 총 질의 {svc.queries}회")

python3 demo_lastbyte.py

C_secret = E(secret XOR IV)      Encrypt("secret") 의 1블록
C_zero   = E(0x00*16 XOR IV)     Encrypt(00 * 16) 의 1블록 = E(IV)

Dec(C_secret) = secret XOR IV
Dec(C_zero)   = 0x00*16 XOR IV = IV

secret = Dec(C_secret) XOR Dec(C_zero)

C1 = E(P1 XOR IV)
C2 = E(P2 XOR C1)

#!/usr/bin/env python3
"""CBC 를 접어 '생 AES 암호화' 오라클을 만든다 — 제출 전 검산에 쓰는 도구."""
import argparse
import os
 
from solve import Service, xor, BS
 
ap = argparse.ArgumentParser()
ap.add_argument("--host", default="127.0.0.1")
ap.add_argument("--port", type=int, default=17122)
a = ap.parse_args()
 
svc = Service(a.host, a.port)
c_zero = svc.encrypt(bytes(BS))[:BS]
print(f"[*] C_zero = Enc(00*16) 의 1블록 = E(IV) = {c_zero.hex()}")
 
z = bytes(range(BS))
e1 = svc.ecb_encrypt(z, c_zero)
e2 = svc.ecb_encrypt(z, c_zero)
print(f"[1] E({z.hex()}) = {e1.hex()}")
print(f"[2] 같은 Z 재질의           = {e2.hex()}  동일: {e1 == e2}")
 
# 접은 오라클이 진짜 CBC 와 맞물리는지 — 임의 2블록을 암호화해 2번째 블록을 예측해 본다
p1, p2 = os.urandom(BS), os.urandom(BS)
ct = svc.encrypt(p1 + p2)
pred = svc.ecb_encrypt(xor(p2, ct[:BS]), c_zero)
print(f"[3] Enc(P1||P2) 의 2블록    = {ct[BS:2 * BS].hex()}")
print(f"[4] 접은 오라클 E(P2^C1)     = {pred.hex()}")
print(f"    -> 일치: {pred == ct[BS:2 * BS]}  (CBC 를 ECB 처럼 호출할 수 있다)")
print(f"[*] 총 질의 {svc.queries}회")

python3 demo_ecb.py

E(IV)            == C_zero
E(secret XOR IV) == C_secret

payload = b"".join(b"2\n" + ct.hex().encode() + b"\n" for ct in cts)
self.io.send(payload)
return [b"Don't steal" in ln for ln in self._collect(RE_DEC, len(cts))]

python3 solve.py

#!/usr/bin/env python3
"""Padding Miracle Attack (DreamHack Silver 4, crypto) 풀이.
 
[1] Encrypt 는 고정 IV 로 AES-CBC 암호화를, [2] Decrypt 는 unpad 성공/실패만 알려준다.
목표는 복호가 아니라 secret 16바이트 그 자체이고, IV 가 끝까지 비공개라
패딩 오라클 한 번으로는 secret 이 아니라 secret^IV 까지밖에 못 간다.
 
  C_s = E(secret ^ IV)        -> Dec(C_s) = secret ^ IV
  C_z = E(0x00*16 ^ IV)       -> Dec(C_z) = IV          (평문 0 을 암호화해 받아 둔다)
  secret = Dec(C_s) ^ Dec(C_z)
 
그래서 블록을 두 개 복원한다. 복원 결과는 제출 전에 암호화 오라클로 자체 검산한다
(E(IV) == C_z, E(secret^IV) == C_s).
"""
import argparse
import re
import sys
 
from pwn import remote, context
 
context.log_level = "error"
BS = 16
# 응답은 반드시 줄바꿈까지 받은 뒤에 센다(아래 _collect 주석 참고)
RE_ENC = re.compile(rb"Encryption=> ([0-9a-f]+)[\r\n]")
RE_DEC = re.compile(rb"Decryption=> ([^\r\n]*)[\r\n]")
 
 
def xor(a: bytes, b: bytes) -> bytes:
    return bytes(x ^ y for x, y in zip(a, b))
 
 
class Service:
    """chall.py 와 줄 단위로 대화한다. 질의는 파이프라이닝해서 왕복을 줄인다."""
 
    def __init__(self, host, port):
        self.io = remote(host, port)
        self.buf = b""
        self.queries = 0
 
    def _collect(self, pattern, count: int) -> list:
        """완결된 줄만 센다.
 
        ★ 줄 끝(개행)을 요구하지 않고 'Decryption=>' 개수만 세면,
        TCP 가 응답을 중간에서 쪼갰을 때 잘린 조각을 하나의 답으로 세어
        성공을 실패로 읽는다. 로컬 루프백에서는 한 번에 다 와서 안 드러나고
        원격에서만 터졌다(21바이트째에서 오라클이 전부 거짓이 됐다).
        """
        while True:
            matches = list(pattern.finditer(self.buf))
            if len(matches) >= count:
                self.buf = self.buf[matches[count - 1].end():]
                return [m.group(1) for m in matches[:count]]
            chunk = self.io.recv(timeout=30)
            if not chunk:
                raise RuntimeError(f"응답 끊김: {len(matches)}/{count}")
            self.buf += chunk
 
    def encrypt(self, data) -> bytes:
        """mode 1. data 가 'secret' 이면 서버가 진짜 secret 을 암호화한다."""
        arg = data if isinstance(data, str) else data.hex()
        self.io.send(b"1\n" + arg.encode() + b"\n")
        self.queries += 1
        hexval = self._collect(RE_ENC, 1)[0]
        return bytes.fromhex(hexval.decode())
 
    def decrypt_batch(self, cts) -> list:
        """mode 2 를 여러 건 한꺼번에 밀어 넣고 패딩 성공 여부 리스트를 받는다."""
        payload = b"".join(b"2\n" + ct.hex().encode() + b"\n" for ct in cts)
        self.io.send(payload)
        self.queries += len(cts)
        return [b"Don't steal" in ln for ln in self._collect(RE_DEC, len(cts))]
 
    def submit(self, secret: bytes) -> str:
        self.io.send(b"3\n" + secret.hex().encode() + b"\n")
        self.queries += 1
        out = self.buf
        self.buf = b""
        for _ in range(10):
            try:
                out += self.io.recv(timeout=3)
            except EOFError:
                break
            if b"decryptor" in out or b"Try again" in out:
                break
        return out.decode(errors="replace")
 
    def ecb_encrypt(self, block: bytes, c_zero: bytes) -> bytes:
        """CBC 를 접어 임의 블록의 생 AES 암호화를 얻는다.
        평문 (0x00*16 || block^C_z) 를 넣으면 1블록은 C_z, 2블록이 E(block) 이다."""
        ct = self.encrypt(bytes(16) + xor(block, c_zero))
        return ct[BS:2 * BS]
 
 
def recover_block(svc: Service, target: bytes, label: str, chunk: int = 32) -> bytes:
    """R || target 를 보내 마지막 블록 평문 = Dec(target) ^ R 로 패딩 오라클을 돌린다."""
    dec = bytearray(BS)
    for idx in range(BS - 1, -1, -1):
        pad_val = BS - idx
        base = bytearray(BS)
        for j in range(idx + 1, BS):
            base[j] = dec[j] ^ pad_val
 
        hit = None
        for start in range(0, 256, chunk):
            guesses = list(range(start, min(start + chunk, 256)))
            cts = []
            for g in guesses:
                r = bytearray(base)
                r[idx] = g
                cts.append(bytes(r) + target)
            for g, ok in zip(guesses, svc.decrypt_batch(cts)):
                if not ok:
                    continue
                if idx == BS - 1:
                    # 0x01 인 척하는 0x02 0x02 를 걸러낸다: 앞 바이트를 흔들어도 살아남아야 진짜다
                    probe = bytearray(base)
                    probe[idx] = g
                    probe[idx - 1] ^= 0xFF
                    if not svc.decrypt_batch([bytes(probe) + target])[0]:
                        continue
                hit = g
                break
            if hit is not None:
                break
        if hit is None:
            raise RuntimeError(f"{label}: {idx}번째 바이트에서 유효 패딩을 못 찾음")
        dec[idx] = hit ^ pad_val
        sys.stderr.write(f"\r[{label}] {BS - idx:2d}/16  Dec={dec.hex()}  q={svc.queries}")
        sys.stderr.flush()
    sys.stderr.write("\n")
    return bytes(dec)
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--host", default="127.0.0.1")
    ap.add_argument("--port", type=int, default=17122)
    args = ap.parse_args()
 
    svc = Service(args.host, args.port)
 
    c_secret = svc.encrypt("secret")[:BS]            # E(secret ^ IV)
    c_zero = svc.encrypt(bytes(BS))[:BS]             # E(0x00*16 ^ IV) = E(IV)
    print(f"[+] C_secret = {c_secret.hex()}")
    print(f"[+] C_zero   = {c_zero.hex()}")
 
    d_secret = recover_block(svc, c_secret, "secret^IV")
    iv = recover_block(svc, c_zero, "IV       ")
    secret = xor(d_secret, iv)
    print(f"[+] IV       = {iv.hex()}")
    print(f"[+] secret   = {secret.hex()}")
 
    # 제출 전 검산 — 암호화 오라클로 두 관계식이 모두 맞는지 확인한다
    ok_iv = svc.ecb_encrypt(iv, c_zero) == c_zero
    ok_sec = svc.ecb_encrypt(xor(secret, iv), c_zero) == c_secret
    print(f"[+] 검산 E(IV)==C_zero: {ok_iv} / E(secret^IV)==C_secret: {ok_sec}")
    if not (ok_iv and ok_sec):
        print("[-] 검산 실패. 제출하지 않는다.")
        return 1
 
    print(f"[+] 총 질의 {svc.queries}회")
    print(svc.submit(secret).strip())
    return 0
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 solve.py --host host3.dreamhack.games --port 20886

DH{Can_you_do_it_even_faster??}

#!/usr/bin/env bash
# Padding Miracle Attack (DreamHack, Silver 4 crypto) — 한 방 재현.
#
#   ./reproduce.sh                 로컬 복제 서버를 띄워 공격 기법만 검증한다(더미 flag).
#   ./reproduce.sh <host> <port>   드림핵 라이브 VM 에 붙어 진짜 flag 를 딴다.
#
# 라이브 VM 은 시간이 지나면 만료되므로 인자를 안 주면 기본값은 "로컬 검증"이다.
# 로컬 모드가 통과해도 진짜 flag 가 아니므로 그렇게 표기한다.
set -eu
ROOT="$(dirname "$(readlink -f "$0")")"
cd "$ROOT"
 
REAL=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null \
       || echo 'DH{Can_you_do_it_even_faster??}')
 
if [ $# -ge 2 ]; then
  MODE=live; HOST=$1; PORT=$2; EXPECT=$REAL
else
  MODE=local; HOST=127.0.0.1; PORT=17122
  EXPECT='DH{dummy_local_flag_for_verification_only}'
  mkdir -p local
  cp -f extracted/chall.py local/chall.py
  printf '%s\n' "$EXPECT" > local/flag.txt
  # socat 의 pty 릴레이는 자식 출력을 제 stdout 으로도 흘린다 — 로그로 보낸다
  ( cd local && exec socat -T 120 "TCP-LISTEN:$PORT,reuseaddr,fork" \
      EXEC:"python3 chall.py",pty,echo=0,raw ) >local/socat.log 2>&1 &
  SOCAT=$!
  trap 'kill "$SOCAT" 2>/dev/null || true' EXIT
  sleep 1
fi
 
OUT=$(timeout 600 python3 solve.py --host "$HOST" --port "$PORT" 2>&1) || true
echo "$OUT" | tail -8
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
 
if [ "${FLAG:-}" = "$EXPECT" ]; then
  if [ "$MODE" = live ]; then
    echo; echo "✅ PASS  $FLAG"
  else
    echo; echo "✅ 기법 검증 PASS (로컬 복제본·더미 flag — 진짜 flag 아님)"
    echo "   진짜 flag 는: ./reproduce.sh <드림핵 host> <port>"
  fi
  exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

./reproduce.sh host3.dreamhack.games 20886