Http Request Smuggling in Fastapi with Firestore

HTTP request smuggling occurs when an attacker can cause an upstream and downstream server to interpret request boundaries differently. In a Fastapi application that uses Firestore as a backend datastore, the framework and the Firestore client library do not directly implement HTTP proxying or normalization. However, if Fastapi is placed behind a load balancer, API gateway, or a reverse proxy that also terminates TLS or modifies headers, the interaction between Fastapi and Firestore can become relevant to smuggling risks.

Consider a scenario where requests are first handled by a gateway that buffers or re-encodes HTTP messages before forwarding them to Fastapi. If Fastapi reads the request body differently than the gateway—for example, relying on request.body() after the gateway has already consumed or partially consumed the stream—the boundary assumptions may diverge. Firestore operations in Fastapi typically involve deserializing JSON bodies into Pydantic models for document writes. If smuggling alters which bytes are considered part of the request body, the Firestore write may receive truncated or duplicated data, leading to inconsistent state or authorization bypasses.

Specifically, an attacker might craft a request where the Content-Length and Transfer-Encoding headers are both present but inconsistent. A gateway parsing Transfer-Encoding: chunked while Fastapi interprets the body based on Content-Length can cause one request to be split across two backend requests. If the first request creates a document in Firestore and the second request (smuggled) attempts to read or modify that document based on attacker-controlled logic, this can result in privilege escalation or data exposure.

Because Fastapi does not inherently normalize these headers, developers must ensure consistent parsing at the edge. Firestore-specific concerns arise when the smuggled request triggers unintended document creation or updates, potentially bypassing intended validations. For instance, a document write that should require a specific role might be processed without proper checks if the request context is altered by the smuggling discrepancy.

In practice, mitigating this requires aligning how requests are interpreted across all layers between the client and Firestore. Since middleBrick scans the unauthenticated attack surface, it can flag inconsistencies in how headers are handled and highlight endpoints that perform Firestore writes based on raw, unvalidated input.

To reduce the risk of request smuggling when Fastapi interacts with Firestore, enforce strict header parsing and input validation before any database operations. Below are concrete code examples that demonstrate secure patterns.

1. Normalize and reject inconsistent headers

Ensure that Fastapi rejects requests that contain both Content-Length and Transfer-Encoding. Use an endpoint dependency to validate headers before constructing Firestore documents.

from fastapi import FastAPI, Request, Depends, HTTPException
from google.cloud import firestore

app = FastAPI()
db = firestore.Client()

def validate_no_smuggling(request: Request):
    if request.headers.get("content-length") and request.headers.get("transfer-encoding"):
        raise HTTPException(status_code=400, detail="Conflicting transfer encodings; request rejected")

@app.post("/items/")
async def create_item(request: Request, payload: dict, validate=Depends(validate_no_smuggling)):
    # Safe to proceed with Firestore write
    doc_ref = db.collection("items").add(payload)
    return {"id": doc_ref[1].id}

2. Explicitly read the request body once and enforce strict content handling

Read the body in a streaming-aware manner and avoid mixing high-level convenience methods that may interpret the body differently across layers.

from fastapi import FastAPI, Request
from google.cloud import firestore
import json

app = FastAPI()
db = firestore.Client()

@app.post("/records/")
async def ingest_record(request: Request):
    body = await request.body()
    try:
        data = json.loads(body)
    except json.JSONDecodeError:
        raise HTTPException(status_code=400, detail="Invalid JSON")

    # Validate required fields before writing to Firestore
    if "user_id" not in data or "value" not in data:
        raise HTTPException(status_code=400, detail="Missing required fields")

    # Write to Firestore with explicit document ID or auto-ID
    doc_ref = db.collection("records").document(data["user_id"]).set(data)
    return {"status": "written"}

3. Use Firestore transactions for consistency when multiple operations are involved

If the smuggling risk could lead to partial writes, use transactions to ensure atomicity. This does not prevent smuggling at the HTTP layer but reduces the impact on Firestore state.

from google.cloud import firestore

async def safe_update(user_id: str, updates: dict):
    db = firestore.Client()
    doc_ref = db.collection("entities").document(user_id)
    async with db.transaction() as transaction:
        snapshot = await transaction.get(doc_ref)
        if not snapshot.exists:
            raise ValueError("Document does not exist")
        transaction.update(doc_ref, updates)
    return {"ok": True}

4. Enforce consistent Content-Type and reject ambiguous payloads

Require application/json and avoid accepting multiple content types that may be parsed differently by proxies and Fastapi.

from fastapi import FastAPI, Request, Depends, HTTPException

app = FastAPI()

def enforce_json_content_type(request: Request):
    ct = request.headers.get("content-type", "")
    if ct != "application/json":
        raise HTTPException(status_code=415, detail="Content-Type must be application/json")

@app.put("/profile/{user_id}")
async def update_profile(user_id: str, request: Request, validate=Depends(enforce_json_content_type)):
    body = await request.body()
    data = json.loads(body)
    # Proceed with Firestore update
    db = firestore.Client()
    db.collection("profiles").document(user_id).set(data, merge=True)
    return {"status": "updated"}

5. Validate and sanitize Firestore document IDs to prevent injection via smuggling

If the smuggling attack manipulates URL paths or document IDs, enforce strict allow-lists or patterns before using them in Firestore lookups.

import re
from google.cloud import firestore
from fastapi import HTTPException

ID_PATTERN = re.compile(r"^[a-zA-Z0-9_-]{1,100}$")

def get_document_safe(doc_id: str):
    if not ID_PATTERN.match(doc_id):
        raise HTTPException(status_code=400, detail="Invalid document ID")
    db = firestore.Client()
    doc = db.collection("items").document(doc_id).get()
    if not doc.exists:
        raise HTTPException(status_code=404, detail="Not found")
    return doc.to_dict()