Bảo mật JWT cho REST API: Ngăn chặn None Algorithm, Key Confusion và Triển khai Token Rotation

Security tutorial - IT technology blog
Security tutorial - IT technology blog

Bối cảnh & Lý do: Sáu tháng sự cố JWT

Chúng tôi triển khai xác thực JWT cho REST API khoảng sáu tháng trước. Bản triển khai ban đầu trông ổn trên giấy tờ — token, chữ ký, thời hạn. Điều tôi chưa lường được lúc đó là JWT có thể sai theo bao nhiêu cách nếu không khóa chặt các giá trị mặc định của thư viện.

Ba sự cố đã định hình cách tôi nhìn nhận về bảo mật JWT hiện nay:

  • Một pen tester trong nhóm đã bỏ qua hoàn toàn xác thực bằng thủ thuật None Algorithm — chỉ cần thay đổi alg trong header và loại bỏ chữ ký.
  • Chúng tôi phát hiện token ký bằng RSA dễ bị tấn công Key Confusion vì code xác thực không ép buộc thuật toán kỳ vọng.
  • Refresh token bị đánh cắp vẫn được tái sử dụng nhiều ngày sau khi người dùng “đăng xuất” vì chúng tôi không có cơ chế vô hiệu hóa token.

Không cái nào là lỗ hổng đặc biệt hay phức tạp. Tất cả đều được ghi chép rõ ràng, tồn tại nhiều năm, và đều có thể phòng ngừa được. Hai mươi dòng cấu hình được đặt đúng chỗ đã vá cả ba. Đây là những gì đã thay đổi.

Cài đặt: Xây dựng JWT Stack Bảo mật

Lựa chọn thư viện quan trọng ở đây. Một số thư viện JWT cũ chấp nhận alg: none theo mặc định hoặc không ép buộc algorithm whitelisting. Với Python, hãy dùng PyJWT phiên bản 2.x — API đã thay đổi đáng kể so với 1.x, và phiên bản mới có giá trị mặc định tốt hơn:

pip install PyJWT[crypto]==2.9.0

Về phía Node.js, jsonwebtoken là lựa chọn tiêu chuẩn — nhưng hãy kết hợp với jose để ép buộc thuật toán chặt chẽ hơn:

npm install jose@5

Chất lượng secret key quan trọng không kém gì lựa chọn thư viện. Tôi dùng công cụ tạo mật khẩu tại toolcraft.app/vi/tools/security/password-generator cho server secret — nó chạy hoàn toàn trên trình duyệt, không có dữ liệu nào được gửi qua mạng. Với HS256, tạo ít nhất 256 bit (32 byte hex ngẫu nhiên). Với RS256, tạo cặp khóa RSA 2048 bit:

# Tạo cặp khóa RSA cho RS256
openssl genrsa -out private.pem 2048
openssl rsa -in private.pem -pubout -out public.pem

Lưu private key ngoài web root với quyền truy cập đặt là 600. Nếu dùng Linux, chạy service dưới một user riêng biệt và hạn chế quyền truy cập khóa bằng filesystem ACL.

Cấu hình: Chặn Ba Vector Tấn công Chính

Chặn tấn công None Algorithm

Tấn công None Algorithm hoạt động vì đặc tả JWT ban đầu cho phép alg: none cho các token “không bảo mật”. Kẻ tấn công sửa header thành {"alg": "none"}, loại bỏ hoàn toàn chữ ký, và một số thư viện chấp nhận kết quả đó là hợp lệ.

Khắc phục bằng cách whitelist thuật toán tường minh ở phía decode. Đừng bao giờ để header của token tự quyết định thuật toán nào server nên dùng để xác thực:

import jwt

SECRET_KEY = "your-256-bit-secret"
ALLOWED_ALGORITHMS = ["HS256"]  # Whitelist tường minh — không bao giờ chấp nhận 'none'

