Back
+30 XP
Concept

JSON Web Token (JWT) Parser & HMAC-SHA256

JSON Web Tokens (JWT) structure compact claims across three base64url segments separated by dots: header, payload, and signature. Verifying a JWT requires recomputing HMAC-SHA256 across header and payload bytes, validating signatures with compare_digest, and checking expiration claims.

python
# Signing input:
msg = f"{header_b64}.{payload_b64}".encode('ascii')
expected_sig = hmac.new(secret, msg, hashlib.sha256).digest()

# JSON Web Token (JWT) Parser & HMAC-SHA256 JSON Web Tokens (RFC 7519) are stateless auth tokens passed in HTTP `Authorization: Bearer <token>` headers. A JWT consists of three segments delimited by dots: $$\text{Header} \,.\, \text{Payload} \,.\, \text{Signature}$$ 1. **Header**: JSON object (`{"alg": "HS256", "typ": "JWT"}`), encoded with URL-safe base64. 2. **Payload**: JSON claims (`{"sub": "user_123", "exp": 1735689600}`), encoded with URL-safe base64. 3. **Signature**: $$\text{Signature} = \text{HMAC-SHA256}(\text{Secret}, \text{Header} \parallel \text{"."} \parallel \text{Payload})$$ ```python import base64 import hmac import hashlib # URL-safe base64 decoding with padding restoration: def b64url_decode(s: str) -> bytes: pad = "=" * ((4 - len(s) % 4) % 4) return base64.urlsafe_b64decode(s + pad) ``` ## Pop Quiz Why does JWT use base64url encoding rather than standard base64 encoding? - [ ] Base64url replaces `+` and `/` with `-` and `_`, and omits trailing `=` padding so tokens are safe inside URL query strings and HTTP headers. - [ ] Standard base64 triggers buffer overflows on HTTP/2 network proxies. - [ ] Base64url compresses JSON strings by 30% using Huffman tables. - [ ] Because web browsers reject cookies containing lowercase ASCII characters. ## Real-World Challenge Implement `verify_jwt(token: str, secret: bytes) -> dict`. - Parse the 3 parts of the token. - Recompute the HMAC-SHA256 signature and verify with `hmac.compare_digest`. - If the signature is invalid, raise `ValueError("Invalid signature")`. - If the payload contains an `"exp"` timestamp older than the current time, raise `ValueError("Token expired")`. - Return the decoded payload dictionary. <details> <summary>Solution</summary> ```python import base64 import json import hmac import hashlib import time def b64url_decode(text: str) -> bytes: padding = "=" * ((4 - len(text) % 4) % 4) return base64.urlsafe_b64decode(text + padding) def b64url_encode(raw: bytes) -> str: return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") def verify_jwt(token: str, secret: bytes) -> dict: segments = token.split(".") if len(segments) != 3: raise ValueError("Invalid JWT format: expected 3 dot-delimited segments") hdr_b64, payload_b64, sig_b64 = segments signing_input = f"{hdr_b64}.{payload_b64}".encode("ascii") expected_sig = hmac.new(secret, signing_input, hashlib.sha256).digest() provided_sig = b64url_decode(sig_b64) if not hmac.compare_digest(expected_sig, provided_sig): raise ValueError("Invalid signature") payload_json = b64url_decode(payload_b64).decode("utf-8") payload = json.loads(payload_json) if "exp" in payload and payload["exp"] < time.time(): raise ValueError("Token expired") return payload # Verification key = b"super_secret_auth_signing_key_42" # 1. Create valid token h_str = b64url_encode(json.dumps({"alg": "HS256", "typ": "JWT"}).encode("utf-8")) p_str = b64url_encode(json.dumps({"sub": "admin_user", "exp": time.time() + 300}).encode("utf-8")) sig_bytes = hmac.new(key, f"{h_str}.{p_str}".encode("ascii"), hashlib.sha256).digest() valid_jwt = f"{h_str}.{p_str}.{b64url_encode(sig_bytes)}" claims = verify_jwt(valid_jwt, key) assert claims["sub"] == "admin_user" # 2. Tampered payload tampered_jwt = valid_jwt[:-4] + "AAAA" tamper_failed = False try: verify_jwt(tampered_jwt, key) except ValueError: tamper_failed = True assert tamper_failed is True ``` </details>