/

CVE-2026-45224

Severity:

HIGH RISK

(7.1)

Path Traversal in Crabbox Islo Provider Workspace Resolution

CVE-2026-45224

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Deletion and Overwrite on Host Filesystem

Severity:

HIGH RISK

(7.1)

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

Crabbox versions before 0.9.0 contain a path traversal flaw in the Islo provider that allows crafted workspace paths to escape the intended /workspace directory.

When an attacker can control a .crabbox.yaml or crabbox.yaml file and sync.delete is enabled, they may trigger rm -rf and mkdir -p operations on arbitrary filesystem locations, leading to unintended file deletion or overwrite.

Affected context

This issue occurs in environments where Crabbox is used with the Islo provider and workspace paths are derived from user-supplied or repository-supplied configuration.

The vulnerability is present when:

  • The Islo provider resolves workspace paths from .crabbox.yaml or crabbox.yaml
  • The resolution logic allows absolute or relative paths without enforcing confinement to /workspace
  • The sync.delete option is enabled, causing cleanup logic to run rm -rf and mkdir -p on the resolved workspace path

It primarily affects setups where Crabbox runs with filesystem access beyond the intended isolated workspace directory.

Exploit preconditions

  • Attack surface: Configuration-driven workspace setup in Crabbox (Islo provider).
  • Required access: Ability to introduce or modify .crabbox.yaml or crabbox.yaml in a project, repository, or path processed by Crabbox (e.g., through SCM access, pull requests, or controlling the source directory).
  • Trigger point: Execution of a Crabbox workflow where the Islo provider prepares the workspace and sync.delete is enabled, causing the cleanup/initialization logic to act on the computed path.
  • Why exploitation is possible: The path resolution logic accepts attacker-controlled absolute or relative paths (including traversal sequences like ../) and uses them directly in rm -rf and mkdir -p shell commands without validating or re-confining them to the intended /workspace root.

Why this happens

The root cause is insufficient validation of filesystem paths derived from configuration before using them in destructive file operations.

The Islo provider's workspace resolution code treats user-controlled path values from Crabbox configuration files as trusted and does not normalize and enforce that the effective path remains within the designated /workspace directory.

This maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), where relative segments and absolute paths allow an attacker to escape the intended directory boundary.

Combining this with cleanup logic that invokes rm -rf on the resolved path amplifies the impact from simple directory misplacement to arbitrary file deletion or overwrite.

Potential impact

  • Deletion of arbitrary directories and files accessible to the Crabbox process on the host or container filesystem
  • Overwriting of existing directories by creating new ones at attacker-chosen locations
  • Disruption of CI/CD pipelines or developer environments by removing build artifacts, configuration, or source code
  • Potential deletion of security-related files (logs, temporary data, or local caches), impacting observability and reliability
  • In multi-tenant or shared environments, potential cross-project impact where one configuration affects another project's data

General mitigation guidance

Effective mitigation relies on constraining workspace paths and hardening file operation patterns rather than ad-hoc checks.

Structural defensive measures include:

  • Enforce directory confinement: Normalize and resolve all configured workspace paths against a fixed root (e.g., /workspace), then verify that the resulting absolute path is a descendant of that root before using it.
  • Reject dangerous inputs: Disallow absolute paths and path segments like .. in user-supplied workspace configuration, or provide only a limited, enumerated set of valid workspace names.
  • Decouple destructive operations from untrusted input: Avoid passing raw, configuration-derived paths directly into commands such as rm -rf. Use higher-level filesystem APIs with explicit checks that confirm the target is within an authorized directory.
  • Apply least-privilege filesystem access: Run Crabbox with only the minimal filesystem permissions required, so that even if a path escapes /workspace, it cannot affect system-critical areas.
  • Safe defaults for deletion features: Default sync.delete-like options to disabled or to restrictive behavior, requiring explicit, informed opt-in for destructive cleanup, especially when paths come from version-controlled configuration.

How teams detect issues like this

Potential detection approaches focus on both code-level analysis and operational monitoring:

  • Static analysis and code review:
  • Flag uses of configuration-derived strings in file deletion or directory creation operations (e.g., rm -rf, rmdir, File.delete) without prior normalization and confinement checks.
  • Look for path joining that does not canonicalize and validate the resulting path against a fixed root directory.
  • Review provider implementations (like Islo) for assumptions that configuration paths are safe or pre-validated.
  • Configuration policy enforcement:
  • Implement repository or CI checks that restrict workspace-related keys in .crabbox.yaml / crabbox.yaml to relative, simple paths without traversal segments.
  • Use policy-as-code tools to enforce rules on configuration files that drive build or workspace automation.
  • Runtime monitoring:
  • Monitor Crabbox execution environments for unexpected rm -rf invocations or directory deletions outside known workspace roots.
  • Log and periodically audit resolved workspace paths used by providers to catch anomalies or misconfigurations.
  • Automated tooling:
  • Integrate SAST or custom linters into the development pipeline to detect unsafe path handling patterns and highlight them during code review.

Sources

SourceLink
github.comgithub.com/openclaw/crabbox/commit/6b07193fb5670aac315ea47215651c67b8127868
github.comgithub.com/openclaw/crabbox/pull/65
github.comgithub.com/openclaw/crabbox/releases/tag/v0.9.0
vulncheck.comvulncheck.com/advisories/crabbox-path-traversal-via-islo-provider-workspace-resolution

Frequently asked

questions

It can be, if an attacker can influence the .crabbox.yaml or crabbox.yaml used by a remote Crabbox instance—for example, via a malicious pull request or repository contribution processed by CI. In other deployments, exploitation may be limited to users who can modify local configuration.

The attacker needs the ability to supply or modify the Crabbox configuration that defines the workspace path. This typically corresponds to write access to the project or repository that Crabbox uses as its input.

The most robust fix is to normalize workspace paths and enforce that they remain under a dedicated root directory before passing them to any filesystem operations. Reject or sanitize any path that is absolute or that escapes the allowed root, and avoid direct use of raw configuration values in destructive commands.

Treat all configuration-driven paths as untrusted input, enforce strict directory confinement, and use centralized path-handling utilities that perform canonicalization and validation. Complement this with code review guidelines and automated checks that flag any use of user-controlled paths in file operations without proper validation.

Find out what's already
exploitable in your codebase.