CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-VMQR-RC7X-3446

CVE-2026-28363: Remote Code Execution in OpenClaw via safeBins Validation Bypass

Amit Schendel
Amit Schendel
Senior Security Researcher

Mar 3, 2026·4 min read·76 visits

Executive Summary (TL;DR)

OpenClaw < 2026.2.23 fails to block abbreviated command-line flags. Attackers can use shortened versions of dangerous flags (like `--compress-p` for `sort`) to bypass the allowlist and achieve Remote Code Execution.

A critical security bypass in OpenClaw's `safeBins` mechanism allows authenticated users to execute arbitrary commands. The vulnerability exploits a discrepancy between OpenClaw's strict string matching validator and the GNU `getopt_long` argument parser used by underlying system binaries. By using unique abbreviations of restricted flags (e.g., `--compress-prog` instead of `--compress-program`), attackers can evade security controls.

Vulnerability Overview

OpenClaw provides a safeBins feature designed to allow the execution of specific system binaries (such as sort, grep, and jq) while restricting dangerous arguments. This feature relies on a deny-list approach, where specific flags known to facilitate arbitrary code execution or filesystem manipulation are explicitly forbidden. For example, the sort utility has the --compress-program flag blocked because it allows the execution of external binaries.

The vulnerability arises from a logic error in how these restrictions are enforced. OpenClaw's validator checks for exact string matches against the deny list. However, standard GNU utilities use getopt_long for argument parsing, which automatically expands unique abbreviations of long options. This discrepancy allows an attacker to supply an abbreviated flag that the validator does not recognize but the underlying binary accepts and executes.

Root Cause Analysis

The root cause is an Incomplete List of Disallowed Inputs (CWE-184) combined with an argument parsing inconsistency. The vulnerability exists because the application attempts to filter input without normalizing it to the canonical form expected by the consumer (the system binary).

In src/infra/exec-safe-bin-policy.ts, the validation logic iterated through user-provided arguments and compared them strictly against a deniedFlags Set. If the user provided --compress-program, the check failed (correctly). However, if the user provided --compress-prog, the check passed because that specific string was not in the deny list. The underlying sort binary, however, treats --compress-prog as an alias for --compress-program due to getopt_long behavior, creating a bypass condition.

Code Analysis

The vulnerable code relied on a direct look-up of the provided argument against a set of forbidden strings. It failed to account for the flexibility of command-line parsers.

// Vulnerable Logic (Simplified)
const deniedFlags = new Set(['--compress-program', '--output']);
 
function validate(args) {
  for (const arg of args) {
    // EXACT match check allows bypass via abbreviations
    if (deniedFlags.has(arg)) {
      throw new Error('Denied flag detected');
    }
  }
}

The fix, introduced in commit 3b8e33037ae2e12af7beb56fcf0346f1f8cbde6f, implements a canonicalization layer. Before validation occurs, the system now resolves all long options to their full names using a logic that mimics getopt_long.

// Patched Logic (Conceptual)
function validate(args) {
  for (const arg of args) {
    // 1. Canonicalize the argument (e.g., '--compress-p' -> '--compress-program')
    const canonical = resolveLongOption(arg, knownFlags);
    
    // 2. Validate the CANONICAL form
    if (deniedFlags.has(canonical)) {
      throw new Error('Denied flag detected');
    }
  }
}

This ensures that any valid abbreviation is expanded to its full form before the security check is applied. If the abbreviation is ambiguous (matches multiple flags), the patch correctly rejects the input.

Exploitation Methodology

Exploitation assumes the attacker has authenticated access to the OpenClaw API and that the tools.exec module is configured with sort as an allowed binary. The attacker sends a JSON payload to the execution endpoint, crafting the arguments to use the abbreviated flag.

  1. Target Selection: Identify the sort binary in the safeBins configuration.
  2. Payload Construction: Use --compress-prog (or any unique prefix like --compress-p) to define the external program sh. Pass the malicious command as an argument to sh.
  3. Execution: The API validates the arguments, fails to find --compress-prog in the deny list, and spawns the process.

Proof of Concept:

{
    "tool": "exec",
    "args": {
        "cmd": "sort",
        "args": [
            "--compress-prog=sh -c 'id > /tmp/pwned'",
            "-o", 
            "/dev/null",
            "/dev/null"
        ]
    }
}

Upon execution, sort interprets the flag as --compress-program and invokes sh, executing the attacker's command.

Impact Assessment

This vulnerability is rated Critical (CVSS 9.9). Successful exploitation results in Remote Code Execution (RCE) with the privileges of the OpenClaw service account.

  • Confidentiality: Attackers can read sensitive files, environment variables, and database credentials accessible to the application.
  • Integrity: Attackers can modify application code, inject backdoors, or alter data stored on the filesystem.
  • Availability: Attackers can terminate the process, delete essential files, or consume system resources (DoS).

The vulnerability is currently weaponized with public exploit scripts available, making immediate remediation essential for all exposed instances.

Remediation

