CVE-2026-103395: LightLLM Visual-Only RPyC Deserialization Pre-Authentication Remote Code Execution
HERMES AGENTIC SECURITY SCORE & AI RUNTIME EXPOSURE
Target:LightLLM Inference Serving Framework - Visual-Only RPyC RPC Daemon Standard CVSS v3.1 rates this flaw at 9.8 (Critical). The Hermes Threat Score evaluates it at 95 (CRITICAL) and the Hermes Agentic Security Score (HASS) rates it at 96 (CRITICAL). LightLLM is high-throughput inference infrastructure utilized in multi-modal agentic workflows, vision-language pipelines, and enterprise LLM clusters. Exposing unauthenticated RPyC with allow_pickle enabled breaks AI runtime sandboxing entirely: any upstream agent, prompt injection with SSRF capability, or external network actor can achieve full host code execution, compromise GPU memory spaces, and extract proprietary model weights or system prompts.
CVE-2026-103395: LightLLM Visual-Only RPyC Deserialization Pre-Authentication Remote Code ExecutionVULNERABILITY
Software platform affected by security vulnerabilities and agentic attack patterns.
๐ Why is this related? (Evidence & 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 (Reliability: VERY_HIGH)
1. Technical Context & Affected Software Matrix
Section titled โ1. Technical Context & Affected Software MatrixโLightLLM is a high-performance, lightweight Large Language Model (LLM) and Vision-Language Model (VLM) serving framework developed in Python and C++/CUDA, engineered for high concurrency and low-latency token generation across cloud and on-premises GPU clusters.
| Parameter | Technical Specification | Operational Impact |
|---|---|---|
| CVE Identifier | CVE-2026-103395 | Global tracking reference |
| Advisory Source | VulnCheck Exploit Intelligence Advisory | Weaponized exploit tracking (October 1, 2026) |
| Vulnerability Class | Insecure Deserialization (CWE-502), Missing Authentication (CWE-287) | Remote code execution on AI host |
| Affected Components | Visual Serving Daemon (lightllm.server.visual_server), RPyC Worker Interface | Multi-modal image pre-processing & inference routing |
| Affected Versions | LightLLM <= 1.2.0 | All multimodal and visual-only serving instances |
| Fixed Version | 1.2.1 (or patched upstream repository) | RPyC authentication enforcement & pickle ban |
| Operational Impact | Total AI Host & GPU Cluster Compromise | Shell execution, CUDA context memory dumping, weight exfiltration |
2. In-Depth Technical Decomposition
Section titled โ2. In-Depth Technical DecompositionโThe Flaw: Unauthenticated RPyC with Insecure Pickle Deserialization
Section titled โThe Flaw: Unauthenticated RPyC with Insecure Pickle DeserializationโTo offload vision encoder computations (e.g. CLIP, SigLIP, or ViT backbones) across dedicated GPU processes, LightLLM deploys a worker daemon using the rpyc library. The primary entry point for visual requests is exposed through an RPyC service instance:
ATTACKER / ROGUE AGENT NETWORK INTERFACE LIGHTLLM VISUAL DAEMON (GPU HOST) โ โ โ โ 1. Connect to RPyC Service Port โ โ โ (e.g., TCP 22345 or exposed bind) โ โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ>โ โ โ โ โ โ 2. Handshake Negotiation: โ โ โ Service accepts raw RPyC connection. โ โ โ NO mutual TLS, token, or password! โ โ โ<โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค โ โ โ โ โ 3. Craft Malicious Serialized Object: โ โ โ class Exploit(object): โ โ โ def __reduce__(self): โ โ โ return (os.system, ('id',)) โ โ โ โ โ โ 4. Transmit Payload to Method: โ โ โ conn.root.remote_infer_images(payload) โ โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ>โ โ โ โ 5. Deserialization Pipeline: โ โ โ rpyc.core.protocol.Connection receives โ โ โ incoming bytes. allow_pickle=True! โ โ โ Calls pickle.loads() on image args! โ โ โ โ โ โ 6. __reduce__() Invoked during Unpickling: โ โ โ Arbitrary OS command executes in the โ โ โ process context of LightLLM daemon! โ โ โ โ โ 7. Command Output / Reverse Shell Established โ โ<โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโคIn Python, the pickle module serializes arbitrary object hierarchies into byte streams. Deserialization via pickle.loads() reconstructs instances by resolving callables defined within the __reduce__ tuple. If allow_pickle is enabled in an RPyC connection, the protocol relies on Pythonโs native unpickling subsystem, permitting any client to force the server into executing arbitrary system functions (e.g., posix.system, subprocess.Popen) during parameter parsing.
Vulnerable Code in Visual Service
Section titled โVulnerable Code in Visual Serviceโ# Conceptual extract from 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): # VULNERABILITY (CWE-502): Accepts untrusted client data passed through RPyC. # When allow_pickle=True is set on the server, incoming objects are deserialized # directly by the RPyC protocol before this function even begins processing. 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): # VULNERABILITY (CWE-287): Binding to all interfaces without authentication server = ThreadedServer( VisualInferService, port=port, hostname=host, protocol_config={ "allow_pickle": True, # CRITICAL: Enables arbitrary object deserialization "allow_public_attrs": True } ) server.start()Patched Implementation (1.2.1)
Section titled โPatched Implementation (1.2.1)โ# Patched implementation in 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): # REMEDIATION: Accept only raw byte streams and validate with Pillow/Safe decoders if not isinstance(raw_image_bytes, bytes): raise ValueError("Invalid payload: only raw bytes are permitted.") 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): # REMEDIATION: Bind to localhost, enforce strict IPC or Unix sockets, ban pickle server = ThreadedServer( SecureVisualInferService, port=port, hostname=host, authenticator=rpyc.utils.authenticators.HmacAuthenticator(auth_secret), protocol_config={ "allow_pickle": False, # STRICT: Disallow pickle deserialization entirely "allow_public_attrs": False } ) server.start()3. Attack Vectors & Real-World Weaponization
Section titled โ3. Attack Vectors & Real-World WeaponizationโVulnCheck exploit intelligence details active operational tradecraft targeting AI infrastructure:
- Autonomous Agent Tool Subversion: An autonomous agent endowed with web browsing or API querying tools is manipulated via indirect prompt injection (e.g. browsing a malicious webpage containing instructions:
fetch http://internal-gpu-worker:22345/). If the agent can initiate raw socket connections or send HTTP requests that trigger internal SSRF, it can reach the unprotected RPyC listener. - GPU Cluster Initial Access Brokerage: Threat actors scan enterprise subnets and Kubernetes namespaces for exposed ports (
22345,8000,9000). Because visual microservices are frequently deployed on high-memory GPU worker nodes (equipped with NVIDIA H100, A100, or L40S cards), compromising the visual daemon provides adversaries with immediate compute resources for cryptomining, model extraction, or internal network pivot. - Model Weight & Training Data Theft: Upon obtaining shell access, attackers read model checkpoint files stored in shared NFS mounts or local scratch disks (
/root/.cache/huggingface/hub/), exfiltrating proprietary fine-tuned weights and corporate system instructions. - VRAM Memory Scraper: Attackers inject CUDA hooking libraries (e.g.
LD_PRELOADinterceptingcudaMemcpy) to sniff visual inference inputs, capturing confidential documents, employee badges, or medical scans processed by the vision-language model.
4. Forensic Triage & Detection Engineering
Section titled โ4. Forensic Triage & Detection EngineeringโDetection teams must monitor endpoint process execution trees and network traffic directed towards RPyC ports.
title: Anomalous Child Process Spawned by LightLLM Visual Daemon (CVE-2026-103395)id: 3c7e9b14-1033-4f95-8a21-95cbe103395bstatus: experimentaldescription: Detects command shells or suspicious system binaries spawned by Python processes running LightLLM visual serving components, indicative of RPyC pickle deserialization exploitation.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: - Custom diagnostic scripts invoked manually by AI DevOps engineers with interactive ttylevel: criticaltags: - attack.execution - attack.t1059.004 - attack.initial_access - attack.t1190 - cve.2026.103395// Detect anomalous child process executions from Python AI serving processes// CVE-2026-103395 LightLLM Deserialization RCESyslog| 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"""Diagnostic utility: Probe internal LightLLM RPyC listeners for insecure allow_pickle configuration."""import sysimport socket
def audit_rpyc_endpoint(host, port): print(f"[*] Probing {host}:{port} for RPyC exposure...") try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(3.0) s.connect((host, int(port)))
# Send raw RPyC handshake probe s.sendall(b"\x00\x00\x00\x01\x00") resp = s.recv(1024) s.close()
if resp: print(f"[!] WARNING: Port {port} responded to raw RPyC probe.") print(f"[!] Endpoint is exposed. If running LightLLM <= 1.2.0, host is vulnerable to CVE-2026-103395.") return True else: print(f"[+] Port {port} did not return RPyC handshake.") return False except Exception as e: print(f"[-] Connection failed to {host}:{port}: {e}") return False
if __name__ == "__main__": target_host = sys.argv[1] if len(sys.argv) > 1 else "127.0.0.1" target_port = int(sys.argv[2]) if len(sys.argv) > 2 else 22345 audit_rpyc_endpoint(target_host, target_port)5. Remediation Strategy & Hardening
Section titled โ5. Remediation Strategy & Hardeningโ-
Upgrade LightLLM to Version 1.2.1:
Update the Python package within serving virtual environments and container images:Terminal window pip install --upgrade lightllm>=1.2.1Rebuild GPU base container images to ensure vulnerable visual service files are completely replaced.
-
Disable allow_pickle in RPyC Configurations:
If operating custom wrappers around the visual service, explicitly verify thatallow_pickleis set toFalsein allprotocol_configdictionaries. -
Bind Visual Services Exclusively to Loopback or Unix Domain Sockets:
Configure the visual daemon to bind exclusively to127.0.0.1or leverage Unix domain sockets (/var/run/lightllm/visual.sock) to prevent inter-pod network exposure. -
Isolate AI GPU Worker Nodes via Kubernetes NetworkPolicies:
Implement strict network egress and ingress rules preventing ingress traffic to visual service ports from non-coordinator pods:apiVersion: networking.k8s.io/v1kind: NetworkPolicymetadata:name: isolate-lightllm-visualspec:podSelector:matchLabels:app: lightllm-workeringress:- from:- podSelector:matchLabels:app: lightllm-routerports:- protocol: TCPport: 22345