Aller au contenu
Hermes Codex

CVE-2026-22807 : exécution de code à distance pré-authentification dans le chargeur de modules dynamiques auto-map de vLLM

HERMES

SCORE DE MENACE HERMES & COMPROMISSION DU PÉRIMÈTRE

Cible : Cœur d'inférence LLM, grappes GPU & infrastructure d'orchestration IA
Confiance : 96%
94 / 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 19 / 20
Exposition 18 / 20
Prévalence 19 / 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 v3.1 attribue à la CVE-2026-22807 un score de 9.8 Critique (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Le Hermes Threat Score lui assigne la note de 94 (CRITIQUE). vLLM constitue le moteur d'inférence open source haute performance standard de l'écosystème IA d'entreprise. L'exécution dynamique liée à auto_map intervient avant toute authentification d'API, permettant à un dépôt de modèle empoisonné sur Hugging Face ou un registre interne de compromettre l'hôte GPU et d'exfiltrer les poids, les secrets cloud et les données des locataires.

HASS

SÉVÉRITÉ AGENTIQUE HASS & IMPACT SUR L'ISOLATION DES AGENTS

Cible : Chargeur de modèle vLLM & résolveur de modules dynamiques Transformers
Confiance : 95%
82 / 100
ÉLEVÉ

Mesure le risque systémique spécifique découlant de l'autonomie, de l'autorité des outils et de l'exécution en cascade.

Décomposition des dimensions
Autonomie décisionnelle 18 / 20
Accès aux outils & APIs 18 / 20
Privilege 13 / 15
Persistence 11 / 15
External Impact 11 / 15
Propagation 11 / 15
⚖️ Divergence & Justification opérationnelle

Les agents IA autonomes et les pipelines MLOps automatisés déploient dynamiquement des serveurs d'inférence et chargent des poids de modèles selon les requêtes d'utilisateurs ou les tâches d'évaluation. L'absence de restriction sur auto_map permet à un manifeste malveillant de s'échapper du bac à sable de l'agent et de détourner l'ensemble des flux d'exécution.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-22807: vLLM Dynamic Module Auto-Map Pre-Auth Remote Code ExecutionVULNÉRABILITÉ

Nœuds connectés : 3
Relations sortantes actives
→ affectsCOMPOSANTvLLM Inference Engine
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“Confirmed security vulnerability in vLLM Inference Engine documented in Hermes dossier.”

Preuves vérifiées associées :
→ exploitsMODÈLE D'ATTAQUEAAP-007: Autonomous Cascading RCE
92% VERY_HIGH

Cascading multi-stage attack chaining context injection, autonomous loop planning, and un-sandboxed execution sinks to achieve persistent root shell compromise on host machines.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“CVE-2026-22807 weaponizes the agentic attack pattern formalized under AAP-007.”

Preuves vérifiées associées :
→ exploitsMODÈLE D'ATTAQUEAAP-004: Semantic Tool Poisoning
92% VERY_HIGH

Attacker registers rogue MCP tools or skills with weaponized docstrings and deceptive metadata that trick the model into routing sensitive user tasks to attacker-controlled functions.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“CVE-2026-22807 weaponizes the agentic attack pattern formalized under AAP-004.”

Preuves vérifiées associées :

1. Contexte technique et matrice des versions affectées

Section intitulée « 1. Contexte technique et matrice des versions affectées »

vLLM permet le chargement direct de modèles depuis Hugging Face Hub, des répertoires locaux ou des compartiments S3 via son intégration avec transformers.

ParamètreSpécification techniqueImpact opérationnel
Identifiant CVECVE-2026-22807Avis de sécurité vLLM GHSA-vllm-automap
Classe de vulnérabilitéInjection de code (CWE-94) / Chargement non fiable (CWE-829)Exécution arbitraire de scripts Python au chargement du modèle
Composant vulnérablevllm/model_executor/model_loader.py & résolution AutoConfigAnalyse de la configuration du modèle et importation dynamique
Vecteur d’exploitationFichier config.json malveillant avec clé auto_map pointant vers un fichier .pyRCE pré-authentification déclenchée au démarrage du worker
Privilèges requisAucun (PR:N)Déclenché avant la couche d’authentification API
Privilèges obtenusUtilisateur système hôte (uid du service vLLM / root en conteneur)Accès intégral aux calculs GPU, mémoire hôte et clés d’API
Versions affectéesvLLM >= 0.10.1 et < 0.14.0Serveurs d’inférence, pods Kubernetes GPU, clusters Ray
Correctifs publiésvLLM 0.14.0 et 0.14.1Contrôle strict du flag de confiance et validation des modules

2. Anatomie de la vulnérabilité et analyse de la cause racine

Section intitulée « 2. Anatomie de la vulnérabilité et analyse de la cause racine »

Importation dynamique non assainie via auto_map

Section intitulée « Importation dynamique non assainie via auto_map »

Dans l’écosystème Hugging Face, un auteur de modèle peut définir une architecture sur-mesure en fournissant les classes Python directement dans le dépôt. Le fichier config.json contient une section auto_map :

{
  "architectures": ["AdversarialCausalLM"],
  "auto_map": {
    "AutoConfig": "configuration_adversarial.AdversarialConfig",
    "AutoModelForCausalLM": "modeling_adversarial.AdversarialForCausalLM"
  }
}

Dans le code de vLLM (vllm/model_executor/model_loader.py), la vérification de l’option de sécurité trust_remote_code était contournée lors de l’appel au résolveur de classes personnalisées :

# Chargeur vulnérable de configuration de modèle dans vLLM
def _get_model_architecture(model_config: ModelConfig):
    hf_config = get_config(model_config.model, trust_remote_code=model_config.trust_remote_code)


    # ANOMALIE : Si auto_map est défini, vLLM résout la classe via une importation dynamique
    # sans transmettre la restriction trust_remote_code à l'importateur sous-jacent
    if hasattr(hf_config, "auto_map") and "AutoModelForCausalLM" in hf_config.auto_map:
        custom_class_path = hf_config.auto_map["AutoModelForCausalLM"]
        module_name, class_name = custom_class_path.rsplit(".", 1)


        # FAILLE : dynamic_import_hub_module télécharge et importe le bytecode Python,
        # exécutant le code racine de modeling_adversarial.py dès son importation !
        custom_module = dynamic_import_hub_module(
            model_id=model_config.model,
            module_file=f"{module_name}.py"
        )
        return getattr(custom_module, class_name)

Puisque l’évaluation d’un module par importlib exécute immédiatement toute instruction située au niveau racine du script Python, un code malveillant placé en dehors des classes s’exécute avec les pleins droits du processus vLLM dès la tentative de chargement.

3. Vecteurs d’attaque et cinématique forensique d’exécution

Section intitulée « 3. Vecteurs d’attaque et cinématique forensique d’exécution »
sequenceDiagram
    autonumber
    actor Attacker as Attaquant / Menace
    participant Hub as Hugging Face Hub / Registre
    participant Agent as Agent IA / Pipeline MLOps
    participant Loader as Chargeur vLLM
    participant OS as Système hôte Linux / GPU
    participant C2 as Serveur C2 adverse


    Attacker->>Hub: Publication du dépôt empoisonné (config.json + modeling_adversarial.py)
    Note over Hub: modeling_adversarial.py contient un reverse shell au niveau racine
    Agent->>Loader: Commande vllm serve attaquant/modele-piege
    Loader->>Hub: Téléchargement des poids, de config.json et des scripts
    Loader->>Loader: Analyse de config.json -> détection de la clé auto_map
    Loader->>OS: dynamic_import_hub_module() exécute modeling_adversarial.py
    OS->>C2: Lancement du reverse shell / exfiltration des clés d'API et tokens IAM
    C2-->>OS: Prise de contrôle persistante du nœud de calcul GPU
  1. Empoisonnement du dépôt de modèle : L’attaquant publie un modèle sur un hub public ou un registre interne compromis, en configurant un pointeur auto_map vers un fichier modeling_adversarial.py.
  2. Armement de la charge utile : Dans modeling_adversarial.py, du code Python est placé au niveau supérieur du fichier afin de capturer les variables d’environnement (HF_TOKEN, OPENAI_API_KEY, métadonnées cloud AWS/GCP) ou d’ouvrir un socket interactif.
  3. Déclenchement du chargement : Un agent de développement IA autonome ou un opérateur déclenche le service vllm serve attaquant/modele-piege ou sollicite l’API de permutation de modèle.
  4. Exécution pré-authentification : Avant toute vérification de clé d’API cliente et avant l’allocation de la VRAM, l’importation dynamique charge le fichier .py et exécute la charge utile.
  5. Mouvement latéral sur le cluster GPU : L’attaquant obtient un shell interactif au sein du cluster de calcul haute vitesse, accédant aux bus NVLink et aux caches d’inférence d’autres locataires.

4. Investigation forensique et réponse à incident

Section intitulée « 4. Investigation forensique et réponse à incident »

Les analystes DFIR intervenant sur un serveur vLLM suspecté de compromission doivent inspecter les artefacts suivants :

Commandes d’investigation sur l’hôte et le conteneur

Section intitulée « Commandes d’investigation sur l’hôte et le conteneur »
Fenêtre de terminal
# 1. Examiner le cache des modules dynamiques Hugging Face
find ~/.cache/huggingface/modules/ -type f -name "*.py" -exec ls -la {} +


# 2. Vérifier les paramètres de commande et drapeaux passés à vLLM
ps aux | grep vllm | grep -E "model|trust-remote-code"


# 3. Détecter d'éventuels processus enfants anormaux engendrés par Python
pstree -p $(pgrep -f "vllm.entrypoints")


# 4. Identifier les sockets réseau sortants inhabituels ouverts par le processus vLLM
ss -tp | grep -E "python|ray"


# 5. Consulter les appels d'exécution de commandes système via Auditd
ausearch -p $(pgrep -f "vllm") -m EXECVE -ts today

5. Chasse aux menaces et ingénierie de détection

Section intitulée « 5. Chasse aux menaces et ingénierie de détection »
title: Processus enfant suspect généré par le moteur d'inférence vLLM
id: 22807c02-vllm-automap-rce-fr
status: experimental
description: Détecte le lancement d'interpréteurs de commande ou d'outils réseau suspects par le processus vLLM, signalant l'exploitation de la CVE-2026-22807.
author: Hermes Codex Detection Engineering
date: 2026-09-24
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentCommandLine|contains:
      - 'vllm.entrypoints'
      - 'vllm'
  selection_child:
    Image|endswith:
      - '/bin/sh'
      - '/bin/bash'
      - '/usr/bin/curl'
      - '/usr/bin/wget'
      - '/usr/bin/nc'
      - '/usr/bin/python3'
      - '/usr/bin/python'
  condition: selection_parent and selection_child
falsepositives:
  - Scripts de surveillance interne exécutés sous une arborescence non conventionnelle.
level: critical
tags:
  - attack.execution
  - attack.t1059.006
  - cve.2026-22807

6. Plan de remédiation et durcissement défensif

Section intitulée « 6. Plan de remédiation et durcissement défensif »

Mise à jour de la bibliothèque vLLM

Section intitulée « Mise à jour de la bibliothèque vLLM »

Mettre à jour immédiatement vLLM vers la version 0.14.0 ou 0.14.1 :

Fenêtre de terminal
pip install --upgrade vllm>=0.14.1

Durcissement architectural en profondeur

Section intitulée « Durcissement architectural en profondeur »
  1. Blocage systématique du code distant : Ne jamais employer l’argument --trust-remote-code sans audit préalable et signature cryptographique du modèle.
  2. Registre de modèles étanche et scanné : Interdire l’accès direct des clusters de production au Hugging Face Hub public. Mettre en place un registre interne où les modèles sont inspectés et validés par des analyseurs statiques avant mise à disposition.
  3. Isolement strict des conteneurs : Exécuter les pods vLLM sous un utilisateur non privilégié (runAsNonRoot: true), révoquer l’ensemble des capacités Linux (cap_drop: ["ALL"]) et monter le système de fichiers racine en lecture seule (readOnlyRootFilesystem: true).

7. Recherches corrélées et références internes

Section intitulée « 7. Recherches corrélées et références internes »

Sources et références

Section intitulée « Sources et références »