[🌱 Sprout] GET·POST 요청 체이닝 — 리다이렉트 따라가며 토큰 이어 붙이기 — DreamHack simple-web-request 풀이

문제: DreamHack — simple-web-request 분류: Web 난이도: 🌱 Sprout FLAG: DH{c46b414ddba26adfa4606c59655bda0a18fbe260606b042b52d865e0160eea0e}

이름 그대로 "간단한 웹 요청" 문제다. 화면엔 STEP 1 / STEP 2 / FLAG 링크 세 개만 있고, 정해진 순서대로 정해진 파라미터를 실어 요청을 보내면 플래그가 나온다. HTTP 메서드(GET·POST)와 파라미터를 손으로 다뤄 보는 게 목적인 입문 문제라, 코드도 짧고 우회랄 것도 거의 없다. 다만 단계 사이를 잇는 난수 토큰 하나가 있어서, 그걸 어떻게 이어 붙이는지가 전부다.

문제 개요

풀이 흐름은 단순하다. /step1 에 올바른 GET 파라미터를 주면 /step2 로 리다이렉트되고, /step2 는 HTML 안에 hidden 토큰을 박아 내려준다. 그 토큰을 그대로 /flag 에 POST로 다시 올리면 플래그가 떨어진다. 토큰이 한 흐름 안에서만 유효하다는 점만 주의하면 된다.

🧩 배경 — GET·POST 와 리다이렉트, 그리고 세션

이 문제를 풀려면 HTTP 요청의 기본 세 가지를 구분할 줄 알아야 한다.

GET 과 POST. 둘 다 서버에 요청을 보내는 메서드다. GET은 보통 데이터를 URL 쿼리스트링(?param=값)에 담아 "조회"할 때, POST는 본문(body)에 담아 "제출"할 때 쓴다. Flask에서는 request.args.get() 으로 GET 쿼리를, request.form.get() 으로 POST 폼 데이터를 읽는다. 이 문제는 단계마다 둘 중 하나를 정확히 맞춰 보내야 한다.

302 리다이렉트. 서버가 302 응답에 Location 헤더를 실어 보내면, 브라우저나 HTTP 클라이언트는 그 주소로 다시 요청을 보낸다. Flask의 redirect(url_for(...)) 가 이 응답을 만든다. 이 문제에서 /step1 통과 직후 /step2 로 넘어가는 게 바로 이 리다이렉트다.

세션(쿠키 없이도). 보통 "세션"이라고 하면 쿠키로 상태를 유지하는 걸 떠올리지만, 이 문제 서버는 쿠키를 쓰지 않는다. 대신 단계 토큰을 서버 전역 변수에 저장해 두고, 다음 요청이 그 값과 맞는지 비교한다. 그래서 토큰을 응답에서 읽어 다음 요청에 직접 실어 보내는 식으로 흐름을 이어야 한다.

🔬 코드 정찰 — app.py

제공된 app.py 는 라우트 네 개가 전부다. 하나씩 보면 통과 조건이 그대로 드러난다.

@app.route("/step1", methods=["GET", "POST"])
def step1():
    global step1_num
    step1_num = int.from_bytes(os.urandom(16), sys.byteorder)   # 호출마다 새 난수
 
    if request.method == "GET":
        prm1 = request.args.get("param", "")
        prm2 = request.args.get("param2", "")
        step1_text = "param : " + prm1 + "\nparam2 : " + prm2 + "\n"
        if prm1 == "getget" and prm2 == "rerequest":
            return redirect(url_for("step2", prev_step_num=step1_num))   # ← 통과 시 step2로
        return render_template("step1.html", text=step1_text)
    else:
        return render_template("step1.html", text="Not POST")

/step1 은 GET으로 param=getget, param2=rerequest 를 받으면 /step2?prev_step_num=<step1_num> 으로 리다이렉트한다. 여기서 step1_num 은 함수에 들어올 때마다 새로 생성되는 16바이트 난수다. 이게 뒤에서 함정이 된다.

조건이 안 맞으면 그냥 입력한 두 파라미터를 그대로 화면에 출력한다. 직접 아무 값이나 넣어 보면 그대로 반사되는 걸 볼 수 있다.

@app.route("/step2", methods=["GET", "POST"])
def step2():
    if request.method == "GET":
        if request.args.get("prev_step_num"):
            try:
                prev_step_num = request.args.get("prev_step_num")
                if prev_step_num == str(step1_num):           # ← step1이 발급한 값과 일치?
                    global step2_num
                    step2_num = int.from_bytes(os.urandom(16), sys.byteorder)
                    return render_template("step2.html",
                                           prev_step_num=step1_num, hidden_num=step2_num)
            except:
                return render_template("step2.html", text="Not yet")
        return render_template("step2.html", text="Not yet")
    ...

/step2 는 GET 쿼리 prev_step_num 이 현재 step1_num 과 같을 때만 다음으로 넘겨준다. 통과하면 새 난수 step2_num 을 만들어 step2.html 에 넘기는데, 템플릿을 보면 이 값이 hidden input 으로 박힌다.

<!-- step2.html -->
<form action="/flag" method="post">
  <p>param <input type="text" name="param"/></p>
  <p>param2 <input type="text" name="param2"/></p>
  <input type="hidden" name="check" value="{{ hidden_num }}">   <!-- ← step2_num이 여기 -->
  <input type="submit"/>
</form>

@app.route("/flag", methods=["GET", "POST"])
def flag():
    if request.method == "GET":
        return render_template("flag.html", flag_txt="Not yet")
    else:
        prev_step_num = request.form.get("check", "")
        try:
            if prev_step_num == str(step2_num):               # ← step2가 발급한 값과 일치?
                prm1 = request.form.get("param", "")
                prm2 = request.form.get("param2", "")
                if prm1 == "pooost" and prm2 == "requeeest":
                    return render_template("flag.html", flag_txt=FLAG)   # ← 플래그!
                ...

/flag 는 POST로 check 가 현재 step2_num 과 같고, 동시에 param=pooost, param2=requeeest 일 때 FLAG 를 돌려준다. 정리하면 통과 조건은 이렇다.

🧱 안티치트 — 토큰은 한 흐름 안에서만 산다

코드 주석에 "풀이와 관계없는 치팅 방지 코드"라고 적혀 있는 부분이 바로 step1_num / step2_num 검증이다. 이게 없으면 그냥 /flag 에 정답 파라미터만 POST하면 끝이라, 토큰으로 "앞 단계를 실제로 거쳤는지"를 확인한다.

함정은 step1_num 이 /step1 에 들어올 때마다 새로 생성된다는 점이다. 그래서 /step1 을 다시 부르는 순간 직전에 받은 prev_step_num 은 무효가 된다. /step2 의 토큰도 마찬가지로 그 다음 /step2 호출에서 갈린다. 결국 STEP1 → STEP2 → FLAG 를 중간에 끊지 않고 한 흐름으로 이어야 한다.

🐛 삽질 — 링크를 따로따로 눌러 보기

처음엔 메인의 링크를 순서대로 눌러 봤다. /step2 와 /flag 를 그냥 직접 열면 어떻게 되나 확인하는 차원이었는데, 당연히 둘 다 막힌다.

▶🐛 삽질 — /step2·/flag 직접 접근은 전부 Not yet

/step2 를 prev_step_num 없이 그냥 열면 else 분기로 빠져 "Not yet" 만 나온다. step1_num 검증을 통과한 적이 없으니 hidden 토큰도 안 박힌다.

/flag 를 GET으로 열어도 마찬가지다. /flag 의 GET 핸들러는 무조건 "Not yet" 을 돌려주고, 플래그는 POST + check 토큰이 맞을 때만 나온다. 링크 클릭(=GET)만으로는 절대 도달할 수 없는 구조다.

여기서 "아, 메서드와 토큰을 직접 맞춰 보내야 하는구나"가 분명해진다.

/step1 만 따로 열면 빈 입력 폼이 보인다. 폼은 method="get" 이라, 여기에 값을 넣고 제출해도 결국 GET 쿼리로 나간다.

💣 핵심 — 리다이렉트를 따라가면 토큰이 저절로 이어진다

여기서 핵심 관찰. /step1?param=getget&param2=rerequest 로 들어가면 서버가 step1_num 을 만든 직후 /step2?prev_step_num=<그 값> 으로 리다이렉트한다. 즉 리다이렉트 URL이 방금 발급된 토큰을 그대로 담고 있다. 브라우저든 HTTP 클라이언트든 그 리다이렉트를 따라가면, /step2 검증을 그대로 통과하면서 step2_num 이 박힌 폼을 받게 된다.

실제로 브라우저 주소창에 /step1?param=getget&param2=rerequest 를 치면, 자동으로 /step2?prev_step_num=... 로 넘어가 입력 폼이 뜬다. 주소창의 긴 숫자가 step1_num, 그리고 이 페이지의 hidden input 에 step2_num 이 들어 있다.

이 폼은 action="/flag" method="post" 이고 hidden check 에 step2_num 이 이미 채워져 있다. 그러니 이 화면에서 param, param2 칸에 정답을 넣고 제출하면, 브라우저가 알아서 check + param + param2 를 POST로 /flag 에 올린다. 중간에 /step1 이나 /step2 를 다시 건드리지 않았으니 토큰도 그대로 유효하다.

🎯 익스플로잇 — 브라우저로 한 번

가장 손쉬운 방법은 위 폼을 그대로 쓰는 것이다. 리다이렉트로 도착한 /step2 폼에서 param 에 pooost, param2 에 requeeest 를 넣고 제출하면 된다. 브라우저가 hidden check 까지 함께 POST하므로 추가로 손댈 게 없다.

/flag 화면에 플래그가 그대로 찍혔다.

DH{c46b414ddba26adfa4606c59655bda0a18fbe260606b042b52d865e0160eea0e}

🚀 Full Exploit — requests.Session 으로 자동화

매번 손으로 폼을 채우는 대신, requests.Session 으로 리다이렉트를 자동 추적하고 hidden 토큰을 정규식으로 뽑아 이어 붙이면 한 번에 끝난다. allow_redirects=True (기본값) 덕분에 STEP1의 302를 따라가 STEP2 폼까지 한 호출로 도달하고, 거기서 check 값을 읽어 그대로 POST하면 된다.

#!/usr/bin/env python3
# simple-web-request — GET/POST 요청 체이닝
import re, sys, requests
 
BASE = sys.argv[1] if len(sys.argv) > 1 else "http://host3.dreamhack.games:22341"
BASE = BASE.rstrip("/")
s = requests.Session()
 
# STEP1: 정답 param 두 개 → 302 /step2?prev_step_num=step1_num 까지 자동 추적
r = s.get(f"{BASE}/step1", params={"param": "getget", "param2": "rerequest"},
          allow_redirects=True)
print(f"[STEP1→STEP2] {r.url}")
print(f"             status={r.status_code}")
 
# STEP2 응답 HTML 에서 hidden check 값(step2_num) 추출
m = re.search(r'name="check"\s+value="(\d+)"', r.text)
step2_num = m.group(1)
print(f"[STEP2] hidden check (step2_num) = {step2_num}")
 
# FLAG: POST 로 check + 정답 param 두 개
r = s.post(f"{BASE}/flag",
           data={"check": step2_num, "param": "pooost", "param2": "requeeest"})
print(f"[FLAG] status={r.status_code}")
flag = re.search(r"DH\{.*?\}", r.text)
print(f"[+] FLAG = {flag.group(0)}")

requests.Session 을 쓴 건 쿠키 때문이 아니라(이 서버는 쿠키를 안 쓴다) 같은 커넥션으로 흐름을 깔끔하게 잇기 위해서다. 핵심은 allow_redirects=True 로 STEP1의 리다이렉트를 따라가 STEP2 폼을 받고, 거기 hidden check 값을 그대로 STEP2가 발급한 토큰으로 재사용하는 것. 실행하면 단계별 토큰과 함께 플래그가 떨어진다.

📝 결론

요청을 직접 다뤄 보는 입문 문제.

링크를 클릭하는 것과, 메서드·파라미터·헤더를 손으로 맞춰 요청을 보내는 것의 차이를 익히는 게 이 문제의 전부다. GET은 쿼리스트링, POST는 폼 본문, 302는 따라가는 응답 — 이 셋만 구분하면 흐름이 그대로 보인다.

서버 상태를 토큰으로 잇는 패턴.

단계마다 난수를 발급하고 다음 요청에서 그 값을 확인하는 구조는 실제 서비스의 CSRF 토큰·결제 흐름 토큰·OAuth state 와 같은 발상이다. 다만 여기선 토큰을 전역 변수 하나에 담아 둬서, 동시 접속이나 재요청에 취약하다. step1_num 이 호출마다 덮어써지는 것도 그래서 한 흐름 안에서만 유효한 것이고.

방어 관점에서 보면.

이런 다단계 검증을 제대로 하려면 토큰을 전역 변수가 아니라 사용자별 세션(서명된 쿠키나 서버 세션 저장소)에 묶어야 한다. 전역에 두면 한 사용자의 토큰이 다른 요청에 덮어써지거나 새어 나갈 수 있다. 그리고 hidden input 에 토큰을 내려보내는 것 자체는 흔한 방식이지만, 그 토큰이 "어떤 단계까지 통과했는지"만이 아니라 "누가" 통과했는지까지 묶여 있어야 의미가 있다.