EN
en direct
IA

Le sandbox regex de LiteLLM cède face à la réécriture de bytecode et donne un shell à distance

Le 18 novembre 2026, la CISA ajoute CVE-2026-40217 à son catalogue KEV : l’endpoint de test des guardrails de LiteLLM exécute du code arbitraire en réécrivant le bytecode Python, et l’image Docker tourne en root. Toute passerelle LiteLLM antérieure à la v1.83.10-stable doit être mise à jour, et la master key traitée comme un secret root.

Une petite cage métallique posée sur un établi sombre, un barreau légèrement écarté.

10 avril 2026. La NVD publie CVE-2026-40217 : la passerelle LLM open source LiteLLM exécute du code arbitraire via la réécriture de bytecode sur l’endpoint /guardrails/test_custom_code. 18 novembre 2026. La CISA ajoute la faille à son catalogue KEV, sur preuve d’exploitation active, avec une échéance fédérale au 2 décembre 2026. 18 novembre 2026. Le correctif existe depuis la v1.83.10-stable, mais l’image Docker officielle exécute le processus en root. Pourquoi c’est important : sept mois séparent la divulgation de l’alerte, et pendant tout ce temps, la passerelle d’inférence — le point unique qui détient les clés de dizaines de modèles — était une porte ouverte.

Un sandbox qui filtrait du texte, pas du code

LiteLLM est une passerelle LLM qui unifie l’accès à des dizaines de fournisseurs — OpenAI, Anthropic, Gemini — derrière une seule API. Elle embarque une fonction de guardrails : du code Python personnalisé qui filtre les requêtes et les réponses avant qu’elles n’atteignent le modèle. Pour tester ce code sans le déployer, l’interface d’administration expose l’endpoint /guardrails/test_custom_code, qui exécute le Python fourni dans un sandbox maison.

Ce sandbox reposait sur un mécanisme que les chercheurs de X41 D-Sec ont démonté : un filtre regex qui refusait la présence littérale de chaînes dangereuses — __globals__, __builtins__, import, __class__. L’hypothèse implicite était qu’un code ne contenant pas ces chaînes ne pouvait pas les utiliser. C’est exactement l’hypothèse que Python casse, parce que le langage résout ses attributs dynamiquement à l’exécution.

La conséquence est nette. Le sandbox ne filtrait pas les capacités du code — il filtrait des sous-chaînes. Or un attaquant peut reconstruire n’importe quelle chaîne interdite par concaténation : "_"+"_gl"+"ob"+"als"+"_"+"_" produit __globals__ sans jamais le faire apparaître littéralement dans le source. Le filtre regex est contourné avant même d’avoir commencé à protéger quoi que ce soit.

La réécriture de bytecode, pas une injection classique

L’exploitation va plus loin qu’une simple concaténation de chaînes. L’attaquant qui soumet du code au sandbox suit un chemin précis, décrit dans l’advisory x41-2026-001 et repris par la CISA. D’abord, il remonte la hiérarchie d’objets de Python sans passer par l’attribut filtré __class__ : l’expression str.mro()[1] renvoie l’objet racine object via l’ordre de résolution des méthodes. Ensuite, il extrait l’objet code d’une fonction génératrice grâce à l’attribut gi_code, qui n’était pas dans la liste noire.

Vient alors l’étape qui donne son nom à la faille. L’attaquant appelle la méthode code.replace() pour réécrire la table de noms du bytecode de la fonction, en y injectant la chaîne __globals__ reconstruite. Il applique ce bytecode modifié via object.__setattr__. Quand la fonction s’exécute, elle résout __globals__ sur un environnement non restreint fourni par le sandbox — par exemple la fonction utilitaire http_get — et l’attaquant récupère le dictionnaire globals d’un contexte de confiance.

La dernière ligne du payload ne laisse aucun doute :

python
def apply_guardrail(inputs, request_data, input_type):
    obj = str.mro()[1]
    def g(fn):
        yield fn.placeholder
    c = g(None).gi_code
    gn = "_"+"_gl"+"ob"+"als"+"_"+"_"
    cn = "_"+"_co"+"de_"+ "_"
    obj.__setattr__(g, cn, c.replace(co_names=(gn,)))

De là, l’accès à __builtins__ ouvre le module os, et os.popen("id").read() exécute une commande système dont la sortie revient dans la réponse HTTP de l’endpoint. Une seule requête POST authentifiée suffit.

Root par défaut, et la master key comme seul verrou

Le décalage de sept mois entre la divulgation d’avril et l’inscription au KEV de novembre mérite d’être nommé. LiteLLM a publié le correctif v1.83.10-stable peu après la divulgation, et l’advisory X41 décrivait la technique d’exploitation en clair, avec le payload complet. Pendant tout ce temps, des instances exposées ont continué de tourner en root avec un sandbox contournable — c’est précisément ce décalage entre « correctif disponible » et « correctif appliqué » que le KEV cherche à réduire en imposant une échéance.

Le prérequis d’exploitation est une authentification : l’endpoint exige un jeton porteur valide, typiquement la LITELLM_MASTER_KEY. C’est ce qui fixe le CVSS 3.1 à 8,8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) — des privilèges faibles sont nécessaires. Mais deux détails aggravent sérieusement l’impact.

D’abord, l’image Docker officielle de LiteLLM exécute le processus en root par défaut. Un contournement du sandbox devient donc une compromission complète du conteneur, et non d’un utilisateur limité. Ensuite, la master key n’est pas un secret marginal : c’est la clé qui déverrouille l’administration de la passerelle et, indirectement, les clés API de tous les fournisseurs que la passerelle agrège. Une RCE sur cette machine, c’est la lecture de toutes les clés de modèles en clair.

Ce n’est pas la première alerte LiteLLM que nous couvrons. Le pipeline de publication du projet a déjà été compromis pour distribuer un info-stealer, et la campagne Canto Incognito ciblait explicitement les instances LiteLLM exposées pour les convertir en mineurs. Le motif est constant : la passerelle LLM est un service stateful, riche en secrets, souvent exposé pour la commodité des développeurs — et traité avec moins de rigueur qu’un serveur de base de données.

La correction abandonne le sandbox maison

Le correctif, livré dans la v1.83.10-stable, ne durcit pas le filtre regex — il l’abandonne. LiteLLM a intégré la bibliothèque RestrictedPython, qui opère au niveau de l’arbre syntaxique (AST) plutôt que du texte source. RestrictedPython réécrit chaque accès d’attribut en un appel à une fonction de garde qui applique une politique stricte à l’exécution : les attributs internes comme gi_code ou mro deviennent inaccessibles, et les vecteurs de concaténation et de manipulation de bytecode disparaissent.

C’est la bonne décision, et c’est une leçon générale. Un sandbox qui filtre du texte pour sécuriser un langage dynamique est un sandbox mort-né. La seule frontière fiable est celle qui s’applique à la structure du programme — l’AST — et non à sa surface textuelle.

La remédiation

Pour une instance LiteLLM auto-hébergée, la marche à suivre tient en trois actions. Montez en v1.83.10-stable ou supérieure — c’est la version qui remplace le sandbox regex par RestrictedPython. Faites tourner le conteneur en utilisateur non-root : l’image officielle utilise root par défaut, et un utilisateur dédié transforme une RCE en compromission limitée. Enfin, traitez la master key comme un secret root — rotation immédiate si elle a pu être exposée, et retrait de l’endpoint /guardrails de toute exposition non nécessaire.

bash
# Vérifier la version déployée
docker exec litellm python -c "import litellm; print(litellm.__version__)"

# Mettre à jour l'image et repartir en utilisateur non-root
docker pull ghcr.io/berriai/litellm:main-latest
docker run -d --user 1000:1000 -p 4000:4000 \
  -e LITELLM_MASTER_KEY="$NEW_MASTER_KEY" ghcr.io/berriai/litellm:main-latest

La CISA fixe l’échéance fédérale au 2 décembre 2026. Pour une équipe privée, le bon réflexe est le même : ce délai n’est pas une suggestion, c’est le temps que l’exploitation active vous laisse.

Le verdict

Si vous exploitez LiteLLM en version antérieure à la v1.83.10-stable, montez immédiatement — la faille est activement exploitée, inscrite au KEV, et l’image Docker exécute le processus en root. La priorité va aux passerelles exposées ou partagées entre plusieurs équipes, qui concentrent les clés de dizaines de fournisseurs de modèles.

Si vous êtes déjà à jour, ne relâchez rien : faites tourner le conteneur en non-root, restreignez l’accès à /guardrails, et faites tourner la master key. La leçon dépasse LiteLLM — toute passerelle d’inférence que vous déployez est un coffre à secrets. Un sandbox qui filtre du texte pour contenir du Python est une porte que quelqu’un finira par pousser.

Références

Le brief cyber, chaque mardi

Les failles qui comptent, les correctifs à appliquer, en dix minutes de lecture.

Pas de spam. Désinscription en un clic.
à lire ensuite

Sur le même sujet

llama.cpp 1.0 verrouille son API et devient la fondation de l’IA locale

Le 13 novembre 2026, llama.cpp publie sa version 1.0.0 et impose la version sémantique à libllama et libggml, les bibliothèques qui font tourner l’inférence locale de bout en bout. Si vous intégrez de l’IA locale dans un produit, adoptez les canaux de distribution officiels — Docker, Debian, Homebrew — plutôt que de compiler et vendorer le code vous-même.

← Retour au fil

Tapez au moins deux caractères.

↑ ↓ naviguer ↵ ouvrir esc fermer