79% frente al 51%: los neobancos independientes quedan atrás en seguridad de aplicaciones. Leer el informe

Análisis a fondo

Análisis a fondo

Desbordamiento de pila RDMA en llama.cpp ggml-rpc (CVE-2026-118375)

llama.cpp anterior a b11865 copia hasta 256 KiB de RDMA en una variable de pila de 1 byte, y permite a un par remoto corromper el servidor RPC (9.2 Crítica).

Resumen

  • Una comprobación de límites ausente en la ruta de recepción RDMA de ggml-rpc copia hasta 256 KiB en una variable de pila de 1 byte.
  • El registro CVE enumera las compilaciones b8841 a b11864 de llama.cpp como afectadas. La corrección se publicó en b11865 el 2026-10-24.
  • El registro asigna a la falla una puntuación CVSS v4.0 9.2 Crítica. No se conoce explotación en entornos reales, y no está en el catálogo KEV de CISA al 2026-11-20.
  • Actualice a b11865 o posterior, o inicie el servidor RPC con GGML_RPC_NO_RDMA=1 mientras pueda.

¿Estoy afectado?

Todas estas condiciones deben cumplirse para que un despliegue esté expuesto:

  • Ejecuta una compilación de llama.cpp entre b8841 y b11864, o una compilación anterior que incluya el transporte RDMA.
  • La compilación activa el backend RPC y el transporte RDMA de Linux: GGML_RPC=ON, GGML_RPC_RDMA=ON, y libibverbs encontrado al configurar.
  • Un proceso ggml-rpc-server es accesible por un par no confiable por TCP, no solo desde localhost.
  • El servidor tiene un dispositivo RDMA, y el par puede completar un handshake RDMA con su propio par de colas.
Rama Versiones afectadas Versión corregida
llama.cpp b8841 a b11864 b11865

El registro empieza en b8841, la compilación que trasladó el transporte RPC a transport.cpp. La compilación inmediatamente anterior, b8840, contiene el mismo memcpy sin comprobar en ggml-rpc.cpp. El límite inferior marca el refactor, no un cambio en la seguridad del código, así que actualice cualquier compilación anterior a b11865 que tenga el transporte RDMA.

La etiqueta independiente ggml 0.27.0 todavía tiene el bucle vulnerable. La versión 0.28.0, publicada el 2026-10-28, incluye la comprobación.

RDMA se negocia durante HELLO. El servidor cambia a la ruta de recepción RDMA solo cuando ambos lados anuncian capacidades distintas de cero, así que una compilación solo TCP no alcanza esta falla.

El servidor escucha en 127.0.0.1:50052 por defecto e imprime una advertencia cuando el host no es 127.0.0.1. El README RPC del proyecto describe el backend como una prueba de concepto y pide no ejecutar nunca el servidor en una red abierta.

Compruebe la compilación y el transporte:

# Build number of the source checkout
git -C llama.cpp describe --tags --always

# Was the RPC backend and RDMA compiled in?
cmake -LA -N build | grep -E 'GGML_RPC(:BOOL|_RDMA:BOOL)'

# Does the server link an RDMA provider?
ldd build/bin/ggml-rpc-server | grep -E 'ibverbs|rdma'

# Is the server listening beyond loopback?
ss -lntp | grep ':50052'

El servidor RPC no imprime un número de compilación. El nombre del archivo de la versión, la versión del paquete o la copia del código fuente son la fuente fiable.

¿Cómo lo corrijo?

Actualice a llama.cpp b11865 o posterior y reinicie cada proceso del servidor RPC. La versión actual al 2026-11-20 es b12590.

  1. Actualice la copia del código fuente y recompile el servidor y sus clientes:
git -C llama.cpp fetch --tags
git -C llama.cpp checkout b12590
cmake -S llama.cpp -B build -DGGML_RPC=ON
cmake --build build --config Release
  1. Si usa binarios de versión, sustituya ggml-rpc-server en cada host RPC por el archivo b11865 o posterior, y reinicie el servicio.
  2. Si usa contenedores, descargue la nueva imagen y vuelva a crear el contenedor. Un reinicio por sí solo mantiene el binario anterior.
  3. Confirme que el nuevo proceso se ejecuta y que el puerto RPC sigue siendo accesible solo donde usted espera.

Si no puede actualizar todavía, desactive el transporte RDMA en el servidor:

  1. Inicie el servidor con RDMA desactivado:
GGML_RPC_NO_RDMA=1 ggml-rpc-server -H 127.0.0.1 -p 50052
  1. O recompile con -DGGML_RPC_RDMA=OFF.
  2. Mantenga el puerto RPC en loopback o en una red de confianza. El protocolo no tiene autenticación, así que el aislamiento de red es el único control de acceso.

La solución alternativa elimina la ruta de recepción RDMA, así que el memcpy vulnerable no se alcanza. Renuncia a la latencia y al rendimiento de RDMA, y no corrige otros problemas de RPC.

La corrección es el commit 9a0fde9 de la solicitud de extracción #30399.

¿Cuál es la causa raíz?

La función de recepción RDMA copia una completación de wc.byte_len bytes en el búfer del llamador sin comprobar que la completación quepa en ese búfer. Cuando el llamador pide 1 byte, una completación de hasta 256 KiB desborda la variable de pila de 1 byte. El contador de bytes restantes da la vuelta.

ggml-rpc es el transporte que permite a un proceso de llama.cpp usar dispositivos de otra máquina. Un cliente envía tensores y comandos de grafo a ggml-rpc-server, y el servidor los ejecuta en su GPU o CPU local. En Linux, el transporte puede pasar de TCP a RDMA sobre RoCE o InfiniBand después del handshake HELLO.

El bucle de recepción está en ggml/src/ggml-rpc/transport.cpp:440-453 en la etiqueta b8841:

bool socket_t::impl::rdma_recv(void * data, size_t size) {
    rdma_conn * c = rdma.get();
    uint8_t * dst = (uint8_t *)data;
    size_t rem = size;
    while (rem > 0) {
        struct ibv_wc wc;
        if (!rdma_poll(c->rcq, &wc)) return false;

        int slot = (int)wc.wr_id;
        size_t got = wc.byte_len;
        memcpy(dst, c->rx_slot(slot), got);

        if (!c->post_rx(slot)) return false;

        dst += got;
        rem -= got;
    }
    return true;
}

data y size son el búfer del llamador y el número exacto de bytes que espera. rem sigue cuántos bytes faltan. rdma_poll devuelve una completación de la cola de recepción. wc.byte_len es la longitud del mensaje que envió el par remoto, no la longitud que pidió el llamador.

El memcpy usa got sin compararlo con rem. Después, dst += got mueve el puntero de escritura más allá del búfer del llamador. rem -= got da la vuelta a un valor enorme cuando got es mayor que rem.

El llamador es la primera lectura del bucle de comandos RPC en ggml/src/ggml-rpc/ggml-rpc.cpp:2437-2438:

uint8_t cmd;
if (!sock->recv_data(&cmd, 1)) {
    return;
}

cmd es un solo byte en la pila. recv_data pasa a rdma_recv cuando la conexión se actualizó, así que size es 1 mientras la completación puede ser de 256 KiB. Cada ranura de recepción tiene RDMA_CHUNK bytes, y RDMA_CHUNK es 256 * 1024.

La actualización la decide la solicitud HELLO. rpc_msg_hello_req transporta un bloque de capacidades de 24 bytes: un número de par de colas, un número de secuencia de paquetes y un GID de 16 bytes. Un par que pone esos campos a valores distintos de cero hace que el servidor llame a rdma_activate y cambie recv_data a la ruta RDMA.

¿Cómo se explota?

Un atacante que puede alcanzar un servidor RPC con RDMA completa el handshake HELLO con capacidades distintas de cero. Después envía una completación mayor que el búfer de comando de 1 byte.

  1. Alcance el puerto TCP del servidor RPC. El endpoint por defecto es 127.0.0.1:50052. Un despliegue que escucha en -H 0.0.0.0 o en una dirección enrutable lo expone a la red.
  2. Envíe un HELLO con capacidades RDMA distintas de cero. El cliente envía el comando 14, el tamaño de 8 bytes de la solicitud HELLO (24), y un bloque de capacidades de 24 bytes. Ese bloque contiene un número de par de colas real, un número de secuencia de paquetes y un GID.
  3. Deje que el servidor active su par de colas. update_caps lleva el par de colas del servidor a los estados listo para recibir y listo para enviar con los valores del atacante.
  4. Envíe una completación RDMA SEND de hasta 256 KiB. El anillo de recepción del servidor tiene 24 ranuras de 256 KiB cada una, y una sola basta.
  5. La siguiente lectura recv_data(&cmd, 1) copia toda la completación en el cmd de 1 byte. La pila se sobrescribe antes de cualquier comprobación.
  6. El servidor se bloquea, o continúa con un estado de pila corrupto. El contador de bytes restantes da la vuelta, así que el bucle no se detiene después de la primera copia.

El autor de la corrección reprodujo el desbordamiento con AddressSanitizer en un dispositivo SoftRoCE. Enviar más de 1 byte para cmd producía un stack-buffer-overflow en memcpy sin la comprobación. Con la comprobación, la conexión se cierra limpiamente.

SoftRoCE (rxe) es un proveedor RDMA por software del núcleo de Linux, así que un atacante no necesita una tarjeta RoCE física. El servidor sigue necesitando un dispositivo RDMA.

¿Cómo se desarrolla el ataque?

Un atacante que puede alcanzar un servidor RPC con RDMA anuncia RDMA en HELLO y envía una completación de 256 KiB. La copia sin comprobar desborda entonces la variable de comando de 1 byte en la pila del servidor.

flowchart LR A["El atacante alcanza el puerto RPC"] --> B["HELLO anuncia capacidades RDMA distintas de cero"] B --> C["El servidor activa su par de colas RDMA"] C --> D["El atacante envía una completación de 256 KiB"] D --> E["rdma_recv copia wc.byte_len en un cmd de 1 byte"] E --> F["Sin comprobación de límites: desbordamiento de pila"] F --> G["El servidor se bloquea o se corrompe la memoria de pila"]

¿Qué puede hacer un atacante?

Una sola completación puede bloquear el servidor RPC, lo que corta a todos los clientes que dependen de sus dispositivos remotos.

La sobrescritura la controla el atacante y puede llegar a 256 KiB. El registro CVE dice que puede ejecutar código potencialmente en el proceso del servidor. Ningún exploit público demuestra ejecución de código.

Una ejecución de código se ejecutaría con los privilegios del servidor RPC. El servidor puede acceder a los dispositivos de aceleración que expone y a la caché local con la que se inició.

Todas las condiciones de «¿Estoy afectado?» se aplican aquí en su totalidad. Hace falta una compilación con RDMA, un servidor con RDMA, un par con RDMA, accesibilidad de red y un servidor que escucha más allá de loopback. El protocolo no tiene autenticación, así que cualquier par que pueda conectarse puede intentar el handshake.

El impacto demostrado es un desbordamiento de búfer en la pila y un bloqueo. La ejecución de código es potencial, no demostrada.

¿Por qué funciona la corrección?

La corrección rechaza una completación mayor que el búfer restante del llamador antes de la copia, así que la escritura en la pila nunca ocurre.

La corrección, tomada de transport.cpp en b11865:

         int slot = (int)wc.wr_id;
         size_t got = wc.byte_len;
+        if (got > rem) {
+            LOG_ERROR("RDMA recv overrun: got=%zu rem=%zu\n", got, rem);
+            c->post_rx(slot);
+            return false;
+        }
         memcpy(dst, c->rx_slot(slot), got);

         if (!c->post_rx(slot)) return false;

rem es el número exacto de bytes que todavía se esperan. got > rem significa que la completación es mayor que el búfer del llamador. La comprobación se ejecuta antes de memcpy, así que la copia nunca ocurre.

Vuelve a publicar la ranura para que el anillo de recepción no se agote cuando se rechaza la conexión. Devuelve falso, así que recv_data falla y rpc_serve_client retorna, lo que cierra la conexión.

La comprobación es completa para esta función en Linux. Toda recepción RDMA pasa por rdma_recv, y la ruta TCP lee exactamente el tamaño solicitado. La corrección no cambia el protocolo ni el handshake. Un servidor corregido sigue aceptando pares RDMA y sigue rechazando una completación mayor que el búfer del llamador.

¿Cómo compruebo si estuve comprometido?

Empiece por las comprobaciones de exposición y bloqueo, y después revise el registro del servidor para la actualización a RDMA.

# Was the server reachable beyond loopback?
ss -lntp | grep ':50052'

# Did the process crash? (systemd-coredump)
coredumpctl list ggml-rpc-server

# Did the server negotiate RDMA? This is a normal log line, not an attack indicator.
journalctl -u ggml-rpc-server | grep 'RDMA activated'

No se publican indicadores de compromiso públicos para CVE-2026-118375. Una línea RDMA activated muestra que el servidor tomó la ruta vulnerable al menos una vez. No prueba un ataque. Un bloqueo justo después de una conexión entrante es una pista. Una sola completación sobredimensionada puede no dejar ningún otro rastro.

Si el servidor nunca negoció RDMA, la ruta de recepción vulnerable no se usó. Revise los registros anteriores a la actualización.

Cronología

  • 2026-04-19: se publica llama.cpp b8841, y el transporte RPC pasa a transport.cpp.
  • 2026-10-12: Sohaib Harraoui abre la solicitud de extracción de corrección #30399.
  • 2026-10-24: la solicitud de extracción #30399 se fusiona en el commit 9a0fde9, y se publica b11865.
  • 2026-10-28: se publica CVE-2026-118375, y se publica ggml 0.28.0.
  • 2026-11-03: CISA publica su evaluación Vulnrichment: Exploitation none, Automatable no, Technical Impact total.
  • 2026-11-20: se comprueba el catálogo KEV 2026.11.18 de CISA, y no tiene ninguna entrada para el CVE.

La primera compilación afectada, la corrección y la divulgación abarcan 188 días
Figura 1: De b8841 a la corrección en 188 días. Fuente: versiones de llama.cpp, solicitud de extracción #30399 y registro CVE, comprobados el 20 de noviembre de 2026.

Preguntas frecuentes

¿CVE-2026-118375 afecta a llama-server o solo a ggml-rpc-server?

El listener vulnerable es ggml-rpc-server. llama-server y llama-cli son clientes que se conectan a él con --rpc. Si ejecuta llama-server sin un backend RPC, no expone este listener.

¿RDMA está activado por defecto?

Sí, en Linux, cuando CMake encuentra libibverbs al configurar. La opción GGML_RPC_RDMA vale ON por defecto en ese caso. El transporte se negocia en HELLO, así que ambos pares deben admitir RDMA para que la conexión se actualice.

¿Puede un atacante explotarlo por TCP simple?

No, esta falla está en la ruta de recepción RDMA. El bucle recv_data de TCP lee exactamente el número de bytes solicitado. El protocolo RPC sigue sin autenticación, así que otros riesgos permanecen en una conexión TCP.

¿Un protector de pila detiene el ataque?

Un canario de pila puede convertir la sobrescritura en un aborto, pero el memcpy se ejecuta antes de la comprobación del canario. No impide el desbordamiento. Que el proceso aborte o que el estado corrupto sea explotable depende de la compilación y de la disposición de la memoria.

¿CVE-2026-118375 está explotado en entornos reales?

No se conoce explotación en entornos reales al 2026-11-20. El registro Vulnrichment de CISA dice Exploitation none y Automatable no, y el CVE no está en el catálogo KEV de CISA.

¿Qué hago si no puedo actualizar de inmediato?

Defina GGML_RPC_NO_RDMA=1 en el servidor y reinícielo, o recompile con -DGGML_RPC_RDMA=OFF. Mantenga el puerto RPC en loopback o en una red de confianza hasta que instale b11865 o posterior.

Encuentre las compilaciones vulnerables de llama.cpp con Ostorlab

Sohaib Harraoui encontró y corrigió esta falla, y el análisis de composición de software de Ostorlab inventaría los componentes de código abierto y sus versiones en sus repositorios, para que pueda encontrar las compilaciones de llama.cpp y ggml anteriores a b11865. Empiece en Ostorlab SCA y SBOM.

Referencias

  • Registro CVE-2026-118375, VulnCheck: https://www.cve.org/CVERecord?id=CVE-2026-118375 (comprobado el 20 de noviembre de 2026)
  • Solicitud de extracción de corrección #30399 de llama.cpp, «rpc : add bounds check in rdma_recv»: https://github.com/ggml-org/llama.cpp/pull/30399 (comprobada el 20 de noviembre de 2026)
  • Commit de corrección 9a0fde9967fa1a35b6e5dd1f47e1a3648b6fecc1: https://github.com/ggml-org/llama.cpp/commit/9a0fde9967fa1a35b6e5dd1f47e1a3648b6fecc1 (comprobado el 20 de noviembre de 2026)
  • Notas de la versión b11865 de llama.cpp: https://github.com/ggml-org/llama.cpp/releases/tag/b11865 (comprobadas el 20 de noviembre de 2026)
  • Notas de la versión b8841 de llama.cpp: https://github.com/ggml-org/llama.cpp/releases/tag/b8841 (comprobadas el 20 de noviembre de 2026)
  • rdma_recv vulnerable en b8841: https://github.com/ggml-org/llama.cpp/blob/b8841/ggml/src/ggml-rpc/transport.cpp (comprobado el 20 de noviembre de 2026)
  • La misma copia sin comprobar en b8840: https://github.com/ggml-org/llama.cpp/blob/b8840/ggml/src/ggml-rpc/ggml-rpc.cpp (comprobado el 20 de noviembre de 2026)
  • rdma_recv corregido en b11865: https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/transport.cpp (comprobado el 20 de noviembre de 2026)
  • Bucle de comandos RPC en b11865: https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/ggml-rpc.cpp (comprobado el 20 de noviembre de 2026)
  • Capacidades del transporte RPC en b11865: https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/transport.h (comprobadas el 20 de noviembre de 2026)
  • Opciones de compilación RPC en b11865: https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/CMakeLists.txt (comprobadas el 20 de noviembre de 2026)
  • Código del servidor RPC y endpoint por defecto en b11865: https://github.com/ggml-org/llama.cpp/blob/b11865/tools/rpc/rpc-server.cpp (comprobados el 20 de noviembre de 2026)
  • README RPC, con la sección RDMA y la advertencia: https://github.com/ggml-org/llama.cpp/blob/b11865/tools/rpc/README.md (comprobado el 20 de noviembre de 2026)
  • Versión ggml 0.28.0: https://github.com/ggml-org/ggml/releases/tag/v0.28.0 (comprobada el 20 de noviembre de 2026)
  • Repositorio de llama.cpp, 135,844 estrellas el 2026-11-20: https://github.com/ggml-org/llama.cpp (comprobado el 20 de noviembre de 2026)
  • Catálogo Known Exploited Vulnerabilities de CISA, versión 2026.11.18: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (comprobado el 20 de noviembre de 2026)