비밀번호는 입력하는 순간 상대에게 넘어갈 수 있고, 한 번 넘어가면 같은 비밀번호를 쓰는 다른 서비스까지 열립니다. 패스키(WebAuthn)는 서버에 공개키만 두고, 서명이 만들어질 때 브라우저가 접속 주소(origin)를 서명 데이터에 함께 넣게 해서 이 문제를 줄입니다. 이 글에서는 작은 Flask 앱에 py_webauthn으로 패스키 등록과 로그인을 붙이고, 크롬의 가상 인증기로 실제 지문이나 보안 키 없이 전 과정을 확인합니다.
먼저 비밀번호 로그인이 피싱 중계 서버를 거쳐도 그대로 통과하는 것을 보고, 같은 중계에서 패스키 로그인이 거부되는 것을 확인합니다. 그다음 챌린지가 한 번만 쓰이는지, origin과 rpId를 어떻게 검증하는지, 서명 카운터가 어떻게 오르는지 봅니다. 마지막에는 패스키를 쓰더라도 남는 문제(복구 경로, 동기화 패스키, 기기 분실)를 정리합니다. 중계 서버는 연습용 앱 두 개를 내 컴퓨터에서만 서로 연결하는 것이고, 외부 서비스에는 아무것도 보내지 않습니다.
준비물
| 항목 | 버전 | 용도 |
|---|---|---|
| Python | 3.12.10 | Flask 앱, 확인 스크립트 |
| Flask | 3.1.3 | 연습용 웹 앱 |
| webauthn(py_webauthn) | 3.0.1 | 옵션 생성과 응답 검증 |
| Playwright | 1.62.0 | 크롬 실행, CDP 호출 |
| Chrome | 156.0.8078.48 | 가상 인증기(WebAuthn 도메인) |
명령은 Windows에서 확인했고, 리눅스와 macOS에서는 실행하지 않았습니다. 예상 소요 시간은 30분 안팎입니다. Playwright는 설치된 크롬을 executable_path로 지정해 쓰므로 브라우저를 따로 내려받지 않습니다. 크롬 경로가 다르면 환경 변수 CHROME_PATH로 지정합니다. 이 글의 코드는 모두 본문에 전체를 실었고, 글 맨 위의 실습 코드 내려받기에서도 같은 파일을 받을 수 있습니다.
flask==3.1.3
webauthn==3.0.1
python -m pip install -r requirements.txt playwright
1. 가상 인증기란
패스키를 만들고 쓰려면 보통 지문, 얼굴, 보안 키 같은 인증기가 필요합니다. 크롬 개발자 도구에는 WebAuthn 패널이 있어서 소프트웨어로 만든 가상 인증기를 켤 수 있고, 같은 기능을 CDP(Chrome DevTools Protocol)의 WebAuthn.enable과 WebAuthn.addVirtualAuthenticator로 호출할 수 있습니다. 이 글에서는 스크립트로 재현하려고 CDP를 호출했고, 개발자 도구 패널은 열지 않았습니다. 가상 인증기를 켜면 navigator.credentials.create와 get이 팝업 없이 곧바로 응답합니다.
drive.py가 쓰는 옵션은 아래와 같습니다. 플랫폼 인증기(internal)에 사용자 확인이 통과된 상태(isUserVerified)로 만들고, 사용자 존재 확인(터치)은 자동으로 시뮬레이션합니다.
cdp.send("WebAuthn.addVirtualAuthenticator", {"options": {
"protocol": "ctap2", "transport": "internal",
"hasResidentKey": True, "hasUserVerification": True,
"isUserVerified": True, "automaticPresenceSimulation": True,
}})
가상 인증기는 서버 코드를 확인하는 도구입니다. 실제 기기의 생체 인식, 패스키 동기화, 운영체제 팝업 동작은 재현하지 못합니다.
2. 발견: 비밀번호는 넘어가고, 같은 비밀번호로 다른 곳도 열립니다
연습 앱의 비밀번호 로그인은 일반적인 구현입니다. 사용자 이름과 비밀번호가 맞으면 세션을 만듭니다. 사용자가 다른 서비스에서도 같은 비밀번호를 쓴다고 가정하고, 공격자가 진짜 앱 앞에 중계 서버를 세워 화면을 똑같이 보여 주는 상황을 만듭니다. phish.py는 5051 포트에서 같은 화면을 보여 주고 받은 요청을 진짜 앱(5050)에 그대로 전달합니다. 사용자가 중계 화면에 비밀번호를 입력하면 공격자 서버가 진짜 앱에서 세션 쿠키를 받아 가집니다.
아래는 앱 전체입니다. 이 단계에서는 비밀번호 로그인(/pw-login)만 보면 됩니다. 패스키 부분은 4단계부터 설명합니다.
"""패스키(WebAuthn) 등록과 로그인을 붙인 Flask 연습 앱. 저장소는 메모리라 재시작하면 사라집니다."""
from flask import Flask, jsonify, request, session
from webauthn import (
generate_authentication_options,
generate_registration_options,
options_to_json,
verify_authentication_response,
verify_registration_response,
)
from webauthn.helpers import base64url_to_bytes, bytes_to_base64url
from webauthn.helpers.structs import (
PublicKeyCredentialDescriptor,
UserVerificationRequirement,
)
PORT = 5050
RP_ID = "localhost" # 도메인만. 포트와 스킴은 넣지 않습니다.
RP_NAME = "Passkey Lab"
EXPECTED_ORIGIN = f"http://localhost:{PORT}" # 서버가 믿는 유일한 origin
app = Flask(__name__)
app.secret_key = "lab-only-secret-key" # 실습용 고정값. 운영에서는 환경 변수로 주입합니다.
# 비밀번호 로그인과 비교하려고 비밀번호 계정도 하나 둡니다. 실습용 평문입니다.
USERS = {"alice": {"password": "Summer2024!", "id": b"user-alice-0001", "creds": {}}}
EVENTS = [] # 화면에 보여 줄 서버 쪽 판정 기록
def log(kind, ok, detail):
EVENTS.append({"kind": kind, "ok": ok, "detail": detail})
del EVENTS[:-12]
def fail(kind, exc):
log(kind, False, f"{type(exc).__name__}: {exc}")
return jsonify(ok=False, error=str(exc)), 400
@app.get("/")
def index():
return PAGE
@app.get("/state")
def state():
u = USERS["alice"]
return jsonify(
user=session.get("user"),
via=session.get("via"),
host=request.host,
creds=[{"id": cid[:12] + "...", "sign_count": c["sign_count"]} for cid, c in u["creds"].items()],
events=EVENTS,
)
@app.post("/pw-login")
def pw_login():
data = request.get_json()
user = USERS.get(data.get("username"))
if user and user["password"] == data.get("password"):
session.clear()
session["user"], session["via"] = data["username"], "password"
log("password", True, f"비밀번호 로그인 허용 (접속 주소 {request.host})")
return jsonify(ok=True)
log("password", False, "비밀번호 불일치")
return jsonify(ok=False), 401
@app.post("/register/options")
def register_options():
if session.get("via") != "password":
return jsonify(ok=False, error="먼저 비밀번호로 로그인하세요"), 401
user = USERS[session["user"]]
opts = generate_registration_options(
rp_id=RP_ID,
rp_name=RP_NAME,
user_id=user["id"],
user_name=session["user"],
exclude_credentials=[
PublicKeyCredentialDescriptor(id=base64url_to_bytes(cid)) for cid in user["creds"]
],
)
session["challenge"] = bytes_to_base64url(opts.challenge) # 서버가 발급한 값을 저장
return app.response_class(options_to_json(opts), mimetype="application/json")
@app.post("/register/verify")
def register_verify():
challenge = session.pop("challenge", None) # 꺼내면서 지웁니다. 1회용입니다.
if challenge is None:
return fail("register", ValueError("발급된 챌린지가 없거나 이미 사용했습니다"))
user = USERS[session["user"]]
try:
v = verify_registration_response(
credential=request.get_json(),
expected_challenge=base64url_to_bytes(challenge),
expected_rp_id=RP_ID,
expected_origin=EXPECTED_ORIGIN,
)
except Exception as exc:
return fail("register", exc)
user["creds"][bytes_to_base64url(v.credential_id)] = {
"public_key": v.credential_public_key,
"sign_count": v.sign_count,
}
log("register", True, f"패스키 등록 (공개키 {len(v.credential_public_key)}바이트 저장, 개인키는 서버에 없음)")
return jsonify(ok=True)
@app.post("/login/options")
def login_options():
user = USERS["alice"]
opts = generate_authentication_options(
rp_id=RP_ID,
allow_credentials=[
PublicKeyCredentialDescriptor(id=base64url_to_bytes(cid)) for cid in user["creds"]
],
user_verification=UserVerificationRequirement.PREFERRED,
)
session["challenge"] = bytes_to_base64url(opts.challenge)
return app.response_class(options_to_json(opts), mimetype="application/json")
@app.post("/login/verify")
def login_verify():
challenge = session.pop("challenge", None) # 1회용
if challenge is None:
return fail("login", ValueError("발급된 챌린지가 없거나 이미 사용했습니다"))
body = request.get_json()
cred = USERS["alice"]["creds"].get(body.get("id"))
if cred is None:
return fail("login", ValueError("등록되지 않은 패스키입니다"))
try:
v = verify_authentication_response(
credential=body,
expected_challenge=base64url_to_bytes(challenge),
expected_rp_id=RP_ID,
expected_origin=EXPECTED_ORIGIN, # 다른 origin 에서 만든 서명은 여기서 거부
credential_public_key=cred["public_key"],
credential_current_sign_count=cred["sign_count"],
)
except Exception as exc:
return fail("login", exc)
cred["sign_count"] = v.new_sign_count # 카운터를 올려 저장
session.clear()
session["user"], session["via"] = "alice", "passkey"
log("login", True, f"패스키 로그인 허용 (서명 카운터 {v.new_sign_count})")
return jsonify(ok=True, sign_count=v.new_sign_count)
@app.post("/logout")
def logout():
session.clear()
return jsonify(ok=True)
PAGE = """<!doctype html><meta charset="utf-8"><title>Passkey Lab</title>
<style>
body{font-family:'Malgun Gothic',sans-serif;margin:28px;color:#222;max-width:900px}
h1{margin:0 0 4px}.host{color:#555;margin-bottom:16px}
.card{border:1px solid #ccd;border-radius:8px;padding:14px 18px;margin:12px 0}
button{padding:8px 14px;margin-right:8px;font-size:15px;cursor:pointer}
input{padding:7px;font-size:15px;margin-right:8px}
#me{font-weight:700;padding:10px 14px;border-radius:8px;background:#eef1f5}
#me.in{background:#dff5e1;color:#14692a}
pre{background:#101820;color:#d8e2ea;padding:10px 12px;border-radius:6px;font-size:13px;white-space:pre-wrap;margin:8px 0 0}
.bad{color:#ff8a8a}.good{color:#8be59b}
</style>
<h1>Passkey Lab</h1>
<div class="host">접속 주소: <b id="host"></b> (서버가 믿는 origin: http://localhost:5050)</div>
<div id="me"></div>
<div class="card"><b>1. 비밀번호 로그인</b><br>
<input id="u" value="alice" size="8"><input id="p" type="password" value="Summer2024!" size="12">
<button onclick="pwLogin()">비밀번호로 로그인</button></div>
<div class="card"><b>2. 패스키 등록</b> (비밀번호로 로그인한 뒤)<br>
<button onclick="reg()">패스키 만들기</button></div>
<div class="card"><b>3. 패스키 로그인</b><br>
<button onclick="login()">패스키로 로그인</button>
<button onclick="replay()">같은 응답 다시 보내기</button>
<button onclick="out_()">로그아웃</button></div>
<div class="card"><b>서버 판정 기록</b><pre id="ev"></pre></div>
<script>
const J = (u, b) => fetch(u, {method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(b || {})});
let last = null;
async function refresh() {
const s = await (await fetch('/state')).json();
document.getElementById('host').textContent = location.origin;
const me = document.getElementById('me');
me.className = s.user ? 'in' : '';
const creds = s.creds.map(c => c.id + ' 카운터=' + c.sign_count).join(', ') || '없음';
me.textContent = (s.user ? '로그인됨: ' + s.user + ' (' + s.via + ')' : '로그아웃 상태') + ' | 등록된 패스키: ' + creds;
document.getElementById('ev').innerHTML = s.events.map(e =>
'<span class="' + (e.ok ? 'good' : 'bad') + '">' + (e.ok ? '허용 ' : '거부 ') + e.kind + '</span> ' + e.detail.replace(/</g, '<')).join('\\n');
}
async function pwLogin() { await J('/pw-login', {username: u.value, password: p.value}); refresh(); }
async function reg() {
const o = await (await J('/register/options')).json();
if (o.error) { alert(o.error); return; }
const cred = await navigator.credentials.create({publicKey: PublicKeyCredential.parseCreationOptionsFromJSON(o)});
await J('/register/verify', cred.toJSON()); refresh();
}
async function login() {
const o = await (await J('/login/options')).json();
let cred;
try { cred = await navigator.credentials.get({publicKey: PublicKeyCredential.parseRequestOptionsFromJSON(o)}); }
catch (e) { document.getElementById('ev').textContent = '브라우저가 거부: ' + e.name + ' ' + e.message; return; }
last = cred.toJSON();
await J('/login/verify', last); refresh();
}
async function replay() { if (last) { await J('/login/verify', last); refresh(); } }
async function out_() { await J('/logout'); refresh(); }
refresh();
</script>"""
if __name__ == "__main__":
# evil.localhost 로도 접속해 볼 수 있게 localhost 이름 전체에서 받습니다.
app.run(host="127.0.0.1", port=PORT)
"""피싱 중계 서버 시뮬레이션. 진짜 앱(5050)과 같은 화면을 5051 포트에서 보여 주고,
받은 요청을 진짜 앱에 그대로 전달합니다. 실제 공격자가 쓰는 '중간자 중계'와 같은 구조입니다.
연습용 앱(app.py)에만 쓰세요."""
import urllib.error
import urllib.request
from flask import Flask, Response, request
from app import PAGE
REAL = "http://127.0.0.1:5050"
app = Flask(__name__)
cookie = {"value": ""} # 공격자 서버가 진짜 앱과 주고받는 세션 쿠키
@app.get("/")
def index():
return PAGE
@app.route("/<path:path>", methods=["GET", "POST"])
def relay(path):
req = urllib.request.Request(
f"{REAL}/{path}",
data=request.get_data() if request.method == "POST" else None,
method=request.method,
headers={"Content-Type": "application/json", "Cookie": cookie["value"]},
)
try:
resp = urllib.request.urlopen(req, timeout=10)
except urllib.error.HTTPError as exc:
resp = exc
set_cookie = resp.headers.get("Set-Cookie")
if set_cookie:
cookie["value"] = set_cookie.split(";")[0]
return Response(resp.read(), status=resp.status, mimetype="application/json")
if __name__ == "__main__":
app.run(host="127.0.0.1", port=5051)
두 서버를 각각 다른 터미널에서 띄웁니다.
python app.py
python phish.py
중계 화면(http://localhost:5051)에서 비밀번호로 로그인하면 진짜 앱이 그대로 허용합니다. 서버 입장에서는 올바른 비밀번호가 도착했을 뿐이라 정상 로그인과 구분할 방법이 없습니다.

3. 원인: 비밀번호는 어디에 입력해도 같은 값입니다
비밀번호는 사용자가 아는 비밀이라서, 입력 화면이 진짜인지 가짜인지와 상관없이 같은 문자열이 서버로 갑니다. 서버가 확인하는 것은 "이 문자열이 맞는가"뿐이고 "어디서 입력했는가"는 확인하지 못합니다. 사용자가 같은 비밀번호를 여러 곳에 쓰면 한 곳에서 새어 나간 비밀번호로 다른 곳까지 열립니다. 이 글의 연습 계정이 쓰는 Summer2024! 같은 규칙적인 비밀번호는 재사용도 쉽습니다. 추측과 대입 공격에도 약하지만 이 글에서는 피싱만 다룹니다.
4. 수정: 패스키 등록과 로그인
패스키를 등록할 때는 인증기가 사이트마다 새 키 쌍을 만들고, 서버는 공개키만 저장합니다. 로그인할 때는 서버가 보낸 무작위 값(챌린지)에 인증기가 개인키로 서명하고, 서명 데이터에 접속 주소(origin)와 rpId 해시가 함께 들어갑니다. 서버가 검증하는 것은 다음 네 가지이고, app.py의 위치와 함께 정리하면 아래와 같습니다.
| 검증 | 코드 위치 | 막는 것 |
|---|---|---|
| 챌린지 일치와 1회성 | session.pop("challenge"), expected_challenge |
응답 재전송 |
| origin 일치 | expected_origin=EXPECTED_ORIGIN |
다른 주소에서 받은 서명 |
| rpId 해시 일치 | expected_rp_id=RP_ID |
다른 사이트용 서명 |
| 서명 카운터 | credential_current_sign_count, new_sign_count |
복제된 인증기 의심 |
등록 순서는 이렇습니다. 비밀번호로 로그인한 사용자가 등록을 시작하면 서버가 generate_registration_options로 옵션과 챌린지를 만들어 세션에 저장합니다. 브라우저가 navigator.credentials.create로 인증기에서 키 쌍을 만들고, 서버가 verify_registration_response로 확인한 뒤 공개키와 카운터를 저장합니다. 개인키는 인증기 밖으로 나오지 않으므로 서버의 저장소가 털려도 로그인에 쓸 수 없습니다. 이 글의 앱은 이미 비밀번호로 로그인한 사용자만 패스키를 추가하게 해서 등록 경로를 단순하게 했습니다.
로그인 순서도 같은 모양입니다. generate_authentication_options가 챌린지를 만들고, 브라우저가 navigator.credentials.get으로 서명을 받고, 서버가 verify_authentication_response로 검증한 뒤 카운터를 갱신해 저장합니다. rpId는 localhost입니다. 포트와 스킴은 rpId에 들어가지 않으므로 5050과 5051이 같은 rpId를 씁니다. 이 점이 6단계의 중계 시연에서 중요합니다.
두 서버를 띄운 채로 세 번째 터미널에서 확인 스크립트를 한 번에 돌려 봅니다. 가상 인증기를 켠 크롬 탭에서 정상 주소 시나리오와 피싱 시나리오를 차례로 실행합니다.
"""가상 인증기로 등록, 로그인, 재전송, 피싱 주소 접속을 자동으로 확인합니다.
사용법: python app.py 와 python phish.py 를 각각 띄운 뒤 다른 터미널에서
python drive.py (결과 출력만)
python drive.py shots (shots 폴더에 화면도 저장)
환경 변수 CHROME_PATH 로 Chrome 실행 파일을 지정할 수 있습니다.
"""
import os
import sys
from pathlib import Path
from playwright.sync_api import sync_playwright
CHROME = os.environ.get("CHROME_PATH", r"C:\Program Files\Google\Chrome\Application\chrome.exe")
SHOTS = Path(sys.argv[1]) if len(sys.argv) > 1 else None
GOOD = "http://localhost:5050/"
RELAY = "http://localhost:5051/" # phish.py 가 띄우는 중계 서버
EVIL = "http://evil.localhost:5050/" # 다른 도메인에서 접속하는 경우
def shot(page, name):
if SHOTS:
SHOTS.mkdir(parents=True, exist_ok=True)
page.screenshot(path=str(SHOTS / name))
def status(page):
page.wait_for_timeout(500)
me = page.inner_text("#me")
ev = page.inner_text("#ev").strip().splitlines()
return me, ev[-1] if ev else ""
def virtual_authenticator(context, page):
cdp = context.new_cdp_session(page)
cdp.send("WebAuthn.enable")
cdp.send("WebAuthn.addVirtualAuthenticator", {"options": {
"protocol": "ctap2", "transport": "internal",
"hasResidentKey": True, "hasUserVerification": True,
"isUserVerified": True, "automaticPresenceSimulation": True,
}})
return cdp
with sync_playwright() as p:
browser = p.chromium.launch(executable_path=CHROME, headless=True)
# 1. 정상 주소: 등록, 로그인, 재전송
ctx = browser.new_context(viewport={"width": 980, "height": 760})
page = ctx.new_page()
virtual_authenticator(ctx, page)
page.goto(GOOD)
page.wait_for_timeout(500)
shot(page, "01-start.png")
page.click("text=비밀번호로 로그인")
print("비밀번호 로그인 ", *status(page))
page.click("text=패스키 만들기")
me, last = status(page)
print("패스키 등록 ", me, "|", last)
shot(page, "02-registered.png")
page.click("text=로그아웃")
page.click("text=패스키로 로그인")
me, last = status(page)
print("패스키 로그인 1 ", me, "|", last)
page.click("text=로그아웃")
page.click("text=패스키로 로그인")
me, last = status(page)
print("패스키 로그인 2 ", me, "|", last)
shot(page, "03-login-ok.png")
page.click("text=같은 응답 다시 보내기")
me, last = status(page)
print("같은 응답 재전송", me, "|", last)
shot(page, "04-replay.png")
# 2. 피싱 중계 서버(phish.py, 5051): 같은 탭, 같은 가상 인증기에서 주소만 바꿉니다.
page.goto(RELAY)
page.click("text=비밀번호로 로그인")
me, last = status(page)
print("중계 주소 비밀번호", me, "|", last)
shot(page, "05-phish-password.png")
page.click("text=로그아웃")
page.click("text=패스키로 로그인")
me, last = status(page)
print("중계 주소 패스키 ", me, "|", last)
shot(page, "06-phish-passkey.png")
# 3. 가짜 도메인(evil.localhost): 브라우저가 서명 자체를 만들지 않습니다.
page.goto(EVIL)
page.click("text=패스키로 로그인")
me, last = status(page)
print("가짜 도메인 패스키", last)
shot(page, "07-phish-browser.png")
ctx.close()
browser.close()
python drive.py shots
5. 재확인: 등록과 로그인
비밀번호로 로그인한 뒤 패스키를 만들면 서버가 공개키를 저장하고 판정 기록에 등록 허용이 남습니다. 화면의 카운터 1은 가상 인증기가 등록 때 이미 한 번 세었다는 뜻입니다.

로그아웃하고 패스키로 로그인하면 비밀번호 입력 없이 로그인되고, 로그인할 때마다 카운터가 2, 3으로 오릅니다. 서버는 서명 검증이 통과한 뒤에야 카운터를 저장합니다.

같은 로그인 응답을 그대로 한 번 더 보내 봅니다. 챌린지는 session.pop으로 꺼내면서 지워지므로 두 번째 요청에서는 꺼낼 값이 없고, 서버는 서명을 보기도 전에 거부합니다.

drive.py의 출력은 아래와 같습니다. 패스키 ID 앞부분은 실행마다 달라지고, 카운터 변화와 허용, 거부 판정은 같아야 합니다.
비밀번호 로그인 로그인됨: alice (password) | 등록된 패스키: 없음 허용 password 비밀번호 로그인 허용 (접속 주소 localhost:5050)
패스키 등록 로그인됨: alice (password) | 등록된 패스키: cIV79F1DNsnH... 카운터=1 | 허용 register 패스키 등록 (공개키 42바이트 저장, 개인키는 서버에 없음)
패스키 로그인 1 로그인됨: alice (passkey) | 등록된 패스키: cIV79F1DNsnH... 카운터=2 | 허용 login 패스키 로그인 허용 (서명 카운터 2)
패스키 로그인 2 로그인됨: alice (passkey) | 등록된 패스키: cIV79F1DNsnH... 카운터=3 | 허용 login 패스키 로그인 허용 (서명 카운터 3)
같은 응답 재전송 로그인됨: alice (passkey) | 등록된 패스키: cIV79F1DNsnH... 카운터=3 | 거부 login ValueError: 발급된 챌린지가 없거나 이미 사용했습니다
중계 주소 비밀번호 로그인됨: alice (password) | 등록된 패스키: cIV79F1DNsnH... 카운터=3 | 허용 password 비밀번호 로그인 허용 (접속 주소 127.0.0.1:5050)
중계 주소 패스키 로그아웃 상태 | 등록된 패스키: cIV79F1DNsnH... 카운터=3 | 거부 login InvalidAuthenticationResponse: Unexpected client data origin "http://localhost:5051", expected "http://localhost:5050"
가짜 도메인 패스키 브라우저가 거부: SecurityError The relying party ID is not a registrable domain suffix of, nor equal to the current domain. Subsequently, an attempt to fetch the .well-known/webauthn resource of the claimed RP ID failed.
6. 재확인: 피싱 중계에서는 패스키가 통과하지 못합니다
같은 탭, 같은 가상 인증기로 주소만 중계 서버(http://localhost:5051)로 바꿉니다. 이 주소는 rpId localhost와 호스트가 같아서 브라우저가 패스키 사용을 막지 않습니다. 사용자가 로그인을 누르면 인증기는 서명을 만들지만, 서명 데이터(clientDataJSON)에는 실제 접속 주소인 http://localhost:5051이 들어갑니다. 중계 서버가 이 응답을 진짜 앱에 전달하면 서버가 Unexpected client data origin으로 거부합니다. 앞에서 비밀번호 로그인은 통과했던 바로 그 중계입니다.

서버의 origin 검증이 필요한 이유가 이 장면입니다. rpId는 포트를 보지 않기 때문에 rpId만 맞으면 통과하는 서버는 같은 호스트의 다른 앱이나 하위 도메인에서 받은 서명을 받아 줍니다. expected_origin을 허용할 주소 목록으로 정확히 지정해야 합니다.
호스트 이름 자체가 다른 주소에서는 서명이 서버까지 오지도 못합니다. http://evil.localhost:5050에서 패스키 로그인을 누르면 브라우저가 rpId localhost를 현재 도메인과 연결하지 못해 SecurityError를 냅니다. 사용자가 속을 일이 없고, 서버에는 요청이 도착하지 않습니다.

7. 비밀번호 로그인과 비교
| 항목 | 비밀번호 | 패스키 |
|---|---|---|
| 서버가 가진 것 | 비밀번호(또는 해시) | 공개키 |
| 서버 저장소가 털리면 | 해시를 풀면 로그인에 사용 가능 | 공개키만으로는 로그인 불가 |
| 가짜 사이트에 입력하면 | 그대로 넘어감 | 서명에 접속 주소가 들어가 서버가 거부 |
| 재사용 | 사용자가 같은 값을 쓸 수 있음 | 사이트마다 새 키 쌍이라 재사용 없음 |
| 응답 재전송 | 해당 없음(비밀번호 자체가 재사용 가능) | 챌린지가 1회용이라 거부 |
| 복구 | 이메일 재설정 | 별도 설계 필요(아래) |
자주 막히는 곳
navigator.credentials.create가 NotAllowedError로 끝납니다
가상 인증기가 켜지지 않은 탭에서 실행한 경우입니다. addVirtualAuthenticator는 호출한 탭(CDP 세션)에만 적용됩니다. drive.py는 탭을 하나만 만들고 주소만 바꾸므로 같은 인증기를 계속 씁니다.
중계 주소에서 화면이 비어 보입니다
phish.py가 처음에 localhost로 진짜 앱에 접속했을 때 응답이 늦어 상태 확인이 빈 값으로 나왔습니다. 127.0.0.1로 바꾸니 바로 응답했습니다. localhost가 먼저 IPv6 주소로 풀려 재시도하면서 생긴 지연으로 추정하며, 이 부분은 따로 확인하지 않았습니다.
서버를 다시 띄웠더니 로그인이 안 됩니다 등록된 공개키를 메모리에만 두기 때문입니다. 서버를 재시작하면 패스키도 사라지므로 브라우저를 새로 열어 다시 등록합니다. 운영에서는 데이터베이스에 저장해야 합니다.
ValueError: 발급된 챌린지가 없거나 이미 사용했습니다가 정상 로그인에서 납니다
옵션 요청과 검증 요청이 서로 다른 세션 쿠키로 갔을 가능성이 큽니다. 주소를 바꿔 접속하면 쿠키가 따로 관리됩니다. 한 주소에서 옵션과 검증을 모두 보내야 합니다.
한계
- 복구 경로가 가장 약한 고리입니다. 패스키를 쓰더라도 기기를 잃었을 때 이메일 재설정으로 되돌릴 수 있다면, 공격자는 패스키 대신 복구 경로를 노립니다. 복구 절차의 본인 확인 강도를 패스키와 맞춰야 합니다. 이 글의 앱에는 복구 경로를 만들지 않았습니다.
- 동기화 패스키는 계정의 보안이 곧 패스키의 보안입니다. 운영체제나 비밀번호 관리자가 패스키를 클라우드로 동기화하면 그 계정이 뚫릴 때 패스키도 함께 위험해집니다. 동기화 패스키 중에는 서명 카운터를 항상 0으로 두는 구현이 있어서, 카운터가 오르지 않는다고 바로 복제로 판단하면 오탐이 납니다. 이 글은 카운터를 올려 저장하는 기본 동작만 확인했고, 카운터가 줄어드는 경우의 거부는 실행하지 않았습니다.
- 기기를 잃으면 그 기기의 패스키도 잃습니다. 패스키를 한 개만 등록하게 하면 잠깁니다. 사용자당 두 개 이상 등록을 권하고, 등록된 패스키 목록과 삭제 화면을 만들어야 합니다. 이 글의 앱은 사용자 한 명의 패스키 목록만 표시합니다.
- 챌린지에 유효 시간을 두지 않았습니다. 세션에 저장한 값을 한 번 쓰면 지울 뿐이고, 옵션을 받고 오래 지난 뒤의 응답도 세션이 살아 있으면 통과합니다. 운영에서는 발급 시각을 함께 저장해 몇 분 안에 쓰게 제한합니다.
- 실제 인증기를 쓰지 않았습니다. 가상 인증기로 서버 검증 로직만 확인했습니다. 생체 인식 실패, 보안 키 분실, 브라우저와 운영체제별 차이는 이 글의 범위 밖입니다.
- 연습용 구성입니다. 사용자 한 명, 메모리 저장, 평문 비밀번호, 고정 세션 키, http입니다. 그대로 서비스에 옮기지 않습니다. attestation은
none(기본값)이라 인증기 종류는 확인하지 않습니다. - 라이브러리 버전에 따라 옵션이 다릅니다. py_webauthn 3.0.1 기준이고, 다른 버전은 함수 인자와 반환 형식이 다를 수 있습니다.
정리하기
실습이 끝나면 두 서버를 Ctrl+C로 끄고 만든 파일을 지웁니다. 확인 스크립트는 임시 프로필로 크롬을 띄우고 종료할 때 닫습니다. 남는 것은 화면을 저장한 shots 폴더와 파이썬 캐시뿐입니다.
rm -rf shots __pycache__
이어서 해 볼 것
- 로그인 후 두 번째 패스키를 등록하고,
exclude_credentials가 같은 인증기의 중복 등록을 막는 것을 확인합니다. - 챌린지에 발급 시각을 붙여 일정 시간이 지나면 거부하도록
app.py를 고칩니다. - 비밀번호 로그인 자체를 닫고 패스키만 남겼을 때 복구 절차가 어떻게 되어야 하는지 정리해 봅니다.
확인 범위
- 해 본 것: 1~6단계 코드를 제가 직접 실행했습니다. 2024-07-26, Windows 11 · Python 3.12.10 · Flask 3.1.3 · py_webauthn 3.0.1 · Playwright 1.62.0 · Chrome 156.0.8078.48(헤드리스) 환경입니다. 화면은 같은 실행에서 얻었습니다. 가상 인증기는 CDP로 켰습니다. 가상 인증기가 등록 시 카운터를 1로 시작하고, 사용할 때마다 1씩 올리는 것을 이번 실행에서 관찰했습니다.
- 해 보지 않은 것: Linux와 macOS에서의 실행. 개발자 도구의 WebAuthn 패널 화면 캡처. 서명 카운터가 줄어드는 경우의 거부. 동기화 패스키. 실제 기기 인증기. 복구 경로.
- 읽을 때 주의: 가상 인증기 카운터 값은 이번 실행에서 관찰한 값입니다.
이 글의 다음 단계
- OS 명령어 인젝션: ping 기능으로 보는 shell=True의 위험과 수정호스트 ping 점검 화면만 있는 작은 Flask 도구에서 shell=True와 문자열 결합이 입력 한 줄로 서버 명령 실행까지 이어지는 과정을 id 출력으로 확인합니다. 인자 리스트, shell 미사용, ipaddress 검증, 허용 대역으로 고친 뒤 같은 입력이 거부되는 것까지 보고, 이 수정으로도 남는 한계를 짚습니다.
- SSRF 막기: URL 미리보기 기능에서 내부 주소 접근 차단링크를 입력하면 제목을 보여 주는 Flask 미리보기 기능이 서버 안쪽에서만 열려야 하는 서비스를 대신 호출하는 문제를 연습용 앱에서 확인합니다. 스킴 제한, 주소 해석 뒤 내부 IP 차단, 리디렉션 재검증, 타임아웃과 크기 제한을 넣고 같은 요청이 막히는 것까지 확인합니다.