Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate and upload crafted Markdown/textpack
-
DeliveryEmbed NAT64/IPv4-compatible image URL wrapping internal IPv4
-
ExploitServer passes literal is_global gate
-
ExecutionLightRAG fetches internal/cloud-metadata resource
-
ImpactResponse body ingested and exfiltrated
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 | Two prerequisites must both hold. First, the attacker must be an authenticated caller who can upload a Markdown or textpack document to LightRAG (PR:L). Second - and this is the decisive limiter - the deployment must have compatible NAT64 or DNS64 routing configured, so that the IPv6 transition-wrapper literal (NAT64 well-known prefix 64:ff9b::/96 or an IPv4-compatible ::a.b.c.d form) is actually delivered to the embedded internal IPv4. Without NAT64/DNS64 the wrapped literal does not route to the intended internal target and the SSRF fails, which is why the vendor rated AC:H. The embedded IPv4 must point at a non-public target (loopback, RFC1918, link-local cloud-metadata 169.254.169.254, or CGNAT). Note IPv4-mapped ::ffff: forms and 6to4/RFC 8215 local-use NAT64 were already blocked pre-fix; the exploitable gap was specifically the NAT64 well-known /96 and IPv4-compatible wrappers whose literal classified as globally routable. Operators who deliberately run local NAT64 can also widen exposure via the NATIVE_MD_IMAGE_ALLOWED_NON_PUBLIC_CIDRS escape hatch. |
| Impact | This is a genuine but conditional SSRF (CWE-918), not a drop-everything issue. The vendor CVSS 3.1 vector (AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N = 7.1) is internally consistent with the description and I concur with it: network-reachable, but AC:H correctly reflects that exploitation only works 'on a deployment with compatible NAT64 or DNS64 routing' - a non-default network precondition - and PR:L reflects that the attacker must be an authenticated caller able to upload a Markdown/textpack document. No EPSS score, no CISA KEV listing, and no public POC are provided; per precision rules this is 'no public exploit identified at time of analysis.' The absence of exploitation signals combined with AC:H and the specialized NAT64/DNS64 routing requirement means real-world exploitability is narrow rather than mass-scannable, despite the HIGH-band 7.1 CVSS. The confidentiality impact (C:H) is credible because the classic SSRF target here is cloud instance-metadata (169.254.169.254) yielding credentials, and the fetched internal-resource body is ingested into the RAG store - so a data-exfiltration path is real where the routing precondition holds. No conflicting signals in the vector; the main caveat is the environmental dependency (NAT64/DNS64) that CVSS base metrics cannot express and AC:H only partially captures. |
| Exploit ScenarioDerived | An authenticated user of a self-hosted LightRAG instance that sits behind NAT64/DNS64 routing uploads a Markdown or textpack document containing an external image URL written as an IPv6 transition wrapper (e.g. NAT64 well-known prefix 64:ff9b::a9fe:a9fe or an IPv4-compatible ::a9fe:a9fe encoding 169.254.169.254). The literal address passes the old is_global check, so the server fetches the wrapped internal target - cloud metadata, loopback, or an RFC1918 service - and ingests the response body, leaking internal data or cloud credentials. No public exploit code is identified, but the technique is well-documented and the fix explicitly enumerates the bypassing wrappers. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 22, 2026
Server-side request forgery (CWE-918) in LightRAG before 1.5.5 lets an authenticated caller who can upload a Markdown or textpack document point an external image URL at an IPv6 transition-wrapper literal (NAT64 well-known prefix 64:ff9b::/96 or an IPv4-compatible ::a.b.c.d form) that embeds a loopback, RFC1918, CGNAT, or cloud-metadata IPv4 address, causing the parser's image download to fetch the internal resource and ingest its body. The guard in lightrag/parser/markdown/parser.py evaluated only the literal address with ipaddress.is_global, which classifies these wrappers as globally routable, so the embedded internal target was never checked. Exploitation is conditional (AC:H): the deployment must have compatible NAT64/DNS64 routing for the wrapper to be delivered to the embedded target, which is why the assessed vector is AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV). The issue is fixed in v1.5.5.
RemediationAI
Vendor-released patch: upgrade to LightRAG v1.5.5 (https://github.com/HKUDS/LightRAG/releases/tag/v1.5.5), which contains the guard rewrite; the underlying changes are visible in the upstream PR and commits (https://github.com/HKUDS/LightRAG/pull/3426, commit 9207e7fd10cf6df3cf26e3dd1921490b34a2f132, commit a25862177a9b00e0edb870778a42b4155924de09, commit c598545aa0084a427bcb19a84ade5e0ec31fa673). If immediate upgrade is not possible, the effective compensating control is to stop the parser from fetching remote images at all - pre-process or reject Markdown/textpack uploads that contain external image references, or disable the native Markdown image fetch path - accepting the loss of automatic image ingestion for those documents. Second, constrain download egress so that the LightRAG host cannot reach loopback, RFC1918, CGNAT, or the link-local cloud metadata endpoint 169.254.169.254 (network policy or egress proxy on the parser's fetch path); this is robust even for untrusted NAT64 prefixes but requires network-layer control and may break legitimate local integrations. Third, do not widen exposure via the operator escape hatch: keep NATIVE_MD_IMAGE_ALLOWED_NON_PUBLIC_CIDRS unset or as narrow as operationally possible, since it explicitly re-permits non-public destinations, and on NAT64/DNS64 hosts pin the download egress to a monitored proxy, because the fix does not recognize custom globally routable NAT64 Network-Specific Prefixes. Finally, restrict who can upload documents to the ingestion pipeline, as the vulnerability requires an authenticated caller (PR:L) and cannot be triggered by an unauthenticated user.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in pypi, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The affected subsystem is LightRAG's Markdown parser, specifically _validated_addresses() in lightrag/parser/markdown/parser.py, which gates host resolution for the image-download path (_download and _build_guarded_opener). The root cause is CWE-918: the guard decided safety from the single primitive ipaddress.is_global applied to the literal resolved address. IPv6 transition wrappers can carry an embedded IPv4 in a fixed low-32-bit position while the wrapper literal itself is classified globally routable, so a literal such as 64:ff9b::7f00:1 (NAT64 well-known prefix, RFC 6052) or the IPv4-compatible form ::7f00:1 passes is_global even though it encodes 127.0.0.1; on a host with NAT64 or DNS64 routing the request is then delivered to the embedded internal IPv4 (loopback, RFC1918, CGNAT 100.64.0.0/10, or link-local cloud metadata 169.254.169.254). The Python standard library's classification has also shifted historically - certain blocks such as 64:ff9b:1::/48 (RFC 8215 local-use NAT64) and 2002::/16 (6to4) were treated as globally routable by older CPython before gh-113171 and its backports. The upstream fix introduces _unwrap_embedded_ipv4(), which decodes only wrappers with a spec-fixed embedded-IPv4 position (IPv4-mapped ::ffff:0:0/96, IPv4-compatible ::/96 excluding :: and ::1, and the NAT64 well-known 64:ff9b::/96) and _is_globally_routable(), which starts from the stdlib verdict and only ever tightens it: force-denied blocks _FORCE_NON_GLOBAL_V6 (64:ff9b:1::/48 and 2002::/16) are always rejected, and a decoded embedded IPv4 must itself be global, so 64:ff9b::808:808 (8.8.8.8) still passes while 64:ff9b::7f00:1 is blocked. Custom, globally routable NAT64 Network-Specific Prefixes (RFC 6052 permits any /32../96) remain unrecognized and are left to operator egress pinning or the NATIVE_MD_IMAGE_ALLOWED_NON_PUBLIC_CIDRS escape hatch.
Know when Lightrag 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:H/PR:L/UI:N/S:C/C:H/I:L/A:N
AC:H for the required NAT64/DNS64 routing precondition, PR:L for the authenticated uploader, S:C and C:H as SSRF reaches internal/cloud-metadata systems and ingests their bodies.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
LightRAG provides simple and fast retrieval-augmented generation. Prior to 1.5.5, _validated_addresses in lightrag/parser/markdown/parser.py evaluates the literal resolved address with ipaddress.is_global without consistently classifying an IPv4 address embedded in an IPv6 transition wrapper. A caller who can upload a Markdown or textpack document can supply an external image URL using NAT64 64:ff9b::/96 or an IPv4-compatible form that embeds a loopback, private, or cloud-metadata IPv4 address. On a deployment with compatible NAT64 or DNS64 routing, _download and _build_guarded_opener accept the wrapper and fetch the internal resource, whose body is then ingested. Current interpreter behavior already blocks some RFC 8215 and 6to4 forms, but the fixed guard handles all documented wrappers without becoming more permissive than the standard library. This issue is fixed in version 1.5.5.
Technical POC Analysis
CWE-918 (Server-Side Request Forgery) in LightRAG's native markdown parser.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
LightRAG deployments running versions before 1.5.5 are exposed to a server-side request forgery flaw that lets any authenticated user permitted to upload Markdown or textpack documents cause the server to fetch internal network resources and ingest their contents. Because the vulnerable code path can reach RFC1918 ranges, CGNAT space, loopback, and cloud metadata endpoints, a single malicious document could expose internal services and cloud credentials to an attacker who already holds a low-privileged account. Exploitation is conditional on the environment supporting NAT64/DNS64 or IPv4-compatible addressing, but where those conditions hold the confidentiality impact is high and the flaw affects the confidentiality of resources beyond the vulnerable component itself.
No vendor-released patch identified at time of analysis; interim mitigations are (1) restrict document upload privilege to trusted authenticated users only, (2) block or allowlist egress from the LightRAG host so it cannot reach loopback, RFC1918, CGNAT, link-local, cloud metadata (169.254.169.254), or NAT64/IPv4-compatible wrapper destinations, (3) enforce IMDSv2 and remove unnecessary cloud IAM roles from the host, (4) audit your NAT64/DNS64 routing to determine whether the exploitation precondition exists, and (5) instrument logging/alerting on parser-initiated outbound requests to internal address space.
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.
Cross-origin data theft in LightRAG server versions prior to 1.5.4 allows any malicious website to make authenticated, c
Password recovery via a timing oracle in LightRAG's /login endpoint lets remote, unauthenticated attackers (CVSS PR:N/UI
Authentication bypass in HKUDS LightRAG before 1.5.4 lets a remote unauthenticated attacker defeat X-API-Key protection
Unthrottled password guessing against the LightRAG POST /login endpoint allows an unauthenticated remote attacker to sub
Stored cross-site scripting (CWE-79) in the LightRAG WebUI prior to 1.5.5 lets an attacker who can ingest a document per
LightRAG API server versions prior to 1.5.5 return raw Python exception text to network clients through error handlers i
EUVD-2026-84549
GHSA-vv3m-f8x4-7377
NVD
CVE.org
EPSS
VulDB
Exploit-DB