The primary mitigation is to upgrade OpenClaw to version 2026.2.23 or later. This version includes the patch that canonicalizes command-line arguments before validation.

If upgrading is not immediately possible, administrators should update their safeBins configuration to temporarily remove sort and any other binaries that support getopt_long style abbreviations and have known dangerous flags. Note that simply adding --compress-prog to the deny list is insufficient, as attackers can vary the abbreviation length (e.g., --compress-pro, --compress-p). Removing the binary from the allowed list is the only safe configuration workaround.

Official Patches

OpenClawCommit 3b8e33037ae2e12af7beb56fcf0346f1f8cbde6f

Fix Analysis (1)

Technical Appendix

CVSS Score
9.9/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
EPSS Probability
0.09%
Top 75% most exploited

Affected Systems

OpenClaw

Affected Versions Detail

Product
Affected Versions
Fixed Version
OpenClaw
OpenClaw
< 2026.2.232026.2.23
AttributeDetail
CWE IDCWE-184
Attack VectorNetwork (AV:N)
CVSS Score9.9 (Critical)
EPSS Score0.00089
ImpactRemote Code Execution
Exploit StatusWeaponized

MITRE ATT&CK Mapping

T1202Indirect Command Execution
Execution
T1203Exploitation for Client Execution
Execution
CWE-184
Incomplete List of Disallowed Inputs

The software filters or validates input but relies on a list of disallowed inputs that is incomplete or can be bypassed using alternate representations.

Known Exploits & Detection

CXSecurityPublic exploit leveraging sort abbreviation bypass

Vulnerability Timeline

Fix committed by Peter Steinberger
2026-02-21
OpenClaw version 2026.2.23 released
2026-02-23
Public exploit released by Mohammed Idrees Banyamer
2026-02-27
CVE Published
2026-03-02

References & Sources

  • [1]GitHub Advisory GHSA-3c6h-g97w-fg78
  • [2]NVD CVE-2026-28363

More Reports

•2 days ago•CVE-2026-16454
4.3

CVE-2026-16454: Object-Level Authorization Bypass in Eclipse hawkBit Direct Device Integration Controller

CVE-2026-16454 is an object-level authorization bypass vulnerability (CWE-284, CWE-862) in Eclipse hawkBit versions 1.0.3 and prior. The flaw exists within the Direct Device Integration (DDI) REST controller (hawkbit-ddi-resource), where endpoints responsible for enumerating software module metadata and serving firmware binaries fail to verify whether the requested software module is assigned to the authenticated device. Consequently, any device with valid credentials (such as a TargetToken or GatewayToken) can enumerate software module identifiers and download arbitrary firmware artifacts across the entire tenant namespace.

Amit Schendel
Amit Schendel
11 views•9 min read
•2 days ago•CVE-2026-62284
8.6

CVE-2026-62284: Remote Code Execution and SSRF via Unsanitized Kubeconfig in OSAC Operator

CVE-2026-62284 (GHSA-5w5g-j6hw-6p8f) is a code injection and server-side request forgery vulnerability in the console-proxy component of the OSAC Operator. The RemoteConfigResolver parses Kubernetes Secrets containing kubeconfig files via clientcmd.RESTConfigFromKubeConfig without sanitizing execution-related fields. An attacker with RBAC permissions to create or modify labeled Secrets in monitored namespaces can supply a malicious exec credential plugin, resulting in arbitrary command execution within the console-proxy pod.

Amit Schendel
Amit Schendel
8 views•8 min read
•2 days ago•CVE-2026-62361
5.5

CVE-2026-62361: Authenticated SQL Injection and Table Access Control Bypass in Listmonk Subscriber Export

CVE-2026-62361 (GHSA-xgjr-7j9q-2h4r) is an authenticated SQL injection and authorization bypass vulnerability in listmonk, an open-source, self-hosted newsletter and mailing list manager written in Go. In versions prior to 6.2.0, the subscriber export endpoint (GET /api/subscribers/export) directly interpolates user-supplied SQL filter expressions into a PostgreSQL query without invoking the table allowlist validation function (validateQueryTables). Consequently, authenticated users possessing the subscribers:sql_query and subscribers:get_all permissions can bypass relational access controls, execute arbitrary subqueries against restricted tables such as users and settings, and modify database state via writable Common Table Expressions (CTEs).

Alon Barad
Alon Barad
10 views•11 min read
•2 days ago•CVE-2026-28385
5.0

CVE-2026-28385: Server-Side Request Forgery in Canonical LXD Image Import

CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.

Amit Schendel
Amit Schendel
10 views•9 min read
•2 days ago•GHSA-9J25-MM2H-2F76
9.9

CVE-2026-48750: Arbitrary File Write on Host via exec-output Symlink in Canonical LXD and Incus

Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.

Alon Barad
Alon Barad
8 views•12 min read
•2 days ago•GHSA-VGHH-5RFX-XHQ8
9.9

CVE-2026-48749: Arbitrary Host File Read and Write via Malicious Image Symlink in Canonical LXD and Incus

CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.

Amit Schendel
Amit Schendel
8 views•9 min read