/

CVE-2026-29611

Severity:

HIGH RISK

(7.5)

Local File Inclusion / Path Handling in OpenClaw

CVE-2026-29611

Analyzed

Vulnerability type

Category:

Local File Inclusion / Path Handling

CWE:

CWE-73

Impact:

Arbitrary Local File Read and Data Exfiltration

Severity:

HIGH RISK

(7.5)

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

OpenClaw's BlueBubbles extension contains a local file inclusion vulnerability in its media path handling, where user-controlled paths are accepted without proper validation.

An attacker who can trigger sendBlueBubblesMedia with arbitrary mediaPath values may read and exfiltrate sensitive local files, such as /etc/passwd, as media attachments.

Affected context

This vulnerability affects OpenClaw installations where:

  • The BlueBubbles extension is installed and enabled
  • Media attachments are processed using the sendBlueBubblesMedia function
  • Media paths are accepted from external or semi-trusted sources (e.g., client requests, plugin inputs)

The issue arises when the application constructs file reads directly from the mediaPath parameter without enforcing an allowlist or restricting paths to designated media directories.

Exploit preconditions

  • Attack surface: Application interface that invokes sendBlueBubblesMedia (e.g., HTTP API, messaging bridge, or extension API).
  • Required access: Ability to supply or influence the mediaPath argument (authenticated or unauthenticated, depending on deployment configuration).
  • Trigger point: A request or action that causes the BlueBubbles extension to process a mediaPath and read from the filesystem.
  • Why exploitation is possible: The code treats mediaPath as inherently trustworthy and does not validate it against an allowlist of safe directories or file types, allowing arbitrary local paths to be supplied and read.

Why this happens

The underlying issue is improper handling of file paths derived from externally influenced input.

The sendBlueBubblesMedia function appears to directly use mediaPath to locate files on the local filesystem without:

  • Enforcing an allowlist of permitted directories or filename patterns
  • Normalizing and validating canonical paths
  • Preventing traversal or absolute-path usage

This maps to CWE-73: External Control of File Name or Path, where user-controlled input influences file system access operations, leading to unauthorized file reads.

Potential impact

  • Exposure of sensitive system files (e.g., /etc/passwd, configuration files, logs).
  • Disclosure of application secrets such as API keys, tokens, and credentials stored on disk.
  • Leakage of user data and conversation history if stored on the same host.
  • Facilitation of further attacks, including privilege escalation or lateral movement, by revealing internal configuration and environment details.

General mitigation guidance

Effective mitigation centers on constraining how file paths are derived and accessed:

  • Restrict media file access to a small set of predefined, application-controlled directories.
  • Implement an explicit allowlist for acceptable file types and relative paths; reject absolute paths and directory traversal sequences.
  • Normalize and resolve requested paths to their canonical form and verify they reside within approved directories before allowing read operations.
  • Separate and minimize privileges for the component that performs file I/O, limiting the sensitivity of files it can access even if path validation fails.
  • Use secure-by-default APIs or helper functions that encapsulate path validation logic so individual call sites are less likely to implement custom, error-prone checks.

How teams detect issues like this

Detection typically involves reviewing and constraining file access patterns:

  • Use static analysis to identify file I/O operations that use variables derived from external input (e.g., parameters like mediaPath passed into open/read calls).
  • During code review, flag any use of user-supplied strings to construct file paths, especially when absolute paths or traversal patterns are not explicitly blocked.
  • Implement runtime logging and monitoring of file access paths used for media operations, alerting on attempts to access system directories or non-media locations.
  • Apply security policies in CI/CD that require centralized, vetted utilities for filesystem access, preventing ad-hoc path construction in new code.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/71f357d9498cebb0efe016b0496d5fbe807539fc
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-rwj8-p9vq-25gv
vulncheck.comvulncheck.com/advisories/openclaw-local-file-inclusion-via-mediapath-parameter-in-bluebubbles-media-handling

Frequently asked

questions

It can be, if the interface that triggers sendBlueBubblesMedia is exposed over the network and accepts user-controlled mediaPath values. In such deployments, a remote attacker could potentially read local files on the server.

The attacker needs the ability to influence or supply the mediaPath parameter. Depending on configuration, this might require authenticated access to a messaging or API endpoint, or it may be possible from any client if path input is not adequately restricted.

Constrain file reads to a small set of dedicated media directories, enforce an allowlist of permissible paths and file types, and reject any absolute or traversal-containing paths before performing filesystem operations.

Avoid using raw user input to construct file paths; instead, map user choices to server-side identifiers or pre-defined filenames, centralize path validation logic, and incorporate static analysis and security review practices that specifically check for externally controlled file path usage.

Find out what's already
exploitable in your codebase.