Beast Attack in Fastapi with Jwt Tokens

A Beast Attack (short for Browser Exploit Against SSL/TLS) is a TLS-side channel that can leak information when an attacker can inject chosen plaintexts into an encrypted request and observe the length of the resulting ciphertext. While the classic BEAST targets CBC-mode TLS, a FastAPI application using JWT tokens can still be exposed through a related client-side vector when the application reflects attacker-controlled input into authenticated requests. For example, if your FastAPI endpoint accepts a user-supplied path or parameter and includes it inside the authenticated request flow (e.g., calling a downstream service with the caller’s JWT), an attacker can craft URLs or form data that influence the size of the authenticated request body or headers. Because JWT tokens often carry claims that affect serialization size (such as roles, scopes, or session identifiers), the length of the protected request can vary with attacker-controlled data, creating a measurable side channel. In a black-box scan, middleBrick tests such input validation and property authorization to detect whether authenticated endpoints reflect client-supplied data in ways that could enable length-based inference. Even when TLS is properly configured, this reflects a design issue where JWT-bound workflows inadvertently expose data-dependent behavior to an unauthenticated attacker who can influence authenticated request characteristics.

Remediation focuses on ensuring that JWT token content and request paths do not reflect attacker-controlled input, and that authenticated endpoints do not vary their behavior in ways that expose size differences an attacker can measure. Below are concrete FastAPI patterns and code examples to reduce risk.

1. Avoid reflecting attacker-controlled data in authenticated requests

Do not build request paths, headers, or bodies by concatenating user input with values derived from the JWT. Instead, validate and sanitize any user input before using it in authenticated downstream calls.

from fastapi import FastAPI, Depends, HTTPException, Header
from pydantic import BaseModel
import httpx

app = FastAPI()

class Payload(BaseModel):
    data: str

def get_current_user_token(authorization: str = Header(...)) -> str:
    # Simplified JWT extraction; in production use a validated library
    if not authorization.startswith("Bearer "):
        raise HTTPException(status_code=401, detail="Invalid authorization header")
    return authorization[7:]

@app.post("/safe-forward")
async def safe_forward(
    payload: Payload,
    authorization: str = Header(...),
):
    user_token = get_current_user_token(authorization)
    # Sanitize user input before using in URLs or headers
    safe_data = payload.data.replace("..", "").strip()
    async with httpx.AsyncClient() as client:
        # Do not build URLs by string interpolation with user data
        response = await client.post(
            "https://internal-api.example.com/forward",
            headers={"Authorization": f"Bearer {user_token}", "X-Original-Data": safe_data},
            json={"data": safe_data},
            timeout=5.0,
        )
    return {"status": response.status_code}

2. Normalize JWT claims to reduce size variability

If your JWT includes dynamic claims that change size (such as lists of roles or scopes), consider normalizing or omitting them from tokens used in size-sensitive contexts. Use a consistent serialization policy and avoid embedding large or variable-length data in the token when possible.

from datetime import datetime, timedelta
from typing import List
from fastapi import Depends
from jose import jwt

SECRET_KEY = "your-secret-key"
ALGORITHM = "HS256"

def create_token(user_id: str, roles: List[str]) -> str:
    to_encode = {
        "sub": user_id,
        "roles": roles,
        "exp": datetime.utcnow() + timedelta(hours=1),
        # Keep payload compact; avoid variable-length metadata that reflects user input
    }
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

def decode_token(token: str) -> dict:
    return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])

3. Enforce strict input validation and size limits

Apply strict validation and length limits on any data that flows into authenticated request paths. This reduces variability in ciphertext length and prevents injection of payloads designed to influence serialization size.

from fastapi import Query
from pydantic import constr

# Example: limit and sanitize path and query parameters
@app.get("/items/{item_id}")
async def read_item(
    item_id: constr(regex=r"^[a-zA-Z0-9_-]{1,64}$"),  # strict pattern
    q: constr(max_length=100) = Query(None),
):
    return {"item_id": item_id, "q": q}

4. Use middleware to audit and normalize authenticated request characteristics

Instrument request processing to ensure authenticated requests do not vary in size based on attacker-influenced parameters. Log and monitor size differences for anomalies without exposing them to the client.

from fastapi import Request
from starlette.middleware.base import BaseHTTPMiddleware

class JwtSizeAuditMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # Inspect incoming request and authenticated context here if needed
        response = await call_next(request)
        # Avoid returning variable-sized details influenced by user input
        return response

app.add_middleware(JwtSizeAuditMiddleware)