Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with valid access token
-
DeliveryCall dev_insert import endpoint
-
ExploitSupply absolute path in file_path
-
ExecutionMissing validation reads server file
-
ImpactJSON-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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
A vulnerability in infiniflow/ragflow versions v0.12.0 allows for remote code execution. Rated critical severity (CVSS 9
Path traversal vulnerability in RAGFlow RAG engine version 0.23.1 allows unauthenticated attackers to read arbitrary fil
In infiniflow/ragflow versions 0.12.0, the `web_crawl` function in `document_app.py` contains multiple vulnerabilities.
RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine. Rated high severity (CVSS 8.9), this vulnerabilit
RAGFlow versions prior to 0.22.0 generate API keys and beta assistant/agent share tokens with a predictable scheme, lett
The `add_llm` function in `llm_app.py` in infiniflow/ragflow version 0.11.0 contains a remote code execution (RCE) vulne
Remote code execution in RAGFlow versions prior to 0.23.0 allows a low-privileged authenticated user (a normal login acc
RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine based on deep document understanding. Rated high s
A Server-Side Request Forgery (SSRF) vulnerability exists in infiniflow/ragflow version 0.12.0. Rated high severity (CVS
RAGFlow 0.13.0 suffers from improper access control in document-hooks.ts, allowing unauthorized access to user documents
A vulnerability in infiniflow/ragflow version RAGFlow-0.13.0 allows for partial account takeover via insecure data query
Server-side template injection in RAGFlow 0.24.0 and earlier allows any authenticated user to execute arbitrary operatin
EUVD-2026-81682
GHSA-34x7-7wfj-jp4r
NVD
CVE.org
EPSS
Exploit-DB