79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

Débordement de pile RDMA dans llama.cpp ggml-rpc (CVE-2026-118375)

llama.cpp avant b11865 copie jusqu'à 256 Kio de RDMA dans une variable de pile d'un octet, permettant à un pair de corrompre le serveur RPC (9,2 Critique).

En bref

  • Une vérification des limites absente dans le chemin de réception RDMA de ggml-rpc copie jusqu'à 256 Kio dans une variable de pile d'un octet.
  • La fiche CVE liste les versions b8841 à b11864 de llama.cpp comme concernées. Le correctif est sorti dans b11865 le 2026-10-24.
  • La fiche attribue à la faille un score CVSS v4.0 de 9,2 Critique. Aucune exploitation en conditions réelles n'est connue, et elle n'est pas dans le catalogue KEV de la CISA au 2026-11-20.
  • Mettez à niveau vers b11865 ou une version ultérieure, ou démarrez le serveur RPC avec GGML_RPC_NO_RDMA=1 en attendant.

Suis-je concerné ?

Toutes ces conditions doivent être réunies pour qu'un déploiement soit exposé :

  • Vous exécutez une version de llama.cpp comprise entre b8841 et b11864, ou une version plus ancienne qui embarque le transport RDMA.
  • La compilation active le backend RPC et le transport RDMA Linux : GGML_RPC=ON, GGML_RPC_RDMA=ON, et libibverbs trouvé à la configuration.
  • Un processus ggml-rpc-server est joignable par un pair non fiable sur TCP, pas seulement depuis localhost.
  • Le serveur dispose d'un périphérique RDMA, et le pair peut terminer une poignée de main RDMA avec sa propre paire de files.
Branche Versions concernées Version corrigée
llama.cpp b8841 à b11864 b11865

La fiche commence à b8841, la version qui a déplacé le transport RPC dans transport.cpp. La version immédiatement précédente, b8840, contient le même memcpy non vérifié dans ggml-rpc.cpp. La borne basse marque le remaniement, pas un changement de sûreté du code, donc mettez à niveau toute version antérieure à b11865 qui utilise le transport RDMA.

L'étiquette ggml 0.27.0 autonome contient encore la boucle vulnérable. La version 0.28.0, sortie le 2026-10-28, contient la vérification.

RDMA est négocié pendant HELLO. Le serveur passe au chemin de réception RDMA seulement lorsque les deux côtés annoncent des capacités non nulles, donc une compilation TCP seule n'atteint pas cette faille.

Le serveur écoute sur 127.0.0.1:50052 par défaut et affiche un avertissement lorsque l'hôte n'est pas 127.0.0.1. Le README RPC du projet qualifie le backend de preuve de concept et indique de ne jamais exécuter le serveur sur un réseau ouvert.

Vérifiez la version et le transport :

# 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'

Le serveur RPC n'affiche pas de numéro de compilation. Le nom de l'archive de version, la version du paquet ou la copie du code source sont les sources fiables.

Comment corriger ?

Mettez à niveau vers llama.cpp b11865 ou une version ultérieure et redémarrez chaque processus serveur RPC. La version actuelle au 2026-11-20 est b12590.

  1. Mettez à jour la copie du code source et recompilez le serveur et ses clients :
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 vous utilisez des binaires de version, remplacez ggml-rpc-server sur chaque hôte RPC par l'archive b11865 ou ultérieure, puis redémarrez le service.
  2. Si vous utilisez des conteneurs, téléchargez la nouvelle image et recréez le conteneur. Un simple redémarrage conserve l'ancien binaire.
  3. Confirmez que le nouveau processus tourne et que le port RPC reste joignable uniquement là où vous l'attendez.

Si vous ne pouvez pas encore mettre à niveau, désactivez le transport RDMA sur le serveur :

  1. Démarrez le serveur avec RDMA désactivé :
GGML_RPC_NO_RDMA=1 ggml-rpc-server -H 127.0.0.1 -p 50052
  1. Ou recompilez avec -DGGML_RPC_RDMA=OFF.
  2. Gardez le port RPC sur la boucle locale ou un réseau de confiance. Le protocole n'a pas d'authentification, donc l'isolation réseau est le seul contrôle d'accès.

La solution de contournement supprime le chemin de réception RDMA, donc le memcpy vulnérable n'est pas atteint. Elle sacrifie la latence et le débit de RDMA, et elle ne corrige pas les autres problèmes RPC.

Le correctif est le commit 9a0fde9 de la demande de fusion #30399.

Quelle est la cause racine ?

La fonction de réception RDMA copie une complétion de wc.byte_len octets dans le tampon de l'appelant sans vérifier que la complétion tient dans ce tampon. Lorsque l'appelant demande 1 octet, une complétion de jusqu'à 256 Kio déborde la variable de pile d'un octet et fait passer sous zéro le compteur d'octets restants.

ggml-rpc est le transport qui permet à un processus llama.cpp d'utiliser les périphériques d'une autre machine. Un client envoie des tenseurs et des commandes de graphe à ggml-rpc-server, et le serveur les exécute sur son GPU ou son CPU local. Sous Linux, le transport peut passer de TCP à RDMA sur RoCE ou InfiniBand après la poignée de main HELLO.

La boucle de réception se trouve dans ggml/src/ggml-rpc/transport.cpp:440-453 à l'étiquette 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 et size sont le tampon de l'appelant et le nombre exact d'octets qu'il attend. rem suit le nombre d'octets encore manquants. rdma_poll renvoie une complétion de la file de réception. wc.byte_len est la longueur du message envoyé par le pair distant, pas la longueur demandée par l'appelant.

Le memcpy utilise got sans le comparer à rem. Ensuite, dst += got déplace le pointeur d'écriture au-delà du tampon de l'appelant. rem -= got revient à une valeur énorme lorsque got est plus grand que rem.

L'appelant est la première lecture de la boucle de commandes RPC dans ggml/src/ggml-rpc/ggml-rpc.cpp:2437-2438 :

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

cmd est un seul octet sur la pile. recv_data passe à rdma_recv lorsque la connexion a été mise à niveau, donc size vaut 1 alors que la complétion peut faire 256 Kio. Chaque emplacement de réception fait RDMA_CHUNK octets, et RDMA_CHUNK vaut 256 * 1024.

La mise à niveau est décidée par la requête HELLO. rpc_msg_hello_req transporte un bloc de capacités de 24 octets : un numéro de paire de files, un numéro de séquence de paquets et un GID de 16 octets. Un pair qui met ces champs à des valeurs non nulles fait appeler rdma_activate au serveur et basculer recv_data vers le chemin RDMA.

Comment la faille est-elle exploitée ?

Un attaquant qui peut joindre un serveur RPC compatible RDMA termine la poignée de main HELLO avec des capacités non nulles. Il envoie ensuite une complétion plus grande que le tampon de commande d'un octet.

  1. Atteignez le port TCP du serveur RPC. Le point de terminaison par défaut est 127.0.0.1:50052. Un déploiement qui écoute sur -H 0.0.0.0 ou une adresse routable l'expose au réseau.
  2. Envoyez un HELLO avec des capacités RDMA non nulles. Le client envoie la commande 14, la taille de 8 octets de la requête HELLO (24), et un bloc de capacités de 24 octets. Ce bloc contient un vrai numéro de paire de files, un numéro de séquence de paquets et un GID.
  3. Laissez le serveur activer sa paire de files. update_caps place la paire de files du serveur dans les états prêts à recevoir et prêts à envoyer avec les valeurs de l'attaquant.
  4. Envoyez une complétion RDMA SEND de jusqu'à 256 Kio. L'anneau de réception du serveur compte 24 emplacements de 256 Kio chacun, et un seul suffit.
  5. La lecture suivante recv_data(&cmd, 1) copie toute la complétion dans le cmd d'un octet. La pile est écrasée avant toute vérification.
  6. Le serveur plante, ou continue avec un état de pile corrompu. Le compteur d'octets restants passe sous zéro, donc la boucle ne s'arrête pas après la première copie.

L'auteur du correctif a reproduit le débordement avec AddressSanitizer sur un périphérique SoftRoCE. Envoyer plus d'un octet pour cmd produisait un stack-buffer-overflow dans memcpy sans la vérification. Avec la vérification, la connexion se ferme proprement.

SoftRoCE (rxe) est un fournisseur RDMA logiciel du noyau Linux, donc un attaquant n'a pas besoin d'une carte RoCE physique. Le serveur a toujours besoin d'un périphérique RDMA.

Comment se déroule l'attaque ?

Un attaquant qui peut joindre un serveur RPC compatible RDMA annonce RDMA dans HELLO et envoie une complétion de 256 Kio. La copie non vérifiée déborde alors la variable de commande d'un octet sur la pile du serveur.

flowchart LR A["L'attaquant atteint le port RPC"] --> B["HELLO annonce des capacités RDMA non nulles"] B --> C["Le serveur active sa paire de files RDMA"] C --> D["L'attaquant envoie une complétion de 256 Kio"] D --> E["rdma_recv copie wc.byte_len dans un cmd d'un octet"] E --> F["Aucune vérification des limites : débordement de pile"] F --> G["Le serveur plante ou la mémoire de pile est corrompue"]

Que peut faire un attaquant ?

Une seule complétion peut faire planter le serveur RPC, ce qui coupe tous les clients qui dépendent de ses périphériques distants.

L'écrasement est contrôlé par l'attaquant et peut atteindre 256 Kio. La fiche CVE indique qu'il peut potentiellement exécuter du code dans le processus serveur. Aucun exploit public ne démontre d'exécution de code.

Une exécution de code s'exécuterait avec les privilèges du serveur RPC. Le serveur peut accéder aux périphériques d'accélération qu'il expose et au cache local avec lequel il a démarré.

Toutes les conditions de « Suis-je concerné ? » s'appliquent ici intégralement. Il faut une compilation compatible RDMA, un serveur compatible RDMA, un pair compatible RDMA, une accessibilité réseau et un serveur qui écoute au-delà de la boucle locale. Le protocole n'a pas d'authentification, donc tout pair qui peut se connecter peut tenter la poignée de main.

L'impact démontré est un débordement de tampon sur la pile et un plantage. L'exécution de code est potentielle, pas démontrée.

Pourquoi le correctif fonctionne-t-il ?

Le correctif rejette une complétion plus grande que le tampon restant de l'appelant avant la copie, donc l'écriture sur la pile n'a jamais lieu.

Le correctif, extrait de transport.cpp à 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 est le nombre exact d'octets encore attendus. got > rem signifie que la complétion est plus grande que le tampon de l'appelant. La vérification s'exécute avant memcpy, donc la copie n'a jamais lieu. Elle republie l'emplacement pour que l'anneau de réception ne soit pas épuisé lorsque la connexion est rejetée. Elle renvoie faux, donc recv_data échoue et rpc_serve_client retourne, ce qui ferme la connexion.

La vérification est complète pour cette fonction sous Linux. Toute réception RDMA passe par rdma_recv, et le chemin TCP lit exactement la taille demandée. Le correctif ne change ni le protocole ni la poignée de main. Un serveur corrigé accepte toujours les pairs RDMA et rejette toujours une complétion plus grande que le tampon de l'appelant.

Comment vérifier si j'ai été compromis ?

Commencez par les contrôles d'exposition et de plantage, puis examinez le journal du serveur pour la mise à niveau 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'

Aucun indicateur de compromission public n'est publié pour CVE-2026-118375. Une ligne RDMA activated montre que le serveur a emprunté le chemin vulnérable au moins une fois. Elle ne prouve pas une attaque. Un plantage juste après une connexion entrante est une piste. Une seule complétion surdimensionnée peut ne laisser aucune autre trace.

Si le serveur n'a jamais négocié RDMA, le chemin de réception vulnérable n'a pas été utilisé. Consultez les journaux d'avant la mise à niveau.

Chronologie

  • 2026-04-19 : llama.cpp b8841 sort, et le transport RPC passe dans transport.cpp.
  • 2026-10-12 : Sohaib Harraoui ouvre la demande de fusion de correction #30399.
  • 2026-10-24 : La demande de fusion #30399 est fusionnée dans le commit 9a0fde9, et b11865 sort.
  • 2026-10-28 : CVE-2026-118375 est publiée, et ggml 0.28.0 sort.
  • 2026-11-03 : La CISA publie son évaluation Vulnrichment : Exploitation none, Automatable no, Technical Impact total.
  • 2026-11-20 : Le catalogue KEV 2026.11.18 de la CISA est vérifié, et il ne contient aucune entrée pour la CVE.

La première version concernée, le correctif et la divulgation couvrent 188 jours
Figure 1 : De b8841 au correctif en 188 jours. Source : versions de llama.cpp, demande de fusion #30399 et fiche CVE, vérifiées le 20 novembre 2026.

FAQ

CVE-2026-118375 concerne-t-elle llama-server ou seulement ggml-rpc-server ?

L'écouteur vulnérable est ggml-rpc-server. llama-server et llama-cli sont des clients qui s'y connectent avec --rpc. Si vous exécutez llama-server sans backend RPC, vous n'exposez pas cet écouteur.

RDMA est-il activé par défaut ?

Oui, sous Linux, lorsque CMake trouve libibverbs à la configuration. L'option GGML_RPC_RDMA vaut ON par défaut dans ce cas. Le transport est négocié à HELLO, donc les deux pairs doivent prendre en charge RDMA pour que la connexion soit mise à niveau.

Un attaquant peut-il l'exploiter sur TCP simple ?

Non, cette faille se trouve dans le chemin de réception RDMA. La boucle recv_data TCP lit exactement le nombre d'octets demandé. Le protocole RPC n'a toujours pas d'authentification, donc d'autres risques subsistent sur une connexion TCP.

Une protection de pile arrête-t-elle l'attaque ?

Un canari de pile peut transformer l'écrasement en abandon, mais le memcpy s'exécute avant la vérification du canari. Il n'empêche pas le débordement. Le fait que le processus abandonne ou que l'état corrompu soit exploitable dépend de la compilation et de la disposition de la mémoire.

CVE-2026-118375 est-elle exploitée en conditions réelles ?

Aucune exploitation en conditions réelles n'est connue au 2026-11-20. La fiche Vulnrichment de la CISA indique Exploitation none et Automatable no, et la CVE n'est pas dans le catalogue KEV de la CISA.

Que faire si je ne peux pas mettre à niveau tout de suite ?

Définissez GGML_RPC_NO_RDMA=1 sur le serveur et redémarrez-le, ou recompilez avec -DGGML_RPC_RDMA=OFF. Gardez le port RPC sur la boucle locale ou un réseau de confiance jusqu'à l'installation de b11865 ou ultérieur.

Trouvez les versions vulnérables de llama.cpp avec Ostorlab

Sohaib Harraoui a trouvé et corrigé cette faille, et l'analyse de composition logicielle d'Ostorlab inventorie les composants open source et leurs versions dans vos dépôts, ce qui vous permet de trouver les versions de llama.cpp et de ggml antérieures à b11865. Commencez sur Ostorlab SCA et SBOM.

Références

  • Fiche CVE-2026-118375, VulnCheck : https://www.cve.org/CVERecord?id=CVE-2026-118375 (vérifiée le 20 novembre 2026)
  • Demande de fusion de correction #30399 de llama.cpp, « rpc : add bounds check in rdma_recv » : https://github.com/ggml-org/llama.cpp/pull/30399 (vérifiée le 20 novembre 2026)
  • Commit de correction 9a0fde9967fa1a35b6e5dd1f47e1a3648b6fecc1 : https://github.com/ggml-org/llama.cpp/commit/9a0fde9967fa1a35b6e5dd1f47e1a3648b6fecc1 (vérifié le 20 novembre 2026)
  • Notes de version de llama.cpp b11865 : https://github.com/ggml-org/llama.cpp/releases/tag/b11865 (vérifiées le 20 novembre 2026)
  • Notes de version de llama.cpp b8841 : https://github.com/ggml-org/llama.cpp/releases/tag/b8841 (vérifiées le 20 novembre 2026)
  • rdma_recv vulnérable à b8841 : https://github.com/ggml-org/llama.cpp/blob/b8841/ggml/src/ggml-rpc/transport.cpp (vérifié le 20 novembre 2026)
  • Même copie non vérifiée dans b8840 : https://github.com/ggml-org/llama.cpp/blob/b8840/ggml/src/ggml-rpc/ggml-rpc.cpp (vérifié le 20 novembre 2026)
  • rdma_recv corrigé à b11865 : https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/transport.cpp (vérifié le 20 novembre 2026)
  • Boucle de commandes RPC à b11865 : https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/ggml-rpc.cpp (vérifiée le 20 novembre 2026)
  • Capacités du transport RPC à b11865 : https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/transport.h (vérifiées le 20 novembre 2026)
  • Options de compilation RPC à b11865 : https://github.com/ggml-org/llama.cpp/blob/b11865/ggml/src/ggml-rpc/CMakeLists.txt (vérifiées le 20 novembre 2026)
  • Source du serveur RPC et point de terminaison par défaut à b11865 : https://github.com/ggml-org/llama.cpp/blob/b11865/tools/rpc/rpc-server.cpp (vérifiés le 20 novembre 2026)
  • README RPC, avec la section RDMA et l'avertissement : https://github.com/ggml-org/llama.cpp/blob/b11865/tools/rpc/README.md (vérifié le 20 novembre 2026)
  • Version ggml 0.28.0 : https://github.com/ggml-org/ggml/releases/tag/v0.28.0 (vérifiée le 20 novembre 2026)
  • Dépôt llama.cpp, 135 844 étoiles le 2026-11-20 : https://github.com/ggml-org/llama.cpp (vérifié le 20 novembre 2026)
  • Catalogue Known Exploited Vulnerabilities de la CISA, version 2026.11.18 : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)