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

GHSA-634G-4WR8-XWXV

A request with no `client` in its ASGI scope skips the entire pipeline, and nothing is logged

Sin parche publicado
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición85 dDesde la divulgación, 26 ago 2026, 2:49 p. m.
Detección85 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
26 ago 26
20 nov 26
26 ago 26
17 sept 26
8 oct 26
30 oct 26
20 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-634G-4WR8-XWXV divulgada
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés
Summary

`BypassHandler.handle_passthrough` (`guard_core/core/bypass/handler.py:18-20`):

if not request.client_host:
    response = await call_next(request)
    return await self.context.response_factory.apply_modifier(response)

`client` is optional in the ASGI spec. When it is absent, every check is
skipped - bans, rate limiting, IP lists, detection - with no log record, no
telemetry event, and no way for the operator to notice. `fail_secure=True`, the
default, does not cover this path.

Details

Servers and adapters that omit `client`: AWS Lambda and Azure Functions ASGI
adapters, Unix-domain-socket transports, several test harnesses, and any custom
ASGI shim that forwards a scope it built by hand. None of these are exotic - a
Lambda deployment is a normal way to run FastAPI.

The failure is quiet in both directions. Guard logs `Security pipeline
initialized with 14 checks` at startup exactly as it does in a working
deployment, and a `/_guard/status` probe reports everything ready.

PoC
class DropClient:                        # what a serverless adapter hands the app
    def __init__(self, inner): self.inner = inner
    async def __call__(self, scope, receive, send):
        if scope["type"] == "http":
            scope = dict(scope); scope.pop("client", None)
        return await self.inner(scope, receive, send)

Same app, `rate_limit=2/60s`, once with the scope intact and once through
`DropClient`:

rate limit 2/60s, scope['client'] present : [200, 200, 429, 429, 429]
rate limit 2/60s, scope['client'] absent  : [200, 200, 200, 200, 200]
SQLi probe (limit 100),  client present   : 400
SQLi probe (limit 100),  client absent    : 200
log records naming the missing client     : 0

Full script attached as `poc_missing_client.py`.

<details>
<summary><code>poc_missing_client.py</code></summary>

"""A request with no `client` in its ASGI scope skips every check, and logs nothing.

    uv run python docs/upstream-guard-core/followups/poc_missing_client.py

`BypassHandler.handle_passthrough` (guard_core/core/bypass/handler.py:18-20)
returns the downstream response as soon as `request.client_host` is falsy. The
ASGI spec makes `client` optional, so the trigger is a deployment detail, not an
attack: serverless adapters, Unix-socket transports and some test harnesses omit it.
"""

import logging
from importlib.metadata import version

from fastapi import FastAPI
from guard.middleware import SecurityMiddleware
from guard_core.models import SecurityConfig
from starlette.testclient import TestClient

CAPTURED: list[str] = []


class Capture(logging.Handler):
    def emit(self, record: logging.LogRecord) -> None:
        CAPTURED.append(f"{record.levelname} {record.name} {record.getMessage()}")


logging.getLogger().addHandler(Capture())
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger("guard_core").setLevel(logging.DEBUG)


def app(rate_limit: int = 2) -> FastAPI:
    application = FastAPI()
    application.add_middleware(
        SecurityMiddleware,
        config=SecurityConfig(enable_redis=False, rate_limit=rate_limit, rate_limit_window=60),
    )

    @application.get("/")
    async def root():
        return {"ok": True}

    return application


class DropClient:
    """What a serverless adapter or a Unix-socket transport hands the app."""

    def __init__(self, inner):
        self.inner = inner

    async def __call__(self, scope, receive, send):
        if scope["type"] == "http":
            scope = dict(scope)
            scope.pop("client", None)
        return await self.inner(scope, receive, send)


print(f"guard-core {version('guard-core')} / fastapi-guard {version('fastapi-guard')}")

with TestClient(app(), client=("203.0.113.9", 1)) as client:
    with_client = [client.get("/").status_code for _ in range(5)]
with TestClient(app(rate_limit=100), client=("203.0.113.8", 1)) as client:
    sqli_with = client.get("/", params={"q": "' OR 1=1 --"}).status_code

CAPTURED.clear()
with TestClient(DropClient(app())) as client:
    without_client = [client.get("/").status_code for _ in range(5)]
with TestClient(DropClient(app(rate_limit=100))) as client:
    sqli_without = client.get("/", params={"q": "' OR 1=1 --"}).status_code

print(f"  rate limit 2/60s, scope['client'] present : {with_client}")
print(f"  rate limit 2/60s, scope['client'] absent  : {without_client}")
print(f"  SQLi probe (limit 100),  client present   : {sqli_with}")
print(f"  SQLi probe (limit 100),  client absent    : {sqli_without}")

mentions = [line for line in CAPTURED if "client" in line.lower() and "scope" in line.lower()]
print(f"  log records naming the missing client    : {len(mentions)}")
print("  guard reports itself as enabled and initialised throughout; nothing in the")
print("  logs distinguishes this from a deployment where every check ran and passed.")

</details>

Impact

An application deployed behind an adapter that does not populate `client` runs
with guard-core installed, configured, reporting healthy, and enforcing nothing.
The operator has no signal. This is the failure mode that is worst to discover
during an incident, because the dashboard says the control is on.

Suggested fix

Treat a missing client as the identity `"unknown"` and run the pipeline against
it - detection and the IP lists work unchanged, and rate limiting degrades to a
shared bucket, which is the right answer when every request genuinely is
indistinguishable. At minimum, log once at WARNING on the first such request and
honour `fail_secure` on this path. Silently passing through is the one option
that should not be available.

Fixed in 3.14.0

Fixed in guard-core 3.14.0 https://github.com/rennf93/guard-core/releases/tag/3.14.0 (PyPI https://pypi.org/project/guard-core/3.14.0/), merged in #82 https://github.com/rennf93/guard-core/pull/82 (500d4ef6). A request with no client address is rejected (403) under `fail_secure=True`, the default, with a one-time warning naming the fix; under `fail_secure=False` it runs as the `unknown` identity, which is allowed only when no global `whitelist`, `whitelist_countries`, route `ip_whitelist` or route `whitelist_countries` is configured and can never match a blacklist or country block. A new `"unix"` token in `trusted_proxies` makes a peer-less connection a trusted hop so `X-Forwarded-For` resolves over Unix sockets. `UNKNOWN_CLIENT_IDENTITY` is exported from `guard_core.utils`. fastapi-guard 7.8.0 adopts the rule at the ASGI boundary.

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

Versiones

Rangos afectados

Afectada Corregida
guard-core≤ 3.13.0
3.13.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
PyPIguard-core
Sin parche — — —
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/guard-core/security/advisories/GHSA-634g-4wr8-xwxv

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