def decode_token(token: str) -> dict:
    try:
        payload = jwt.decode(
            token,
            SECRET_KEY,
            algorithms=ALLOWED_ALGORITHMS,  # Bắt buộc điều này — không có ngoại lệ
            options={
                "require": ["exp", "iat", "sub"],  # Các claim bắt buộc
                "verify_exp": True,
            }
        )
        return payload
    except jwt.InvalidAlgorithmError:
        raise ValueError("Token sử dụng thuật toán không được phép")
    except jwt.ExpiredSignatureError:
        raise ValueError("Token đã hết hạn")
    except jwt.InvalidTokenError as e:
        raise ValueError(f"Token không hợp lệ: {e}")

Dù kẻ tấn công tạo token với alg: none, PyJWT 2.x vẫn ném ra InvalidAlgorithmError vì none không có trong whitelist. Đó là toàn bộ cơ chế phòng thủ — tường minh, fail-closed.

Ngăn chặn Key Confusion (Tấn công Algorithm Substitution)

Key Confusion tinh vi hơn. Nếu API của bạn dùng RS256 (chữ ký RSA), public key theo định nghĩa là công khai. Kẻ tấn công có thể tải về public key của bạn, đổi header token thành alg: HS256, và ký token giả mạo bằng public key đó như HMAC secret. Một verifier đơn giản dùng HS256 với public key làm secret sẽ chấp nhận token này là hợp lệ.

Chỉ whitelist thôi chưa đủ. Bạn còn cần các đường xác thực riêng biệt cho thuật toán đối xứng và bất đối xứng. Đừng xây dựng một helper verify(token, key, algorithm=None) tổng quát duy nhất với thuật toán là tham số đầu vào:

from cryptography.hazmat.primitives import serialization
import jwt
import time

with open("public.pem", "rb") as f:
    PUBLIC_KEY = serialization.load_pem_public_key(f.read())

with open("private.pem", "rb") as f:
    PRIVATE_KEY = serialization.load_pem_private_key(f.read(), password=None)

def create_rs256_token(user_id: str, expires_in: int = 900) -> str:
    payload = {
        "sub": user_id,
        "iat": int(time.time()),
        "exp": int(time.time()) + expires_in,
    }
    return jwt.encode(payload, PRIVATE_KEY, algorithm="RS256")

def verify_rs256_token(token: str) -> dict:
    # Chỉ "RS256" trong danh sách — HS256 không được phép ở đây
    return jwt.decode(token, PUBLIC_KEY, algorithms=["RS256"])

Hàm riêng biệt cho từng thuật toán. Hàm ký dùng private key với algorithm="RS256" được hardcode. Hàm xác thực dùng public key với algorithms=["RS256"] được hardcode. Không có đường code nào để hai cái bị trộn lẫn.

Triển khai Token Rotation An toàn

Access token nên có thời hạn ngắn — 15 phút là mặc định hợp lý cho hầu hết API. Refresh token có thể tồn tại lâu hơn, nhưng mỗi lần sử dụng phải thực hiện rotation. Khi refresh token được đổi lấy access token mới, cái cũ bị vô hiệu hóa ngay lập tức và cái mới được cấp. Nếu token bị đánh cắp được phát lại, lần refresh tiếp theo của người dùng hợp lệ sẽ thất bại. Thất bại đó chính là tín hiệu báo động.

Dưới đây là một rotation store tối giản dùng Redis với atomic delete để ngăn race condition:

import redis
import secrets
import time
import jwt

r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

REFRESH_TOKEN_TTL = 7 * 24 * 3600  # 7 ngày
ACCESS_TOKEN_TTL = 900              # 15 phút
SECRET_KEY = "your-256-bit-secret"

def issue_token_pair(user_id: str) -> dict:
    refresh_token = secrets.token_urlsafe(64)
    access_token = jwt.encode(
        {"sub": user_id, "exp": int(time.time()) + ACCESS_TOKEN_TTL},
        SECRET_KEY,
        algorithm="HS256"
    )
    r.setex(f"refresh:{refresh_token}", REFRESH_TOKEN_TTL, user_id)
    return {"access_token": access_token, "refresh_token": refresh_token}

