Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect to Chainlit socket.io endpoint
-
DeliverySupply crafted sessionId with path traversal sequences
-
ExploitService resolves traversal outside upload directory
-
ExecutionRecursive deletion executes on target directory
-
ImpactApplication data or host directories destroyed
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | No special configuration is required beyond the Chainlit service being reachable over the network - the vulnerable code path is in the default socket.io session handling present in all Chainlit deployments through 2.12.0. The CVSS 4.0 vector (PR:N/UI:N/AC:L) confirms exploitation is unauthenticated and requires no user interaction. The scope of destruction is bounded by what the service process user account has write/delete permissions to on the host filesystem; running Chainlit as root or with broad filesystem permissions maximizes blast radius. The upload directory configuration determines the starting point, but the lack of validation allows escape to any accessible path. Exploitation is limited to filesystem deletion - there is no read/exfiltration primitive implied by the CVSS vector (VC:N). |
| Impact | The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N) reflects a genuinely dangerous profile: fully network-accessible, zero authentication, no complexity barrier, and high availability impact via recursive directory deletion. The integrity impact is rated low (VI:L), consistent with a write-destructive rather than exfiltration-class flaw - however, directory deletion permanently destroys data, which some assessors would argue warrants VI:H as well. No EPSS score is available for this CVE, and it is not in CISA KEV, reducing urgency for mass-exploitation response but not eliminating priority for internet-exposed deployments. No public exploit code has been identified at time of analysis. Real-world risk is highest for Chainlit instances exposed directly to the internet or to untrusted LAN segments - a single unauthenticated request can trigger recursive deletion of directories the service process has write access to, potentially wiping application data, logs, or even OS directories if the process runs with elevated privileges. Organizations running Chainlit as a low-privilege service in a containerized environment face a lower blast radius but remain vulnerable to application-layer destruction. |
| Exploit ScenarioDerived | An attacker with network access to a Chainlit service endpoint establishes a socket.io connection and supplies a crafted sessionId such as '../../../../critical-app-data' or an absolute path like '/var/log/chainlit'. The service resolves this as a legitimate upload session path and, upon session teardown or cleanup, executes a recursive deletion against the traversed directory - destroying data outside the intended scope without any authentication challenge. No public proof-of-concept has been identified, but the exploitation primitive (client-controlled socket.io parameter → filesystem operation) is straightforward to reproduce from the referenced source code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 09, 2026
Unauthenticated remote directory deletion in Chainlit through 2.12.0 allows any network-accessible attacker to recursively destroy arbitrary filesystem directories reachable by the service process. The flaw resides in the socket.io session handler, which accepts a client-supplied sessionId without path sanitization and uses it directly in file system operations - permitting absolute and relative path traversal sequences to escape the intended upload directory. With a CVSS 4.0 score of 8.8 (AV:N/AC:L/AT:N/PR:N/UI:N), exploitation requires no authentication or user interaction; no public exploit or CISA KEV listing has been identified at time of analysis.
RemediationAI
No vendor-released patch has been identified at time of analysis - the source code references provided point to the 2.12.0 codebase with no subsequent fix commit or tagged release indicated. Operators should consult the upstream repository at https://github.com/Chainlit/chainlit for any post-2.12.0 release addressing this issue. As immediate compensating controls, restrict network access to the Chainlit service to trusted clients only (firewall rules, VPN, or reverse-proxy IP allowlist) to reduce the attack surface since the flaw requires no authentication. Run the Chainlit process under a dedicated least-privilege OS account with file system access explicitly scoped to only the application's required directories using OS-level permissions or mandatory access controls (AppArmor, SELinux). Container deployments should mount only necessary volumes and set those volumes to the minimum required permissions. Note that these controls reduce exposure but do not fix the underlying path traversal - any authenticated or trusted client that becomes compromised remains able to exploit the flaw.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Chainlit is an open-source Python framework (PyPI: chainlit) for rapidly building LLM-powered conversational web applications using a socket.io backend. The vulnerability, classified as CWE-22 (Improper Limitation of a Pathname to a Restricted Directory), originates in the session management layer. Source references point specifically to backend/chainlit/session.py and backend/chainlit/socket.py at tag 2.12.0, where the sessionId - a parameter fully controlled by the connecting client - is incorporated into file system path construction without normalization, canonicalization, or prefix validation. Because socket.io permits arbitrary string values for sessionId, an attacker can supply sequences such as '../../../../var/www' or absolute paths like '/etc' to redirect file operations outside the bounded upload directory. The affected CPE is cpe:2.3:a:chainlit:chainlit:*:*:*:*:*:*:*:*, covering all versions from 0 through 2.12.0.
Know when Chainlit gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
Network-accessible unauthenticated deletion; no confidentiality impact; availability is high (recursive directory wipe); integrity rated low consistent with write-destructive rather than data-disclosure impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Chainlit through 2.12.0 fails to validate the client-supplied socket.io sessionId parameter, allowing unauthenticated attackers to traverse filesystem paths by injecting absolute or relative path sequences. Attackers can craft malicious sessionId values that escape the upload directory and recursively delete arbitrary directories accessible to the service process.
Executive ViewAI
Chainlit versions through 2.12.0 contain an unauthenticated remote vulnerability allowing attackers to recursively delete arbitrary files accessible to the application process, creating immediate risk of data loss and service disruption for any Internet-exposed Chainlit deployment. Organizations using Chainlit for customer-facing chat applications or internal tools must immediately implement access controls to prevent unauthorized file deletion and data loss.
No vendor-released patch identified at time of analysis. Implement network-level access controls to restrict socket.io endpoint exposure via firewall or reverse-proxy authentication; deploy WAF rules to sanitize or block path traversal patterns in session parameters; run Chainlit with restricted filesystem permissions and containerized isolation to limit deletion damage; enable filesystem access logging and alerting for recursive directory operations; maintain encrypted offline backups of application data with restricted access; and consider temporarily disabling Chainlit until patching is available if operational data sensitivity is high.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Unauthenticated remote code execution in Chainlit (2.4.0rc0 through 2.11.x) occurs when features.mcp.enabled is set to t
Server-side request forgery in Chainlit before 2.9.4 lets an authenticated user coerce the server into fetching an attac
Arbitrary file read in Chainlit versions prior to 2.9.4 lets an authenticated user disclose any file readable by the Cha
Session hijacking in Chainlit before 2.10.1 allows remote attackers with a valid victim sessionId to inherit an authenti
Server-side request forgery in Chainlit's MCP client path lets an unauthenticated remote user slip past path-scoped allo
Feedback endpoint authorization bypass in Chainlit through 2.12.0 allows authenticated users to modify or delete other u
EUVD-2026-74908
GHSA-wf68-h55h-fvxv
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB