Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconSupply crafted public URL to application
-
DeliveryPass validate_safe_url() check (public hostname)
-
ExploitAttacker server issues 302 redirect to internal endpoint
-
Installrequests.get() follows redirect without revalidation
-
C2Fetch internal/cloud metadata response
-
ExecuteParse response as Document objects
-
ImpactLeak Document content via application output
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 three concurrent conditions: (1) The application must call HTMLHeaderTextSplitter.split_text_from_url() with a URL that the attacker controls or can influence - this is the intended API design, so any application that ingests user-supplied or third-party URLs via this function is in scope. (2) The redirect target must be an internal endpoint that does not require special request headers for access - AWS IMDSv1 (169.254.169.254) and unauthenticated internal admin APIs are confirmed viable targets; AWS IMDSv2, GCP IMDS, and Azure IMDS are explicitly NOT reachable because they require vendor-specific request headers that the redirect cannot inject. (3) Data exfiltration as an impact requires the application to return Document object contents or derivatives back to the party who supplied the URL - applications that process Documents internally without reflecting content to the requester are not exposed to the exfiltration path, though the unauthorized SSRF request to internal endpoints still occurs. The CVSS PR:N metric confirms that no authentication to the LangChain application itself is required beyond the ability to supply a URL. |
| Impact | The vendor-assigned CVSS 6.5 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N) reflects a moderate severity, though the UI:R metric deserves scrutiny - it represents not an end-user clicking something, but a developer or application passing an attacker-controlled URL into the vulnerable function, which is precisely the intended use case of the API. This makes the 'user interaction' threshold effectively zero in real deployments designed to accept external URLs. Against that, EPSS of 0.03% at the 9th percentile and SSVC exploitation status of 'none' indicate no observed exploitation activity. The SSVC 'automatable: no' assessment aligns with the application-architecture dependency for full data exfiltration - exploitation is not fire-and-forget. The SSVC 'technical impact: partial' correctly captures that impact is bounded by what the application does with Documents. There is no KEV listing and no known POC. The net risk profile is: real vulnerability with a confirmed attack path, but exploitation requires a specific application architecture pattern (accepting attacker URLs AND surfacing Document content to the requester), which limits practical blast radius. Priority should be elevated for LLM applications that accept user-supplied URLs for document ingestion and return processed content to end users. |
| Exploit ScenarioDerived | An attacker submits a crafted URL pointing to a server they control (e.g., https://attacker.example.com/redirect) to a LangChain-powered application that passes user-supplied URLs to HTMLHeaderTextSplitter.split_text_from_url(). The initial validate_safe_url() check passes because the hostname resolves to a public IP. The attacker's server responds with a 302 redirect to http://169.254.169.254/latest/meta-data/iam/security-credentials/ (AWS IMDSv1). Because no POC is publicly available, this scenario is reconstructed from the GHSA advisory description and the CVSS attack vector rather than observed attacker behavior. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 24, 2026
SSRF redirect bypass in langchain-text-splitters prior to 1.1.2 allows attackers who can supply URLs to applications using HTMLHeaderTextSplitter.split_text_from_url() to reach internal network endpoints, localhost services, or cloud instance metadata APIs by exploiting unvalidated HTTP redirects. The function's built-in validate_safe_url() check is circumvented because requests.get() follows 302 redirects by default without revalidating the redirect target - turning a deliberate safety feature into a false guarantee. Data exfiltration is contingent on the application returning or surfacing Document object contents to the URL-supplying party; no public exploit has been identified at time of analysis, and EPSS sits at the 9th percentile.
RemediationAI
Upgrade langchain-text-splitters to version 1.1.2 or later; this release also requires langchain-core >= 1.2.31, so both packages must be updated together. The fix is confirmed by the GitHub Security Advisory GHSA-fv5p-p927-qmxr at https://github.com/langchain-ai/langchain/security/advisories/GHSA-fv5p-p927-qmxr. If immediate upgrade is not possible, the most targeted compensating control is to avoid passing any externally-supplied or user-influenced URLs to split_text_from_url() - restrict input to a static allowlist of trusted domains resolved at application startup. Alternatively, wrap calls to split_text_from_url() with application-level redirect validation by setting allow_redirects=False in the underlying requests call and handling redirects manually with revalidation; however, this requires patching application code that calls the library rather than the library itself. Do not rely on network-layer blocks to internal subnets alone, as redirect targets may include cloud metadata endpoints reachable from any instance (e.g., 169.254.169.254 for AWS IMDSv1) that perimeter controls may not cover.
Affected VersionsENISA
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
The vulnerability resides in libs/text-splitters/langchain_text_splitters/html.py within the split_text_from_url() method of LangChain's HTMLHeaderTextSplitter class (CPE: cpe:2.3:a:langchain-ai:langchain-text-splitters:*:*:*:*:*:*:*:*). CWE-918 (Server-Side Request Forgery) describes the root cause: the server makes an HTTP request to a user-supplied URL without fully controlling the final destination. The architectural flaw is a classic TOCTOU-like pattern - validate_safe_url() confirms the original URL resolves to a non-private address, but the subsequent requests.get() call with follow_redirects=True (default) allows a redirect chain to terminate at any internal destination the attacker's server specifies. Cloud metadata endpoints requiring vendor-specific request headers (AWS IMDSv2, GCP, Azure IMDS) are explicitly not reachable through this bypass because the redirect response cannot inject the required headers; however, unauthenticated endpoints - notably AWS IMDSv1 and internal admin APIs - are exposed. The fix in version 1.1.2 requires langchain-core >= 1.2.31 and presumably revalidates the redirect target URL or disables redirect following entirely.
Know when Langchain Text Splitters 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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N
AC:H reflects the dual application-architecture prerequisite (attacker-controlled URL input AND Document content surfaced to requester); all other metrics align with the vendor vector.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
3DescriptionCVE.org
LangChain is a framework for building agents and LLM-powered applications. Prior to langchain-text-splitters 1.1.2, HTMLHeaderTextSplitter.split_text_from_url() validated the initial URL using validate_safe_url() but then performed the fetch with requests.get() with redirects enabled (the default). Because redirect targets were not revalidated, a URL pointing to an attacker-controlled server could redirect to internal, localhost, or cloud metadata endpoints, bypassing SSRF protections. The response body is parsed and returned as Document objects to the calling application code. Whether this constitutes a data exfiltration path depends on the application: if it exposes Document contents (or derivatives) back to the requester who supplied the URL, sensitive data from internal endpoints could be leaked. Applications that store or process Documents internally without returning raw content to the requester are not directly exposed to data exfiltration through this issue. This vulnerability is fixed in 1.1.2.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-25634
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB