Chainlit
CVE-2026-22219
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privilege Chainlit user
-
DeliverySubmit Element with malicious internal URL
-
ExploitSQLAlchemy layer performs server-side HTTP GET
-
ExecutionServer fetches metadata/internal service
-
PersistResponse stored via storage provider
-
ImpactRetrieve stolen credentials or internal data
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Credential Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that Chainlit is deployed with the SQLAlchemy data layer backend enabled for persistence (the vulnerable outbound-fetch code lives in the SQLAlchemy element-creation logic) and that the attacker holds an authenticated, low-privilege account (CVSS PR:L) able to create or update an Element through the /project/element flow. The concrete attacker-controlled input is the url value on an Element, which the server fetches via HTTP GET. Limiting factors: it is NOT exploitable against default deployments that do not enable the SQLAlchemy data layer, and it is NOT unauthenticated - a valid session is needed. Impact is maximized when the server has network reachability to sensitive internal services or a cloud metadata endpoint; environments with strict egress filtering or IMDSv2 enforcement meaningfully reduce the achievable impact. |
| Impact | The signals are mixed and should be read together. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N, base 8.3) indicates a network-reachable, low-complexity attack requiring only low privileges (an authenticated app user) with high confidentiality impact and a subsequent-system confidentiality impact (SC:H), consistent with reaching internal/metadata endpoints. Publicly available exploit code raises practical risk, yet EPSS is very low (0.04%, 11th percentile) and the vulnerability is NOT in CISA KEV, so there is no evidence of active or widespread exploitation - the low EPSS despite a public POC suggests limited real-world targeting rather than mass scanning, plausibly because exploitation depends on a non-default configuration. Net: this is a genuine, credible priority for organizations that run Chainlit with the SQLAlchemy data layer and expose it to semi-trusted users (especially in cloud environments with reachable metadata services), but a lower priority for deployments not using that backend. Note the requirement of PR:L means it is authenticated, not an unauthenticated internet-wide risk; verify your data-layer configuration before triaging severity. |
| Exploit ScenarioDerived | An attacker with a valid low-privilege account on a Chainlit app (deployed with the SQLAlchemy data layer) creates or updates an Element whose url points at http://169.254.169.254/latest/meta-data/iam/security-credentials/. The Chainlit server issues an outbound GET to that URL and stores the returned cloud IAM credentials via the storage provider, where the attacker retrieves them - potentially enabling cloud account takeover. Public exploit code for this class of attack is available per the Zafran 'ChainLeak' writeup. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv3 – Jul 14, 2026
Server-side request forgery in Chainlit before 2.9.4 lets an authenticated user coerce the server into fetching an attacker-supplied URL, exposing internal network services and cloud metadata endpoints. The flaw lives in the /project/element update flow specifically when Chainlit is deployed with the SQLAlchemy data layer backend, whose element-creation logic issues an outbound HTTP GET against a user-controlled url field and persists the response through the configured storage provider. Publicly available exploit code exists (documented in Zafran's 'ChainLeak' research), though the flaw is not listed in CISA KEV and its EPSS probability is low at 0.04%.
Earlier versions of this analysis (2)
Server-side request forgery in Chainlit (the open-source Python framework for building conversational AI/LLM apps) before 2.9.4 lets an authenticated user coerce the server into fetching an attacker-supplied URL. When the app is deployed with the SQLAlchemy data layer, a user-controlled url in an Element is retrieved by an outbound HTTP GET and the response is written to the configured storage provider, exposing internal services and cloud metadata (e.g. 169.254.169.254). Publicly available exploit code exists (VulnCheck/Zafran 'ChainLeak' research); it is not on CISA KEV and EPSS is low (0.04%).
Chainlit versions prior to 2.9.4 contain a server-side request forgery (SSRF) vulnerability in the /project/element update flow when configured with the SQLAlchemy data layer backend. [CVSS 7.7 HIGH]
RemediationAI
Vendor-released patch: 2.9.4 - upgrade Chainlit to 2.9.4 or later, which adds sanitization for custom thread element updates (PR #2737). Note the 2.9.4 upgrade includes a breaking persistence change: if you use persistence you must run the migration ALTER TABLE steps ADD COLUMN IF NOT EXISTS modes JSONB; before or during rollout, so schedule a maintenance window. If you cannot patch immediately, reduce exposure by restricting who can authenticate to the Chainlit application (the attack requires an authenticated client), and place the server behind egress controls: block outbound requests from the Chainlit host to internal RFC1918 ranges, localhost, and especially the cloud metadata endpoint 169.254.169.254 (on AWS, enforce IMDSv2 to require a session token) - the trade-off is that legitimate server-side fetches to those ranges will also break. Where feasible, temporarily disabling the SQLAlchemy data layer element persistence removes the vulnerable path but also disables element storage functionality. Refer to the VulnCheck advisory and the 2.9.4 release notes for authoritative details.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
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 for building conversational and LLM/agent chat applications, offering an optional persistence layer to store threads, steps, and Elements (file/media attachments). When operators enable the SQLAlchemy data layer, the element-creation code path dereferences a client-supplied url attribute on an Element and performs a server-originated HTTP GET to retrieve its contents before saving them via the storage provider. This is a textbook CWE-918 (Server-Side Request Forgery): the server trusts a user-supplied URL as a fetch target without validating scheme, host, or destination, so requests to RFC1918 addresses, localhost, or cloud metadata services (e.g. 169.254.169.254) are honored. The single affected package is cpe:2.3:a:chainlit:chainlit, with the vulnerable behavior gated on the SQLAlchemy backend configuration rather than being present in all deployments.
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:L/UI:N/VC:H/VI:N/VA:N/SC:H/SI:N/SA:N
Network-reachable and low-complexity but needs an authenticated user (PR:L); SSRF reaching internal/metadata services crosses a trust boundary (S:C) with confidentiality-only impact (C:H, I/A:N).
Primary rating from Vendor (vulncheck).
CVSS VectorVendor: vulncheck
Lifecycle Timeline
6DescriptionCVE.org
Chainlit versions prior to 2.9.4 contain a server-side request forgery (SSRF) vulnerability in the /project/element update flow when configured with the SQLAlchemy data layer backend. An authenticated client can provide a user-controlled url value in an Element, which is fetched by the SQLAlchemy element creation logic using an outbound HTTP GET request. This allows an attacker to make arbitrary HTTP requests from the Chainlit server to internal network services or cloud metadata endpoints and store the retrieved responses via the configured storage provider.
Executive ViewAI
Chainlit versions before 2.9.4 contain a server-side request forgery vulnerability in the /project/element update flow that allows authenticated users to coerce the server into fetching attacker-supplied URLs, potentially exposing internal network services and cloud metadata endpoints. Publicly available exploit code exists, and organizations using SQLAlchemy backends face heightened risk of lateral movement and credential exposure through metadata endpoint access.
Apply vendor patch.
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
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
Affected Products (CPE)CVE.org
Unauthenticated remote code execution in Chainlit (2.4.0rc0 through 2.11.x) occurs when features.mcp.enabled is set to t
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
Unauthenticated remote directory deletion in Chainlit through 2.12.0 allows any network-accessible attacker to recursive
Feedback endpoint authorization bypass in Chainlit through 2.12.0 allows authenticated users to modify or delete other u
GHSA-2g59-m95p-pgfq
NVD
CVE.org
EPSS
VulDB
Exploit-DB