# JWT 검증 실수: 서명 확인 끄기, alg none, 알고리즘 혼동, 만료와 aud

> 정상 토큰 1개와 공격 토큰 6개(alg none, 다른 키 서명, 만료, 다른 aud, 본문 변조, HS256 혼동)를 서명 확인을 끈 검증기, 헤더의 알고리즘을 믿는 검증기, 고친 검증기에 넣어 수락과 거절을 비교합니다. PyJWT가 막아 주는 것과 못 막는 것을 가르고 Node 구현으로 교차 확인합니다.

- 주소: https://copyandrun.com/blog/jwt-validation-pitfalls/
- 분야: 시큐어코딩
- 발행일: 2026-10-30
- 태그: JWT, PyJWT, alg none, 토큰 검증, 인증

JWT는 서명이 붙은 JSON이라서 "받은 토큰을 믿어도 되는가"는 검증 코드가 전부 결정합니다. 라이브러리가 안전하게 설계되어 있어도 옵션을 잘못 주면 검증이 사실상 꺼집니다. 이 글에서는 시험용 RSA 키로 정상 토큰 1개와 공격 토큰 6개를 만들어, 검증기 세 가지에 넣고 어떤 토큰이 통과하는지 표로 비교합니다. 모든 키와 토큰은 내 PC의 컨테이너 안에서 만든 시험용이고, 어떤 서비스에도 보내지 않았습니다. 로그인 쪽 절차는 [Keycloak OIDC PKCE 글](/blog/keycloak-oidc-pkce-local-login/)에서 다뤘으며, 이 글은 받는 쪽의 검증 코드만 봅니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| Docker | 29.5.3 (Windows 11, Git Bash에서 실행) |
| 파이썬 | 3.12 (`python:3.12-slim`) |
| PyJWT | 2.15.1 |
| cryptography | 50.0.2 |
| 교차 확인 | Node 22.23.2 + `jsonwebtoken` (`node:22-alpine`에서 npm 설치) |

서버 키 한 쌍과 공격자 키 한 쌍을 매번 새로 만들기 때문에 토큰 문자열은 실행마다 다릅니다.

## 1. 토큰 일곱 개

<!-- files: make_tokens.py -->

서버는 RS256(개인키로 서명, 공개키로 검증)을 쓰고 발급자(`iss`)는 `https://auth.lab`, 대상(`aud`)은 `shop-api`라고 가정했습니다.

| 이름 | 만든 방법 | 서버가 거절해야 하는 이유 |
|---|---|---|
| 정상 토큰 | 서버 개인키로 서명, 10분 뒤 만료 | (수락해야 함) |
| alg none | 헤더 `alg: none`, 서명 칸 비움, `role: admin` | 서명이 없음 |
| 다른 키 서명 | 공격자 키로 RS256 서명, `role: admin` | 서버 키가 아님 |
| 만료 | 서버 키로 서명, 1시간 전에 만료 | 유효 시간이 지남 |
| 다른 aud | 서버 키로 서명, `aud: billing-api` | 다른 서비스용 토큰 |
| 본문 변조 | 정상 토큰의 본문을 `role: admin`으로 바꾸고 서명은 그대로 | 서명과 본문이 맞지 않음 |
| HS256 혼동 | 서버 공개키 PEM을 HMAC 비밀로 써서 HS256으로 직접 서명 | 알고리즘 혼동 공격 |

마지막 토큰은 PyJWT로는 만들 수 없어서(PyJWT가 공개키를 HMAC 비밀로 쓰는 것을 막습니다) `hmac`과 `base64`로 손으로 만들었습니다. 공개키는 누구나 얻을 수 있으므로, 서버가 헤더의 `alg`를 믿는다면 공격자가 이 토큰을 만들 수 있다는 것이 이 공격의 원리입니다.

## 2. 검증기 세 가지

<!-- files: verifier_nosig.py, verifier_bad.py, verifier_good.py -->

| 검증기 | 코드의 핵심 |
|---|---|
| `nosig` | `jwt.decode(token, options={"verify_signature": False})` |
| `bad` | 토큰 헤더의 `alg`를 읽어 그대로 허용하고, 만료와 `iss`와 `aud` 검사를 끔 |
| `good` | `algorithms=["RS256"]` 고정, `issuer`, `audience`, `leeway=5`, 필수 항목 `exp iat iss aud sub` |

`nosig`는 클레임을 읽으려고 `decode`를 부르다가 서명 확인을 끈 채로 인증에 쓰는 실수를 흉내 냅니다. `bad`는 라이브러리 옵션을 잘못 준 경우입니다.

## 3. 결과

```
토큰             nosig     bad    good
정상 토큰             수락      수락      수락
alg none          수락      거절      거절
다른 키 서명           수락      거절      거절
만료                수락      수락      거절
다른 aud            수락      수락      거절
본문 변조             수락      거절      거절
HS256 혼동          수락      거절      거절
공격 수락            6       2       0
```

![jwt_demo.sh 실행 결과에서 서명 확인을 끈 검증기는 공격 토큰 6개를 모두 수락하고, 헤더 알고리즘을 믿는 검증기는 만료와 다른 aud 2개를 수락하며, 고친 검증기는 0개를 수락하고, 종료 코드는 1과 1과 0이며, Node 구현도 공격 토큰 0건 수락으로 종료 코드 0인 것을 확인합니다.](https://copyandrun.com/img/jwt-validation-pitfalls/01-jwt-검증기-비교.png)

- **`nosig`는 공격 토큰을 6개 모두 수락했습니다.** 서명 확인을 끄면 `role: admin` 토큰이 그대로 통과합니다. 서명 위조 공격이 필요하지도 않습니다.
- **`bad`가 수락한 것은 만료와 다른 aud 두 개였습니다.** 서명은 진짜이므로 서명만 보는 검증을 통과하는 것입니다. 만료 토큰이 영원히 쓰이고, 다른 서비스용 토큰이 이 서비스에서도 통한다는 뜻입니다.
- **의외로 `bad`는 alg none과 HS256 혼동을 막았습니다.** 혼동 토큰은 `InvalidKeyError`(공개키 PEM을 HMAC 비밀로 쓸 수 없음)로, alg none은 `InvalidSignatureError`로 거절되었습니다. `bad`는 헤더의 알고리즘을 그대로 허용하도록 만들었는데도 일어난 거절이라 라이브러리 쪽 방어로 보이지만, 소스까지는 읽지 않았습니다. 다른 버전이나 다른 언어의 라이브러리에서도 막힌다고 일반화할 수 없습니다.
- **`good`은 공격 토큰 6개를 모두 거절했고, 이유가 서로 다릅니다.** `alg none`과 `HS256 혼동`은 `InvalidAlgorithmError`(허용 목록에 없는 알고리즘)였고 만료는 `ExpiredSignatureError`, 다른 aud는 `InvalidAudienceError`, 다른 키 서명과 본문 변조는 `InvalidSignatureError`였습니다.

![고친 검증기의 결과에서 정상 토큰은 수락되고 alg none과 HS256 혼동은 InvalidAlgorithmError, 다른 키 서명과 본문 변조는 InvalidSignatureError, 만료는 ExpiredSignatureError, 다른 aud는 InvalidAudienceError로 거절되는 것을 확인합니다.](https://copyandrun.com/img/jwt-validation-pitfalls/02-고친-검증기-거절-사유.png)

## 4. 게이트

`run_all.py`에 검증기 하나를 주면 공격 토큰이 하나라도 수락되거나 정상 토큰이 거절될 때 종료 코드 1로 끝납니다.

| 검증기 | 종료 코드 |
|---|---|
| `nosig` | 1 |
| `bad` | 1 |
| `good` | 0 |

정상 토큰이 거절되는 경우도 실패로 본 이유는 모든 토큰을 거절하는 검증기가 "안전"해 보이는 것을 막기 위해서입니다. 이 게이트를 서비스의 인증 단위 시험에 넣으면 검증 코드를 바꿀 때마다 같은 일곱 토큰으로 다시 확인할 수 있습니다.

## 5. 교차 확인: Node의 `jsonwebtoken`

<!-- files: node_verify.js -->

같은 토큰 일곱 개와 공개키를 Node 구현에도 넣었습니다. `algorithms: ["RS256"]`, `issuer`, `audience`를 고정했습니다.

| 토큰 | 결과 |
|---|---|
| 정상 토큰 | 수락 |
| 나머지 6개 | 모두 거절(만료는 `TokenExpiredError`, 그 외는 `JsonWebTokenError`) |

파이썬과 Node 두 구현이 같은 결론을 냈습니다. 내가 만든 토큰이 파이썬에서만 우연히 거절되는 것이 아님을 확인한 것입니다.

## 6. 고칠 때의 순서

1. 검증은 반드시 서명 확인을 켠 `decode`나 `verify`로 합니다. 클레임을 읽기만 하는 코드는 이름을 달리해 인증 경로에서 쓰지 않습니다.
2. `algorithms`는 서버 설정에서 고정하고, 토큰 헤더의 `alg`는 읽지 않습니다.
3. `exp`, `iss`, `aud`를 모두 검사하고 필수 항목으로 지정합니다.
4. 키는 서버가 가진 공개키만 씁니다. 헤더의 `jku`나 `kid`가 알려 주는 곳에서 키를 가져오지 않습니다(이 글에서는 `jku`와 `kid`를 시험하지 않았습니다).

## 전체 코드

전체를 한 번에 돌리는 스크립트입니다. 아래 파일과 같은 폴더에서 실행합니다.

```bash
# jwt_demo.sh
#!/usr/bin/env bash
# 토큰 일곱 개(정상 1, 공격 6)를 서명 확인을 끈 검증기, 알고리즘을 헤더에서 읽는 검증기, 고친 검증기에 넣어 비교하고, Node 구현으로 교차 확인한다.
# 준비: Docker, 같은 폴더에 make_tokens.py, verifier_*.py, run_all.py, node_verify.js. 시험용 키는 매번 새로 만든다.
# 실행(Git Bash): bash jwt_demo.sh   (약 2분)
export MSYS_NO_PATHCONV=1
HERE="$(pwd)"
OUT=../osk-fc-jwt-out                      # 결과 폴더는 코드 폴더 밖에 둔다
rm -rf "$OUT"; mkdir -p "$OUT"; ABS="$(cd "$OUT" && pwd)"
PY() { docker run --rm -v "$HERE:/w:ro" -v "$ABS:/out" -w /w -e PYTHONPATH=/w python:3.12-slim sh -c "pip install -q pyjwt cryptography >/dev/null 2>&1; $1"; }

echo "## 1. 토큰 만들기"
PY "python make_tokens.py /out"
echo "## 2. 세 검증기 비교"
PY "python run_all.py /out nosig bad good"
echo "## 3. 검증기별 게이트"
for v in nosig bad good; do
  PY "python run_all.py /out $v >/dev/null; echo \"  verifier_$v 종료 코드 \$?\""
done
echo "## 4. 교차 확인: Node jsonwebtoken (알고리즘 고정, iss/aud 확인)"
docker run --rm -v "$HERE:/w:ro" -v "$ABS:/out:ro" -w /tmp node:22-alpine sh -c 'npm install --silent jsonwebtoken >/dev/null 2>&1; cp /w/node_verify.js /tmp/; node /tmp/node_verify.js /out; echo "  종료 코드 $?"'
echo "## 끝 (결과 폴더: $OUT)"
```

시험용 키와 토큰 일곱 개를 만드는 스크립트입니다.

```python
# make_tokens.py
"""시험용 키 두 쌍을 만들고, 정상 토큰 하나와 공격 토큰 여섯 개를 tokens.json 으로 저장한다.
사용: python make_tokens.py 출력폴더"""
import base64
import hashlib
import hmac
import json
import sys
import time

import jwt
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa

out = sys.argv[1]
ISS, AUD = "https://auth.lab", "shop-api"


def new_key():
    return rsa.generate_private_key(public_exponent=65537, key_size=2048)


def pem_priv(k):
    return k.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption())


def pem_pub(k):
    return k.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo)


def b64(data):
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()


server, attacker = new_key(), new_key()
now = int(time.time())
user = {"sub": "alice", "role": "user", "iss": ISS, "aud": AUD, "iat": now, "exp": now + 600}
admin = dict(user, sub="mallory", role="admin")

good = jwt.encode(user, pem_priv(server), algorithm="RS256")

# 1) 서명이 없는 토큰(alg none)
none_tok = b64(json.dumps({"alg": "none", "typ": "JWT"}).encode()) + "." + b64(json.dumps(admin).encode()) + "."
# 2) 공격자 키로 서명한 토큰
wrong_key = jwt.encode(admin, pem_priv(attacker), algorithm="RS256")
# 3) 만료된 토큰(서명은 진짜)
expired = jwt.encode(dict(user, iat=now - 7200, exp=now - 3600), pem_priv(server), algorithm="RS256")
# 4) 다른 서비스용 토큰(서명은 진짜, aud 만 다름)
wrong_aud = jwt.encode(dict(user, aud="billing-api"), pem_priv(server), algorithm="RS256")
# 5) 본문만 바꾼 토큰(서명은 그대로)
h, p, s = good.split(".")
tampered = h + "." + b64(json.dumps(admin).encode()) + "." + s
# 6) 알고리즘 혼동: 공개키 PEM 을 HMAC 비밀로 써서 HS256 으로 직접 서명(PyJWT 의 보호를 피해 손으로 만듦)
head = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode()) + "." + b64(json.dumps(admin).encode())
sig = hmac.new(pem_pub(server), head.encode(), hashlib.sha256).digest()
confusion = head + "." + b64(sig)

tokens = {"정상 토큰": good, "alg none": none_tok, "다른 키 서명": wrong_key, "만료": expired,
          "다른 aud": wrong_aud, "본문 변조": tampered, "HS256 혼동": confusion}
json.dump(tokens, open(f"{out}/tokens.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1)
open(f"{out}/server_pub.pem", "wb").write(pem_pub(server))
print(f"토큰 {len(tokens)}개와 공개키를 {out} 에 저장")
```

서명 확인을 끈 검증기입니다.

```python
# verifier_nosig.py
"""가장 흔한 실수: 클레임을 읽으려고 decode 하면서 서명 확인을 꺼 둔 채로 인증에 쓴다."""
import jwt


def verify(token, public_pem):
    return jwt.decode(token, options={"verify_signature": False})
```

헤더의 알고리즘을 믿고 만료와 대상을 보지 않는 검증기입니다.

```python
# verifier_bad.py
"""검증을 잘못 구현한 예: 토큰 헤더의 알고리즘을 믿고, 만료와 대상(aud)을 보지 않는다."""
import jwt


def verify(token, public_pem):
    alg = jwt.get_unverified_header(token)["alg"]          # 잘못: 헤더가 알려 주는 알고리즘을 그대로 허용
    key = public_pem if alg != "none" else None
    return jwt.decode(
        token, key, algorithms=[alg],
        options={"verify_exp": False, "verify_aud": False, "verify_iss": False},
    )
```

고친 검증기입니다.

```python
# verifier_good.py
"""고친 검증: 알고리즘을 서버가 고정하고, 만료 시각, 발급자, 대상, 필수 항목을 모두 확인한다."""
import jwt

ISS, AUD = "https://auth.lab", "shop-api"


def verify(token, public_pem):
    return jwt.decode(
        token, public_pem, algorithms=["RS256"],
        issuer=ISS, audience=AUD, leeway=5,
        options={"require": ["exp", "iat", "iss", "aud", "sub"]},
    )
```

토큰을 검증기에 넣어 결과를 보이고 게이트 판정을 하는 스크립트입니다.

```python
# run_all.py
"""토큰을 검증기에 넣어 수락/거절을 보인다.
검증기 하나를 주면 상세 결과와 게이트(공격 토큰 수락이 있으면 종료 코드 1), 둘 이상을 주면 표로 비교한다.
사용: python run_all.py 폴더 good   |   python run_all.py 폴더 nosig bad good"""
import importlib
import json
import sys

sys.stdout.reconfigure(encoding="utf-8")
folder, names = sys.argv[1], sys.argv[2:]
tokens = json.load(open(f"{folder}/tokens.json", encoding="utf-8"))
pub = open(f"{folder}/server_pub.pem", "rb").read()


def run(which):
    verify = importlib.import_module(f"verifier_{which}").verify
    out = {}
    for name, tok in tokens.items():
        try:
            claims = verify(tok, pub)
            out[name] = ("수락", f"sub={claims.get('sub')}, role={claims.get('role')}")
        except Exception as e:
            out[name] = ("거절", type(e).__name__)
    return out


results = {n: run(n) for n in names}
accepted = {n: sum(1 for k, (r, _) in res.items() if k != "정상 토큰" and r == "수락") for n, res in results.items()}
legit = {n: results[n]["정상 토큰"][0] == "수락" for n in names}

if len(names) == 1:
    n = names[0]
    print(f"== verifier_{n}")
    for k, (r, why) in results[n].items():
        print(f"  {k:<10} {r}  ({why})")
    print(f"  공격 토큰 수락 {accepted[n]}건, 정상 토큰 {'수락' if legit[n] else '거절'}")
    sys.exit(1 if accepted[n] or not legit[n] else 0)

print(f"{'토큰':<12}" + "".join(f"{n:>8}" for n in names))
for k in tokens:
    print(f"{k:<12}" + "".join(f"{results[n][k][0]:>8}" for n in names))
print(f"{'공격 수락':<10}" + "".join(f"{accepted[n]:>8}" for n in names))
```

Node 구현으로 교차 확인하는 스크립트입니다.

```javascript
# node_verify.js
// 교차 확인: 다른 구현(Node jsonwebtoken)으로 같은 토큰을 고정 알고리즘 설정에서 검증한다.
// 사용: node node_verify.js 폴더
const fs = require("fs");
const jwt = require("jsonwebtoken");
const dir = process.argv[2];
const tokens = JSON.parse(fs.readFileSync(`${dir}/tokens.json`, "utf8"));
const pub = fs.readFileSync(`${dir}/server_pub.pem`);
let accepted = 0;
for (const [name, tok] of Object.entries(tokens)) {
  let r;
  try {
    jwt.verify(tok, pub, { algorithms: ["RS256"], issuer: "https://auth.lab", audience: "shop-api" });
    r = "수락";
    if (name !== "정상 토큰") accepted++;
  } catch (e) {
    r = "거절 (" + e.name + ")";
  }
  console.log(`  ${name.padEnd(10)} ${r}`);
}
console.log(`  공격 토큰 수락 ${accepted}건`);
process.exit(accepted ? 1 : 0);
```

## 자주 막히는 곳

| 증상 | 원인 | 해결 |
|---|---|---|
| Node에서 `Cannot find module 'jsonwebtoken'` | 읽기 전용 마운트 폴더의 스크립트는 그 폴더 기준으로 모듈을 찾음 | `npm install`한 폴더로 스크립트를 복사해 실행 |
| PyJWT로 HS256 혼동 토큰이 만들어지지 않음 | 공개키 PEM을 HMAC 비밀로 쓰면 `InvalidKeyError` | 시험용으로만 `hmac`과 `base64`로 직접 서명 |
| 한글 표의 열이 어긋나 보임 | 터미널에서 한글 글자 폭이 영문의 두 배 | 숫자만 확인하거나 표를 파일로 저장해 열어 봄 |

## 확인 범위

- **해 본 것:** 2026-10-30, Windows 11 · Docker 29.5.3 · PyJWT 2.15.1 · cryptography 50.0.2에서 정상 토큰 1개와 공격 토큰 6개를 검증기 세 가지에 넣어 수락과 거절을 확인했고, 종료 코드 게이트를 만들었으며, Node 22.23.2의 `jsonwebtoken`으로 교차 확인했습니다. 전체 스크립트를 세 번 실행했고 결과는 모두 같았습니다.
- **해 보지 않은 것:** `kid`와 `jku` 헤더를 이용한 공격, ES256과 EdDSA 서명, 토큰 폐기(블랙리스트)와 리프레시 토큰, 시계 오차가 큰 환경에서의 `leeway`, 쿠키와 헤더에 담아 보내는 방식의 차이, Java와 Go 같은 다른 라이브러리, Linux와 macOS.
- **읽을 때 주의:** `bad` 검증기가 alg none과 HS256 혼동을 막은 것은 이 PyJWT 버전의 동작입니다. 오래된 버전이나 다른 라이브러리에서는 통과할 수 있으므로 알고리즘 고정을 생략해서는 안 됩니다. 이 글의 토큰과 키는 시험용입니다.
