Aller au contenu

CVE-2026-103395 : exécution de code à distance pré-authentifiée par désérialisation RPyC dans LightLLM

Densité :
HASS

SCORE DE SECURITE AGENTIQUE HERMES & EXPOSITION DE L'ENVIRONNEMENT D'EXECUTION IA

Cible : Cadre d'inférence LightLLM - Démon RPC RPyC du service visuel
Confiance : 98%
96 / 100
CRITIQUE

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 20 / 20
Accès aux outils & APIs 20 / 20
Privilege 15 / 15
Persistence 13 / 15
External Impact 14 / 15
Propagation 14 / 15
⚖️ Divergence & Justification opérationnelle

Le score CVSS v3.1 standard évalue cette vulnérabilité à 9.8 (critique). Le score de menace opérationnel Hermes (HTS) lui attribue 95 (CRITIQUE) et le score de sécurité agentique Hermes (HASS) s'établit à 96 (CRITIQUE). LightLLM est une infrastructure d'inférence haute performance exploitée au sein de pipelines multi-modaux, d'agents autonomes de vision et de grappes de calcul IA d'entreprise. L'exposition d'un service RPyC non authentifié avec l'option allow_pickle neutralise l'isolation d'exécution : tout agent en amont, toute injection de prompt dotée de capacités SSRF ou tout attaquant réseau peut exécuter du code sur l'hôte GPU, compromettre la mémoire VRAM et extraire les poids du modèle.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-103395: LightLLM Visual-Only RPyC Deserialization Pre-Authentication Remote Code ExecutionVULNÉRABILITÉ

Nœuds connectés : 1
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 :

LightLLM est un moteur d’inférence léger et hautement optimisé pour grands modèles de langage (LLM) et modèles vision-langage (VLM), développé en Python et C++/CUDA pour garantir une latence minimale sur les parcs de calcul GPU.

ParamètreSpécification techniqueImpact opérationnel
Identifiant CVECVE-2026-103395Référence de suivi international
Source de l’avisAvis d’exploitation VulnCheckSuivi des exploits militarisés (1er octobre 2026)
Classe de vulnérabilitéDésérialisation non sécurisée (CWE-502), absence d’authentification (CWE-287)Exécution de code à distance sur l’hôte d’IA
Composants affectésDémon de service visuel (lightllm.server.visual_server), interface RPyCPrétraitement d’images et routage d’inférence
Versions affectéesLightLLM <= 1.2.0Toutes les instances visuelles et multimodales
Version corrigée1.2.1Interdiction de pickle et authentification RPyC obligatoire
Impact opérationnelCompromission totale de l’hôte GPU et du Cluster D’IAAccès shell, extraction des poids de modèle et vol de prompts

La faille : service RPyC ouvert et désérialisation native pickle

Section intitulée « La faille : service RPyC ouvert et désérialisation native pickle »

Pour distribuer la charge de calcul des encodeurs de vision (tels que CLIP ou SigLIP) sur des processus GPU dédiés, LightLLM instancie un démon à l’aide du protocole RPyC. Ce service expose une méthode de traitement d’images :

ATTAQUANT / AGENT COMPROMIS INTERFACE RÉSEAU DÉMON VISUEL LIGHTLLM (SERVEUR GPU)
│ │ │
│ 1. Connexion au port RPyC │ │
│ (ex. TCP 22345 ou interface exposée) │ │
├───────────────────────────────────────────>│ │
│ │ │
│ 2. Négociation du protocole : │ │
│ Le service accepte la connexion brute. │ │
│ AUCUN certificat TLS ni jeton exigé ! │ │
│<───────────────────────────────────────────┤ │
│ │ │
│ 3. Forger l'objet sérialisé malveillant : │ │
│ class Exploit(object): │ │
│ def __reduce__(self): │ │
│ return (os.system, ('id',)) │ │
│ │ │
│ 4. Transmission de la charge : │ │
│ conn.root.remote_infer_images(payload) │ │
├───────────────────────────────────────────>│ │
│ │ 5. Chaîne de désérialisation : │
│ │ rpyc.core.protocol reçoit les octets. │
│ │ allow_pickle=True est actif ! │
│ │ Appel automatique de pickle.loads() ! │
│ │ │
│ │ 6. Exécution de __reduce__() : │
│ │ La commande système s'exécute sous le │
│ │ compte de service du démon LightLLM ! │
│ │ │
│ 7. Obtention d'un shell distant interactif │
│<────────────────────────────────────────────────────────────────────────────────────────┤

En Python, le module standard pickle reconstruit des instances d’objets en invoquant les constructeurs ou fonctions définis dans le tuple renvoyé par la méthode spéciale __reduce__. Dès lors qu’une connexion réseau autorise la désérialisation pickle sans restriction (allow_pickle=True), l’émetteur peut contraindre le processus récepteur à exécuter des commandes système arbitraires (os.system, subprocess.Popen) lors de la simple lecture des arguments.

Confrontation du code : logique vulnérable vs logique corrigée

Section intitulée « Confrontation du code : logique vulnérable vs logique corrigée »
# Extrait conceptuel de lightllm/server/visual_server/visual_service.py (<= 1.2.0)
import rpyc
from rpyc.utils.server import ThreadedServer
class VisualInferService(rpyc.Service):
def exposed_remote_infer_images(self, model_id, image_bytes_or_obj):
# VULNÉRABILITÉ (CWE-502) : acceptation de structures non fiables via RPyC.
# Lorsque allow_pickle=True est configuré, les objets entrants sont désérialisés
# automatiquement avant même que le corps de cette méthode ne s'exécute.
images = self.preprocess_images(image_bytes_or_obj)
return self.visual_engine.forward(model_id, images)
def start_visual_service(host="0.0.0.0", port=22345):
# VULNÉRABILITÉ (CWE-287) : écoute sur toutes les interfaces sans authentification
server = ThreadedServer(
VisualInferService,
port=port,
hostname=host,
protocol_config={
"allow_pickle": True, # CRITIQUE : autorise la désérialisation d'objets arbitraires
"allow_public_attrs": True
}
)
server.start()
# Implémentation sécurisée dans LightLLM 1.2.1
import rpyc
import hmac
import hashlib
from rpyc.utils.server import ThreadedServer
class SecureVisualInferService(rpyc.Service):
def exposed_remote_infer_images(self, model_id, raw_image_bytes):
# CORRECTION : acceptation stricte d'octets bruts décodés par une bibliothèque sûre (Pillow)
if not isinstance(raw_image_bytes, bytes):
raise ValueError("Charge utile invalide : seuls les flux d'octets bruts sont autorisés.")
return self.visual_engine.forward_safe(model_id, raw_image_bytes)
def start_secure_visual_service(host="127.0.0.1", port=22345, auth_secret=None):
# CORRECTION : liaison à localhost, rejet catégorique de pickle et authentification HMAC
server = ThreadedServer(
SecureVisualInferService,
port=port,
hostname=host,
authenticator=rpyc.utils.authenticators.HmacAuthenticator(auth_secret),
protocol_config={
"allow_pickle": False, # STRICT : interdiction totale de pickle
"allow_public_attrs": False
}
)
server.start()

3. Vecteurs d’attaque & militarisation sur le terrain

Section intitulée « 3. Vecteurs d’attaque & militarisation sur le terrain »

Les bulletins d’ingénierie offensive de VulnCheck mettent en évidence des modes d’exploitation ciblés :

  1. Détournement d’outils d’agents IA autonomes : un agent IA disposant de modules de navigation web ou d’appels d’API internes peut être manipulé via une injection de prompt indirecte. L’agent reçoit l’instruction de contacter l’adresse interne du démon RPyC, relayant la charge malveillante vers le serveur d’inférence.
  2. Prise d’accès initial sur les fermes de serveurs GPU : les attaquants scannent les sous-réseaux internes pour repérer les ports 22345 et 8000. Comme les microservices visuels sont hébergés sur des serveurs pourvus d’accélérateurs NVIDIA H100 ou A100, la compromission procure des ressources de calcul massives et un point d’ancrage persistant.
  3. Pillage des poids de modèles et secrets d’entreprise : une fois l’accès shell obtenu, les assaillants accèdent aux disques partagés NFS ou au cache local (/root/.cache/huggingface/hub/), exfiltrant les modèles affinés (fine-tuned) et les instructions système propriétaires.
  4. Interception de la mémoire VRAM : les assaillants injectent des bibliothèques d’interception CUDA pour capturer les flux d’images traités en direct, récupérant des pièces d’identité, documents confidentiels ou images médicales analysés par le modèle.

4. Triage forensique & ingénierie de la détection

Section intitulée « 4. Triage forensique & ingénierie de la détection »

Les équipes de cybersécurité doivent surveiller la hiérarchie des processus exécutés par Python et le trafic réseau dirigé vers les ports RPyC.

title: Création anormale de processus fils par le démon visuel LightLLM (CVE-2026-103395)
id: 3c7e9b14-1033-4f95-8a21-95cbe103395b
status: experimental
description: Détecte l'exécution d'interpréteurs de commandes ou de binaires suspects engendrés par un processus Python associé au démon visuel de LightLLM.
author: Hermes Codex Cyber Intelligence
date: 2026-10-01
references:
- https://vulncheck.com/advisories/lightllm-through-1.2.0-unauthenticated-remote-code-execution-via-visual-only-rpyc-service
- https://nvd.nist.gov/vuln/detail/CVE-2026-103395
logsource:
category: process_creation
product: linux
detection:
selection_parent:
ParentCommandLine|contains:
- 'lightllm'
- 'visual_service'
- 'visual_server'
- 'rpyc'
selection_child:
Image|endswith:
- '/bin/sh'
- '/bin/bash'
- '/bin/dash'
- '/usr/bin/python'
- '/usr/bin/curl'
- '/usr/bin/wget'
- '/usr/bin/nc'
- '/bin/nc'
- '/usr/bin/whoami'
condition: selection_parent and selection_child
fields:
- Image
- CommandLine
- ParentImage
- ParentCommandLine
- User
falsepositives:
- Scripts de maintenance invoqués interactivement par les ingénieurs d'exploitation IA
level: critical
tags:
- attack.execution
- attack.t1059.004
- attack.initial_access
- attack.t1190
- cve.2026.103395

  1. Mise à niveau de LightLLM vers la version 1.2.1 : Mettre à jour le paquet Python dans les environnements virtuels et les images de conteneurs :

    Fenêtre de terminal
    pip install --upgrade lightllm>=1.2.1

    Reconstruire les conteneurs de base afin de s’assurer de l’élimination complète des fichiers vulnérables du service visuel.

  2. Désactivation explicite de allow_pickle : Pour les déploiements personnalisés de LightLLM, vérifier impérativement que allow_pickle est configuré sur False au sein du dictionnaire protocol_config.

  3. Liaison exclusive à localhost OU à des sockets unix : Restreindre l’écoute du démon visuel exclusivement à 127.0.0.1 ou employer des sockets de domaine Unix (/var/run/lightllm/visual.sock) pour éviter l’exposition réseau inter-conteneurs.

  4. Cloisonnement réseau Kubernetes des nœuds GPU : Appliquer des politiques de réseau (NetworkPolicy) strictes interdisant tout trafic d’entrée non autorisé vers les ports du service visuel depuis les autres pods du cluster.