[🥉 Bronze 4] 복사 금지는 브라우저에게만 하는 부탁이다 — DreamHack Ctrl-C 풀이

FROM python:3.13@sha256:385ccb8304f6330738a6d9e6fa0bd7608e006da7e15bc52b33b0398e1ba4a15b
 
ENV user ctrlc
 
RUN apt update
RUN pip install flask
 
RUN useradd -d /home/$user $user
 
ADD app.py /home/$user/app.py
ADD text.txt /home/$user/text.txt
ADD templates/index.html /home/$user/templates/index.html

import hashlib
import base64
 
def bytes_to_long(a):
    return int.from_bytes(a, byteorder='big')
def long_to_bytes(a):
    return a.to_bytes((a.bit_length()+7)//8, byteorder='big')
 
print(long_to_bytes(548488142063681088110499188198346596132432266189304030893626^bytes_to_long(base64.b64encode(hashlib.sha256(input().rstrip().encode('utf-8')).digest())[13:36])))

curl -s -D - -o /dev/null http://host3.dreamhack.games:21647/

#!/usr/bin/env bash
# Ctrl-C — 서버가 노출하는 경로가 정말 '/' 하나뿐인지 확인한다.
# Dockerfile 이 넣는 세 파일(app.py / text.txt / templates/index.html)이
# 혹시 정적으로 서빙되지 않는지부터 본다. 되면 굳이 파싱할 것도 없다.
U=${1:-http://host3.dreamhack.games:21647}
for p in /text.txt /app.py /static/text.txt /templates/index.html /flag /Ctrl_C.py /robots.txt; do
  printf "%-24s " "$p"
  curl -s -o /dev/null -w "%{http_code}  %{size_download}B\n" --max-time 12 "$U$p"
done
printf "%-24s " "/ (OPTIONS)"; curl -s -o /dev/null -w "%{http_code}\n" -X OPTIONS --max-time 12 "$U/"
printf "%-24s " "/ (POST)";    curl -s -o /dev/null -w "%{http_code}\n" -X POST    --max-time 12 "$U/"
printf "%-24s " "/ (GET)";     curl -s -o /dev/null -w "%{http_code}  %{size_download}B\n" --max-time 12 "$U/"

./probe_endpoints.sh

curl -s http://host3.dreamhack.games:21647/ | sed -n "20,58p"

// 오른쪽 클릭 방지
document.oncontextmenu = function() {
    return false;
}
 
// 드래그 방지
var omitformtags = ["input", "textarea", "select"];
omitformtags = omitformtags.join("|");
 
function disableselect(e) {
    if (omitformtags.indexOf(e.target.tagName.toLowerCase()) == -1)
        return false;
}
 
if (typeof document.onselectstart != "undefined")
    document.onselectstart = new Function("return false");
else {
    document.onmousedown = disableselect;
    document.onmouseup = reEnable;
}
 
// F12 키 비활성화
document.addEventListener("keydown", function(e) {
    if (e.keyCode == 123) { // F12 키의 keyCode는 123
        e.preventDefault();
    }
});

# cap_browser.py — 실제 마우스 이벤트로 방어를 눌러 본다 (발췌)
def xdo(env, *args):
    subprocess.run(["xdotool", *args], env=env, check=False,
                   stderr=subprocess.DEVNULL, timeout=10)
 
# 뷰포트 좌상단의 화면(스크린) 좌표. 창 테두리·탭바·주소창 두께를 직접
# 재지 않고 브라우저에게 물어본다 -> 좌표가 창 크기에 안 흔들린다.
ox = page.evaluate("window.screenX + (window.outerWidth - window.innerWidth) / 2")
oy = page.evaluate("window.screenY + (window.outerHeight - window.innerHeight)")
box = page.evaluate(
    "(() => { const r = document.querySelector('.content p')"
    ".getBoundingClientRect();"
    " return {x: r.x, y: r.y, w: r.width, h: r.height}; })()")
 
x1 = int(ox + box["x"] + 8)
y1 = int(oy + box["y"] + 10)
x2 = int(ox + box["x"] + box["w"] - 8)
y2 = int(oy + box["y"] + 58)
 
# 실제 우클릭
xdo(env, "mousemove", "--sync", str(x1 + 120), str(y1 + 20))
xdo(env, "click", "3")

# 마우스를 누른 채로 네 번에 걸쳐 이동시킨 뒤 뗀다 — 사람 드래그와 같은 경로
xdo(env, "mousemove", "--sync", str(x1), str(y1))
xdo(env, "mousedown", "1")
for f in (0.25, 0.5, 0.75, 1.0):
    xdo(env, "mousemove", "--sync",
        str(int(x1 + (x2 - x1) * f)), str(int(y1 + (y2 - y1) * f)))
    time.sleep(0.12)
xdo(env, "mouseup", "1")
sel = page.evaluate("window.getSelection().toString().length")
print(f"[*] 방어 켜진 상태 선택 길이 = {sel}")

page.evaluate("document.onselectstart = null;"
              "document.onmousedown = null;"
              "document.oncontextmenu = null;")
# ... 위와 똑같은 mousedown -> mousemove x4 -> mouseup ...
sel2 = page.evaluate("window.getSelection().toString().length")
print(f"[*] 핸들러 제거 후 선택 길이 = {sel2}")

t=document.querySelector('.content p').innerText; [t.length, t.slice(0,32), t.slice(-16)]

#!/usr/bin/env python3
"""[13:36] 이 정확히 무엇을 잘라 오는지 확인한다.
 
base64 는 6비트씩 한 글자로 만든다. 그러니 슬라이스는 '다이제스트의 어느 비트 구간'
이라고 말할 수 있다. 그 구간이 얼마나 되는지가 곧 '되돌릴 수 있느냐'의 답이다.
"""
import base64
import hashlib
import pathlib
 
TEXT = pathlib.Path("text.txt").read_text()
d = hashlib.sha256(TEXT.rstrip().encode()).digest()
b64 = base64.b64encode(d).decode()
 
print(f"sha256 다이제스트   : {len(d)}바이트 = {len(d) * 8}비트")
print(f"base64 전체         : {b64}")
print(f"                      ({len(b64)}글자, 끝에 패딩 '{b64[-1]}')")
print(f"[13:36] 슬라이스    : {' ' * 13}{b64[13:36]}")
print(f"                      ({len(b64[13:36])}글자 = 23바이트)")
 
lo, hi = 13 * 6, 36 * 6                     # base64 글자 i = 다이제스트 비트 [6i, 6i+6)
print()
print(f"덮는 비트 구간      : {lo} ~ {hi - 1}  ({hi - lo}비트)")
print(f"전체 대비           : {(hi - lo) / (len(d) * 8):.1%}")
print(f"해당 바이트         : {lo // 8} ~ {(hi - 1) // 8}  (총 {(hi - 1) // 8 - lo // 8 + 1}바이트)")
print(f"패딩 '=' 포함?      : {'예' if 36 > len(b64) - 1 else '아니오 (43번째 패딩은 안 걸린다)'}")
print()
print(f"-> 다이제스트의 {(hi - lo)}비트만 본다. 나머지 {len(d) * 8 - (hi - lo)}비트는 버려진다.")
print("   그래도 원문을 되돌릴 수는 없다. sha256 자체가 단방향이라 몇 비트를 보든 마찬가지다.")

python3 slice_math.py

548488142063681088110499188198346596132432266189304030893626
  -> bit_length = 199
  -> (199 + 7) // 8 = 25 바이트
  -> 5761136603080d246d3a012761434911032a381c362505163a

with urllib.request.urlopen(url, timeout=30) as r:
    html = r.read().decode("utf-8")
m = re.search(r"<p>(.*?)</p>", html, re.S)
text = m.group(1)

import subprocess, pathlib
t = pathlib.Path('text.txt').read_text()
r = subprocess.run(['python3','extracted/Ctrl_C.py'], input=t+'\n', capture_output=True, text=True)
print('stdout:', r.stdout.strip())

stdout: b'WaRP{1_w4n7_5h0r7cu7_k3y}'

#!/usr/bin/env python3
"""Ctrl-C (DreamHack, Bronze 4 / web) — 자체 완결 solve.
 
동작:
  1) 문제 서버의 메인 페이지를 받는다. 복사방지(우클릭·드래그·F12 차단)는
     전부 브라우저에서만 도는 JS라 HTTP 응답 자체에는 아무 영향이 없다.
  2) <p> 안의 2000자를 그대로 꺼낸다.
  3) 배포된 Ctrl_C.py 와 동일한 연산을 수행한다.
       long_to_bytes( CONST ^ bytes_to_long( b64(sha256(text))[13:36] ) )
     CONST 는 25바이트, b64 슬라이스는 23바이트라 상위 2바이트는 XOR 를 안 탄다
     -> 출력은 입력과 무관하게 항상 b'Wa' 로 시작하고, 그 뒤 23바이트가 플래그 본문.
 
사용:
  python3 solve.py http://hostN.dreamhack.games:PORT/
  python3 solve.py --text-file text.txt      # 이미 받아둔 본문으로 오프라인 재현
 
인자를 생략하면 기본 URL 로 붙지만, 드림핵 인스턴스는 시간제한이 있어
만료된 뒤에는 실패한다. 그때는 --text-file 로 저장본을 쓰거나 새 URL 을 넘길 것.
"""
import argparse
import base64
import hashlib
import re
import sys
import urllib.request
 
DEFAULT_URL = "http://host3.dreamhack.games:21647/"
CONST = 548488142063681088110499188198346596132432266189304030893626
 
 
def bytes_to_long(a):
    return int.from_bytes(a, byteorder="big")
 
 
def long_to_bytes(a):
    return a.to_bytes((a.bit_length() + 7) // 8, byteorder="big")
 
 
def fetch_text(url):
    """메인 페이지에서 <p> 안 본문을 꺼낸다. JS 복사방지는 여기 관여하지 못한다."""
    with urllib.request.urlopen(url, timeout=30) as r:
        html = r.read().decode("utf-8")
    m = re.search(r"<p>(.*?)</p>", html, re.S)
    if not m:
        raise SystemExit("[-] <p> 본문을 찾지 못했다. 서버가 만료됐는지 확인할 것.")
    return m.group(1)
 
 
def solve(text):
    """배포된 Ctrl_C.py 와 같은 연산. input().rstrip() 을 그대로 재현한다."""
    digest = hashlib.sha256(text.rstrip().encode("utf-8")).digest()
    sliced = base64.b64encode(digest)[13:36]
    return long_to_bytes(CONST ^ bytes_to_long(sliced)), sliced
 
 
def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("url", nargs="?", default=DEFAULT_URL)
    ap.add_argument("--text-file", help="저장해 둔 본문으로 오프라인 재현")
    a = ap.parse_args()
 
    if a.text_file:
        text = open(a.text_file, encoding="utf-8").read()
        print(f"[*] 본문 출처: {a.text_file}")
    else:
        text = fetch_text(a.url)
        print(f"[*] 본문 출처: {a.url}")
 
    print(f"[*] 본문 길이: {len(text)}자")
    print(f"[*] 본문 앞 48자: {text[:48]}")
 
    flag, sliced = solve(text)
    print(f"[*] sha256 b64 슬라이스[13:36]: {sliced.decode()}")
    print(f"[*] 고정 접두(XOR 미적용 2바이트): {flag[:2].decode()}")
    print(f"[+] FLAG: {flag.decode()}")
    return 0
 
 
if __name__ == "__main__":
    sys.exit(main())

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

#!/usr/bin/env bash
# Ctrl-C (DreamHack Bronze 4 / web) — 한 방 재현. 본문 확보 → 연산 → flag 대조.
#
#   ./reproduce.sh                                   # 저장된 text.txt 로 오프라인 재현 (항상 동작)
#   ./reproduce.sh http://hostN.dreamhack.games:PORT/  # 라이브 서버에서 본문을 새로 받아 재현
#
# ★ 인자 없이 돌리면 오프라인 모드다. 라이브로 확인하려면 URL 을 반드시 넘길 것 —
#   드림핵 인스턴스는 시간제한이 있어 예전 URL 은 이미 만료됐다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
if [ $# -ge 1 ]; then
  OUT=$(timeout 120 python3 solve.py "$1" 2>&1) || true
else
  OUT=$(timeout 120 python3 solve.py --text-file text.txt 2>&1) || true
fi
 
echo "$OUT" | tail -8
FLAG=$(printf '%s' "$OUT" | grep -aoE 'WaRP\{[^}]+\}' | head -1)
if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

./reproduce.sh

#!/usr/bin/env python3
"""Ctrl-C 로컬 복제본.
 
app.py 는 배포되지 않았다. 그래서 Dockerfile 이 넣는 파일 구성
(app.py / text.txt / templates/index.html)과 실제 응답 모양에 맞춰 최소한으로 다시 썼다.
text.txt 는 라이브에서 받아 둔 본문 그대로라, 이 서버로 풀어도 같은 플래그가 나온다.
"""
from flask import Flask, render_template
 
app = Flask(__name__)
 
 
@app.route("/")
def index():
    with open("text.txt", encoding="utf-8") as f:
        text = f.read()
    return render_template("index.html", text=text)
 
 
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

    <div class="content">
        <h1>이 문자들을 제공된 코드에 넣어 flag를 획득하세요!!!</h1>
        <p>{{ text }}</p>
    </div>

#!/usr/bin/env bash
# 로컬 복제본을 5000번 포트로 띄우고, solve.py 를 그 서버에 붙여 flag 까지 확인한 뒤 내린다.
#   pip install flask   (한 번만)
set -eu
cd "$(dirname "$(readlink -f "$0")")"
python3 app.py > /tmp/ctrlc_local.log 2>&1 &
PID=$!
trap 'kill $PID 2>/dev/null || true' EXIT
for _ in $(seq 1 40); do
  curl -s -o /dev/null http://127.0.0.1:5000/ && break || sleep 0.25
done
python3 ../solve.py http://127.0.0.1:5000/

./local/run_local.sh