Skip to main content

RAGFlow CVE-2026-93013

| EUVDEUVD-2026-81682 MEDIUM
Path Traversal (CWE-22)
2026-09-17 VulnCheck GHSA-34x7-7wfj-jp4r
5.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Authenticate with valid access token
  2. Delivery
    Call dev_insert import endpoint
  3. Exploit
    Supply absolute path in file_path
  4. Execution
    Missing validation reads server file
  5. Impact
    JSON-parseable content written to dataset and disclosed

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

Requires a valid RAGFlow access token (authenticated - PR:L) and network reachability to the tenant/dev import endpoints (dev_insert_chunks_from_file, dev_insert_metadata_from_file). The attacker supplies an absolute file_path; there is no additional non-default configuration required beyond having the import endpoints exposed. Key limiting factor: disclosure is bounded to files whose contents parse into the JSON structure the importer expects and then writes to a dataset, so arbitrary binary or non-conforming files cannot be exfiltrated cleanly - this significantly reduces the set of readable secrets versus a general arbitrary-file-read. No user interaction is needed beyond the attacker's own request.

Impact

This is a genuine but moderate-severity issue, not a critical priority. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:N = 5.3) describes an authenticated, network-reachable, low-complexity information-disclosure flaw with LOW confidentiality impact and no integrity or availability impact. The PR:L means a valid access token is required, which meaningfully narrows the attacker population to users already inside the trust boundary. Impact is further constrained by the vulnerability's own mechanics: per the description, disclosure is limited to files that match the expected JSON structure the importer then writes to a dataset, so this is not a clean read of arbitrary secrets (e.g., /etc/shadow content would not parse). No EPSS score, KEV listing, or public POC is present in the supplied data, so there is no signal of active exploitation - the correct status is 'no public exploit identified at time of analysis.' The signals are internally consistent (network vector, authenticated, confidentiality-only); the main caveat is the JSON-structure limitation, which makes real-world value lower than a raw 'arbitrary file read' label would suggest. Patch availability (PR #19591 / commit aa78e8d2) makes remediation straightforward and should be the primary response.

Exploit ScenarioDerived

An authenticated RAGFlow user (or an attacker who has obtained a valid access token) calls the dev_insert_chunks_from_file or dev_insert_metadata_from_file import endpoint and supplies an absolute path such as /var/lib/ragflow/config.json in the file_path parameter. Because path validation is missing, the service reads that server-side file and, if it parses as the expected JSON structure, ingests its contents into a dataset the attacker can then view. No public exploit code is identified in the provided data.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.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 17, 2026

Path traversal in RAGFlow through 0.27.2 allows an authenticated attacker holding a valid access token to read files that are readable by the RAGFlow service by supplying absolute file paths to the dev_insert_chunks_from_file and dev_insert_metadata_from_file tenant/dev import endpoints. The impact is bounded rather than a clean arbitrary-file-read: disclosure only succeeds for files whose contents parse into the JSON structure the importer expects and are subsequently written into a dataset, so non-conforming or binary files cannot be exfiltrated reliably and the practical exposure is limited to JSON-formatted material. No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has published an upstream fix (PR #19591 / commit aa78e8d) that removes the affected dev commands entirely.

RemediationAI

Vendor patch status: upstream fix available (PR/commit); a released patched version is not independently confirmed from the provided data. InfiniFlow's fix is PR #19591 (commit aa78e8d224e0eab818d9fcd46f8791ebd73831bd, https://github.com/infiniflow/ragflow/pull/19591), which removes the dev_insert_chunks_from_file and dev_insert_metadata_from_file commands from the Go CLI parser and dispatch, and the corresponding insert_dataset_from_file / insert_metadata_from_file commands from the Python admin client - so upgrading to the first release that contains this commit (a version above 0.27.2) eliminates the vulnerable code paths rather than merely filtering paths. If upgrading immediately is not possible, the most effective compensating control is to block or remove the affected endpoints: deny POST requests to /kb/insert_from_file and /tenant/insert_metadata_from_file at the reverse proxy or API gateway, with the trade-off that legitimate developer/admin dataset and metadata import tooling breaks; alternatively, do not deploy the developer CLI/import tooling in production images. Because exploitation requires a valid access token, also rotate and tightly scope API tokens, disable unused accounts, and treat any token that has reached a developer workstation as compromised. As defense in depth, run the RAGFlow service under a low-privilege OS account whose readable JSON files contain no credentials or tenant data, since the traversal is bounded to files that parse into the importer's JSON schema; note that this reduces but does not remove exposure, as any readable JSON configuration, credential blob, or export file remains reachable. Additional technical details are in the VulnCheck advisory (https://www.vulncheck.com/advisories/ragflow-through-0.27.2-tenant-import-endpoints-path-traversal) and the upstream issue (https://github.com/infiniflow/ragflow/issues/19122).

Affected VersionsENISA

ragflow 0 ≤0.27.2

Affected Packages

euvd ragflow no fix

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

The issue is a CWE-22 path traversal caused by missing validation of the file_path parameter in RAGFlow's developer/tenant import tooling. The CLI parsers (internal/cli/dev_parser.go for the Go CLI and admin/client/parser.py for the Python admin client) accepted statements of the form 'INSERT CHUNKS FROM FILE "<path>"' and 'INSERT METADATA FROM FILE "<path>"', stripping quotes and passing the string straight through as file_path with no canonicalization, prefix allow-listing, or traversal check. The dispatch layer (internal/cli/cli_http.go for dev_insert_chunks_from_file and dev_insert_metadata_from_file, and admin/client/ragflow_client.py for the corresponding /kb/insert_from_file and /tenant/insert_metadata_from_file POST requests) then forwarded that raw path to the service, which read the referenced file and fed it into the dataset/metadata import pipeline (source evidence points at internal/handler/tenant.go around line 360). Because the read is chained to a JSON-parsing import step, the primitive is a constrained file disclosure: only files that parse into the importer's expected JSON schema and are then written to a dataset leak their contents, which materially limits the class of secrets that can be harvested compared with a general arbitrary-file-read. The upstream patch addresses the root cause by deleting the dev_insert_* commands from the parsers, the CLI command dispatch, and the admin client rather than by adding path-normalization checks.

Know when Ragflow 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 (VulnCheck) PRIMARY 5.3 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
vuln.today AI 4.3 MEDIUM

Network-reachable endpoint needing a valid token (PR:L), low complexity; confidentiality-only and LOW because disclosure is limited to JSON-parseable files, with no integrity or availability impact.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

RAGFlow through 0.27.2 contains a path traversal vulnerability in the dev_insert_chunks_from_file and dev_insert_metadata_from_file endpoints that allows authenticated attackers to read arbitrary files by supplying absolute file paths in the file_path parameter. Attackers with valid access tokens can exploit missing path validation to read any file accessible to the service, with disclosure limited to files matching expected JSON structures that are then written to datasets.

Threat Intelligence Overview

EPSS Score
0.3%
Top 71% exploitable
Prevalence
Medium
popular open-source RAG/LLM engine, moderate self-hosted footprint
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

Attack Technique

Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.

CVE-2024-12433 CRITICAL POC
9.8 Mar 20

A vulnerability in infiniflow/ragflow versions v0.12.0 allows for remote code execution. Rated critical severity (CVSS 9

CVE-2026-24770 CRITICAL POC
9.8 Jan 27

Path traversal vulnerability in RAGFlow RAG engine version 0.23.1 allows unauthenticated attackers to read arbitrary fil

CVE-2024-12450 CRITICAL POC
9.8 Mar 20

In infiniflow/ragflow versions 0.12.0, the `web_crawl` function in `document_app.py` contains multiple vulnerabilities.

CVE-2025-27135 HIGH POC
8.9 Feb 25

RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine. Rated high severity (CVSS 8.9), this vulnerabilit

CVE-2025-69286 HIGH POC
8.9 Dec 31

RAGFlow versions prior to 0.22.0 generate API keys and beta assistant/agent share tokens with a predictable scheme, lett

CVE-2024-10131 HIGH POC
8.8 Oct 19

The `add_llm` function in `llm_app.py` in infiniflow/ragflow version 0.11.0 contains a remote code execution (RCE) vulne

CVE-2025-68700 HIGH POC
8.6 Dec 31

Remote code execution in RAGFlow versions prior to 0.23.0 allows a low-privileged authenticated user (a normal login acc

CVE-2025-25282 HIGH POC
8.1 Feb 21

RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine based on deep document understanding. Rated high s

CVE-2024-12779 HIGH POC
7.5 Mar 20

A Server-Side Request Forgery (SSRF) vulnerability exists in infiniflow/ragflow version 0.12.0. Rated high severity (CVS

CVE-2024-53450 HIGH POC
7.5 Dec 09

RAGFlow 0.13.0 suffers from improper access control in document-hooks.ts, allowing unauthorized access to user documents

CVE-2024-12880 MEDIUM POC
6.5 Mar 20

A vulnerability in infiniflow/ragflow version RAGFlow-0.13.0 allows for partial account takeover via insecure data query

CVE-2026-45312 CRITICAL
9.9 May 29

Server-side template injection in RAGFlow 0.24.0 and earlier allows any authenticated user to execute arbitrary operatin

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