/

CVE-2026-55447

Severity:

CRITICAL RISK

(9.6)

Path Traversal (CWE-61) in Langflow RAG File Components

CVE-2026-55447

Analyzed

Vulnerability type

Category:

Path Traversal / Arbitrary File Read

CWE:

CWE-61, CWE-200

Impact:

Arbitrary File Read and Information Disclosure

Severity:

CRITICAL RISK

(9.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Langflow's RAG file ingestion pipeline allows attackers who can control ingested files or inputs to cause components to read arbitrary files from the host filesystem by absolute path.

When exploited, this behavior can expose sensitive configuration, credentials, or internal application data and is particularly risky in shared or multi-tenant environments.

Affected context

The vulnerability occurs in Langflow deployments that use components derived from BaseFileComponent to ingest documents into RAG workflows.

When file paths or document metadata are treated as trusted input, the node can be steered into reading arbitrary locations on the filesystem by absolute path.

This typically manifests in Docling-based components, the Read File node, NVIDIA Retriever Extraction, Video File processing, and Unstructured API integrations whenever they have access to the underlying file system and lack strict path validation.

Exploit preconditions

  • Attack surface: RAG ingestion endpoints, workflow inputs, or any interface that lets a user supply or influence files or file paths consumed by BaseFileComponent-derived nodes.
  • Required access: Ability to upload files, modify ingestion inputs, or otherwise control data digested into the RAG pipeline for an affected component.
  • Trigger point: Execution of a vulnerable file-based node (e.g., Docling, Read File, Video File) that resolves and reads the attacker-influenced absolute path.
  • Why exploitation is possible: The components accept attacker-controlled file references and do not enforce strict path constraints, allowing direct reads from arbitrary filesystem locations that the Langflow process can access.

Why this happens

At a design level, the affected components treat file paths and related metadata as trusted input and map them directly to filesystem read operations.

This corresponds to CWE-61: Improper Restriction of File Names for Files that are Outside of a Restricted Directory, where user-influenced paths can escape any intended sandbox or working directory.

Because these paths are not normalized, validated, or constrained to a safe root, the underlying file-reading logic can be redirected to sensitive areas of the host.

The resulting data exposure aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, as internal secrets, configuration files, and application state may be returned to the attacker.

Potential impact

  • Attackers may read sensitive configuration files, including API keys or database credentials.
  • They could access logs, prompt histories, or internal RAG content containing private or proprietary information.
  • They can potentially map directory structures and gather system metadata useful for further attacks.
  • Sensitive user data or tenant-specific documents stored on the same host can be exposed.
  • In combination with other flaws, leaked secrets may enable lateral movement or broader system compromise.

General mitigation guidance

Mitigation should focus on confining file access and treating all path-related inputs as untrusted.

Common defensive patterns include:

  • Restricting file operations to a dedicated, sandboxed directory and rejecting any requests that resolve outside this root.
  • Normalizing and validating file paths against an allowlist of directories, patterns, or storage backends rather than accepting arbitrary absolute paths.
  • Decoupling user-facing inputs from direct filesystem paths by using opaque identifiers or managed storage layers.
  • Running Langflow components with least-privilege filesystem permissions so that even if a path is abused, sensitive locations remain inaccessible.
  • Applying strong input validation and explicit rejection of absolute paths or traversal patterns in all BaseFileComponent derivatives.

How teams detect issues like this

Effective detection programs use both code-focused and operational views:

  • Static analysis rules that flag direct use of user-influenced path values in file-open, read, or load calls without preceding normalization or root enforcement.
  • Code review checklists that highlight any component deriving from BaseFileComponent and ensure path constraints and directory whitelists are in place.
  • Centralized logging for file access patterns, with alerts for unusual absolute paths, sensitive directories, or unexpected file types being read by RAG workflows.
  • Security policy enforcement in CI/CD pipelines that prevent introduction of new components performing raw filesystem access based on external input.
  • Occasional dynamic tests or red-team exercises that attempt path traversal and arbitrary file read through RAG ingestion interfaces.

Sources

SourceLink
github.comgithub.com/langflow-ai/langflow/pull/12945
github.comgithub.com/langflow-ai/langflow/security/advisories/GHSA-ccv6-r384-xp75

Frequently asked

questions

Exploitability depends on how users interact with your RAG workflows.

If untrusted or semi-trusted users can upload documents, specify source files, or otherwise influence the ingestion data for BaseFileComponent-based nodes, the risk is high.

In locked-down, purely internal pipelines with tightly controlled inputs, practical exposure may be lower.

The attacker needs the ability to control files or metadata that are digested into the RAG components, such as via file upload endpoints, API calls, or workflow configuration inputs.

They do not need shell or OS-level access; control over ingestion data is sufficient if the component resolves attacker-specified absolute paths.

The most robust fix is to enforce strict filesystem boundaries for all file-based components.

Confine file reading to a dedicated storage root, normalize and validate paths, reject absolute or traversal paths, and avoid exposing raw filesystem locations to user-driven workflows.

Additionally, ensure the runtime account has minimal filesystem privileges outside the intended data directory.

Treat any file path, document reference, or ingestion metadata as untrusted input and mediate it through controlled storage abstractions.

Implement path validation libraries, use object IDs instead of direct paths, and incorporate security checks in design reviews for new components.

Combining these practices with automated static analysis and security-focused code reviews significantly reduces the chance of reintroducing arbitrary file read issues.

Find out what's already
exploitable in your codebase.