CVE-2026-103395 : exécution de code à distance pré-authentifiée par désérialisation RPyC dans LightLLM
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 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.
CVE-2026-103395: LightLLM Visual-Only RPyC Deserialization Pre-Authentication Remote Code ExecutionVULNÉRABILITÉ
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.”
- [vulnerability_report]
- [government_confirmation]CISA verified active exploitation in the wild and mandated federal remediation deadline in KEV entry. — Source : Cybersecurity & Infrastructure Security Agency (CISA): CISA Adds CVE-2026-59822 to Known Exploited Vulnerabilities Catalog (Fiabilité : VERY_HIGH)
1. Contexte technique & matrice logicielle
Section intitulée « 1. Contexte technique & matrice logicielle »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ètre | Spécification technique | Impact opérationnel |
|---|---|---|
| Identifiant CVE | CVE-2026-103395 | Référence de suivi international |
| Source de l’avis | Avis d’exploitation VulnCheck | Suivi 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és | Démon de service visuel (lightllm.server.visual_server), interface RPyC | Prétraitement d’images et routage d’inférence |
| Versions affectées | LightLLM <= 1.2.0 | Toutes les instances visuelles et multimodales |
| Version corrigée | 1.2.1 | Interdiction de pickle et authentification RPyC obligatoire |
| Impact opérationnel | Compromission totale de l’hôte GPU et du Cluster D’IA | Accès shell, extraction des poids de modèle et vol de prompts |
2. Décomposition technique approfondie
Section intitulée « 2. Décomposition technique approfondie »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 rpycfrom 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.1import rpycimport hmacimport hashlibfrom 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 :
- 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.
- Prise d’accès initial sur les fermes de serveurs GPU : les attaquants scannent les sous-réseaux internes pour repérer les ports
22345et8000. 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. - 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. - 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-95cbe103395bstatus: experimentaldescription: 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 Intelligencedate: 2026-10-01references: - 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-103395logsource: category: process_creation product: linuxdetection: 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_childfields: - Image - CommandLine - ParentImage - ParentCommandLine - Userfalsepositives: - Scripts de maintenance invoqués interactivement par les ingénieurs d'exploitation IAlevel: criticaltags: - attack.execution - attack.t1059.004 - attack.initial_access - attack.t1190 - cve.2026.103395// Détection de processus fils suspects issus des services Python d'inférence IA// Chasse forensique pour CVE-2026-103395 LightLLMSyslog| where TimeGenerated >= ago(7d)| where ProcessName has "python"| where SyslogMessage has_any ("lightllm", "visual_server", "rpyc")| where SyslogMessage has_any ("/bin/sh", "/bin/bash", "whoami", "curl", "wget", "nc -e")| project TimeGenerated, Computer, ProcessName, SyslogMessage| order by TimeGenerated desc#!/usr/bin/env python3"""Outil de diagnostic : vérification de l'exposition du port RPyC de LightLLM."""import sysimport socket
def audit_point_entree_rpyc(hote, port): print(f"[*] Vérification de l'accès à {hote}:{port} pour le service RPyC...") try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(3.0) s.connect((hote, int(port)))
# Envoi d'une trame de négociation RPyC s.sendall(b"\x00\x00\x00\x01\x00") reponse = s.recv(1024) s.close()
if reponse: print(f"[!] ALERTE : le port {port} a répondu à la sonde RPyC.") print(f"[!] L'interface est exposée. Si LightLLM <= 1.2.0 est déployé, l'hôte est vulnérable à CVE-2026-103395.") return True else: print(f"[+] Le port {port} n'a pas renvoyé de poignée de main RPyC.") return False except Exception as e: print(f"[-] Échec de la connexion vers {hote}:{port} : {e}") return False
if __name__ == "__main__": hote_cible = sys.argv[1] if len(sys.argv) > 1 else "127.0.0.1" port_cible = int(sys.argv[2]) if len(sys.argv) > 2 else 22345 audit_point_entree_rpyc(hote_cible, port_cible)5. Stratégie de remédiation & durcissement
Section intitulée « 5. Stratégie de remédiation & durcissement »-
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.1Reconstruire les conteneurs de base afin de s’assurer de l’élimination complète des fichiers vulnérables du service visuel.
-
Désactivation explicite de allow_pickle : Pour les déploiements personnalisés de LightLLM, vérifier impérativement que
allow_pickleest configuré surFalseau sein du dictionnaireprotocol_config. -
Liaison exclusive à localhost OU à des sockets unix : Restreindre l’écoute du démon visuel exclusivement à
127.0.0.1ou employer des sockets de domaine Unix (/var/run/lightllm/visual.sock) pour éviter l’exposition réseau inter-conteneurs. -
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.