S059 · AuthN & AuthZ — OAuth 2.0, OIDC, JWT

"""
auth_demo.py — Issue and verify a JWT, decode it by hand, and demonstrate
three common footguns.
 
Run:
    pip install "pyjwt[crypto]"
    python auth_demo.py
"""
from __future__ import annotations
 
import base64
import json
import time
from dataclasses import dataclass
 
import jwt   # PyJWT
 
# ---------- config ----------
ISSUER = "https://auth.example.com"
AUDIENCE = "https://api.example.com"
HS_SECRET = "not-a-real-secret-please-use-256-bits-from-os.urandom"  # for HS256
 
# ---------- issue a token ----------
def issue_token(user_id: str, scopes: list[str], ttl_seconds: int = 300) -> str:
    now = int(time.time())
    payload = {
        "iss": ISSUER,
        "sub": user_id,
        "aud": AUDIENCE,
        "iat": now,
        "exp": now + ttl_seconds,
        "scope": " ".join(scopes),
    }
    return jwt.encode(payload, HS_SECRET, algorithm="HS256", headers={"kid": "hs-1"})
 
# ---------- verify a token (the right way) ----------
def verify_token(token: str) -> dict:
    return jwt.decode(
        token,
        HS_SECRET,
        algorithms=["HS256"],        # PIN the algorithm — prevents alg confusion
        audience=AUDIENCE,           # check aud
        issuer=ISSUER,               # check iss
        options={"require": ["exp", "iat", "sub", "aud", "iss"]},
    )
 
# ---------- decode without verifying (for eyeballing only) ----------
def peek(token: str) -> dict:
    def _b64d(seg: str) -> dict:
        pad = "=" * (-len(seg) % 4)
        return json.loads(base64.urlsafe_b64decode(seg + pad))
    h, p, _ = token.split(".")
    return {"header": _b64d(h), "payload": _b64d(p)}
 
# ---------- footgun demos ----------
def footgun_alg_none(token: str) -> None:
    """Old libs accepted alg:none. Show that we don't."""
    header, payload, _ = token.split(".")
    payload_json = json.loads(base64.urlsafe_b64decode(payload + "==="))
    payload_json["scope"] = "admin"   # attacker escalates
    payload_json["sub"] = "attacker"
    new_payload = base64.urlsafe_b64encode(json.dumps(payload_json).encode()).rstrip(b"=").decode()
    new_header = base64.urlsafe_b64encode(b'{"alg":"none","typ":"JWT"}').rstrip(b"=").decode()
    forged = f"{new_header}.{new_payload}."
    try:
        verify_token(forged)
        print("❌ alg:none accepted — you have a critical vuln")
    except jwt.InvalidAlgorithmError:
        print("✅ alg:none rejected — algorithm is pinned")
    except jwt.DecodeError as e:
        print(f"✅ forged token rejected: {e}")
 
def footgun_expired(user_id: str) -> None:
    token = issue_token(user_id, ["read"], ttl_seconds=-1)  # already expired
    try:
        verify_token(token)
        print("❌ expired token accepted")
    except jwt.ExpiredSignatureError:
        print("✅ expired token rejected as it should be")
 
def footgun_wrong_audience(user_id: str) -> None:
    now = int(time.time())
    token = jwt.encode(
        {"iss": ISSUER, "sub": user_id, "aud": "https://other-api.example.com",
         "iat": now, "exp": now + 60, "scope": "read"},
        HS_SECRET, algorithm="HS256",
    )
    try:
        verify_token(token)
        print("❌ wrong-audience token accepted")
    except jwt.InvalidAudienceError:
        print("✅ wrong-audience token rejected")
 
# ---------- happy path ----------
def main() -> None:
    token = issue_token("user-42", ["read", "write"])
    print("=== issued token ===")
    print(token)
    print("\n=== decoded (header + payload) ===")
    print(json.dumps(peek(token), indent=2))
 
    claims = verify_token(token)
    print("\n=== verified claims ===")
    print(json.dumps(claims, indent=2))
 
    print("\n=== footgun tests ===")
    footgun_alg_none(token)
    footgun_expired("user-42")
    footgun_wrong_audience("user-42")
 
if __name__ == "__main__":
    main()

pip install "pyjwt[crypto]"
python auth_demo.py