def rotate_refresh_token(old_token: str) -> dict:
    user_id = r.get(f"refresh:{old_token}")
    if not user_id:
        # Token không tìm thấy — có thể là tái sử dụng token đã được rotation
        raise ValueError("Refresh token không hợp lệ hoặc đã được sử dụng")

    # Xóa token cũ atomically trước khi cấp token mới
    deleted = r.delete(f"refresh:{old_token}")
    if deleted == 0:
        raise ValueError("Phát hiện race condition trong quá trình token rotation")

    return issue_token_pair(user_id)

Một chi tiết quan trọng: r.delete() trả về số lượng key đã xóa. Nếu hai request đua nhau rotate cùng một token, chỉ một request nhận được deleted == 1. Request thứ hai nhận 0 và thất bại — không có double-use, không có bypass âm thầm.

Xác minh & Giám sát: Nhận biết khi có vấn đề xảy ra

Cấu hình một mình không đủ. Sau sáu tháng, thứ thực sự phát hiện các nỗ lực tấn công là logging và phát hiện bất thường xung quanh các lỗi liên quan đến token. Hầu hết các khai thác JWT thất bại nhanh chóng và rõ ràng nếu bạn theo dõi đúng các sự kiện.

Tối thiểu hãy log những điều này:

  • Lỗi algorithm mismatch — ai đó đang chủ động dò tìm None Algorithm hoặc Key Confusion
  • Sử dụng token hết hạn — có thể là clock drift, có thể là nỗ lực replay
  • Tái sử dụng refresh token — tín hiệu rõ ràng nhất của token bị đánh cắp đang được phát lại
  • Audience claim bất thường — token vượt qua ranh giới service mà không được phép
import logging

security_log = logging.getLogger("security.jwt")

def verify_with_audit(token: str, request_ip: str) -> dict:
    try:
        payload = decode_token(token)
        return payload
    except ValueError as e:
        msg = str(e)
        if "thuật toán không được phép" in msg:
            security_log.warning("Phát hiện tấn công algorithm từ %s", request_ip)
        elif "đã hết hạn" in msg:
            security_log.info("Token hết hạn được gửi từ %s", request_ip)
        elif "đã được sử dụng" in msg:
            security_log.critical(
                "Phát hiện tái sử dụng refresh token từ %s — có thể token bị đánh cắp",
                request_ip
            )
        raise

Đẩy các log này vào Elasticsearch, Loki, hoặc CloudWatch — bất cứ nơi nào team của bạn theo dõi. Thiết lập cảnh báo khi có hơn 3 sự kiện algorithm mismatch từ cùng một IP trong 10 phút. Đó không phải client cấu hình sai, đó là dò quét có chủ đích.

Một điều nữa trước khi triển khai: claim aud (audience). Nếu token của bạn vượt qua ranh giới service, token được cấp cho API hướng người dùng không nên được chấp nhận bởi API admin nội bộ:

payload = jwt.decode(
    token,
    SECRET_KEY,
    algorithms=["HS256"],
    audience="user-api"  # Từ chối token dành cho các service khác
)

Sau sáu tháng vận hành với thiết lập này — whitelist thuật toán tường minh, tách biệt RS256/HS256, rotation với Redis invalidation atomic, và logging sự kiện bảo mật — chúng tôi không có lần bypass xác thực JWT nào thành công. Chính pen tester đã phát hiện vấn đề None Algorithm ban đầu đã xác nhận cả ba vector tấn công đều đã được vá.

Các lỗ hổng không tinh vi. Các bản vá cũng vậy. Điều quan trọng là phải tường minh về mọi giả định mà code xác thực của bạn đưa ra, và log rõ ràng khi những giả định đó bị vi phạm.

Share: