Skip to main content

LightRAG CVE-2026-85740

| EUVDEUVD-2026-84549 HIGH
Server-Side Request Forgery (SSRF) (CWE-918)
2026-09-22 GitHub_M GHSA-vv3m-f8x4-7377
7.1
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate and upload crafted Markdown/textpack
  2. Delivery
    Embed NAT64/IPv4-compatible image URL wrapping internal IPv4
  3. Exploit
    Server passes literal is_global gate
  4. Execution
    LightRAG fetches internal/cloud-metadata resource
  5. Impact
    Response 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

LightRAG < 1.5.5

Affected Packages

pypi lightrag-hku fix: 1.5.5
euvd lightrag fix: 1.5.5

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

Vendor (GitHub_M) PRIMARY 7.1 HIGH
AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N
vuln.today AI 7.1 HIGH

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.

3.1 AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:L/A:N
4.0 AV:N/AC:H/AT:P/PR:L/UI:N/VC:H/VI:L/VA:N/SC:L/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
High
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
Low
Availability
None

Lifecycle Timeline

2
Patch available
Sep 22, 2026 - 17:17 EUVD
CVE Published
Sep 22, 2026 - 16:20 cve.org
HIGH 7.1

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 73% exploitable
Prevalence
Low
GitHub-popular open-source Python RAG framework, but modest real-world production footprint
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

56
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy