Skip to main content

OpenClaw Windows Node CVE-2026-101884

| EUVDEUVD-2026-90257 HIGH
Incomplete List of Disallowed Inputs (CWE-184)
2026-09-30 VulnCheck GHSA-hf34-gmq4-h679
7.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain gateway or agent access to node
  2. Delivery
    Set unsanitized env var (GIT_CONFIG_*/DOTNET_STARTUP_HOOKS/JAVA_TOOL_OPTIONS)
  3. Exploit
    Invoke allowlisted tool (git/dotnet/java) via system.run
  4. Execution
    Tool loads attacker code from environment
  5. Impact
    Arbitrary code execution with node privileges

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation completeness
Exploitation Conditions

Exploitation requires that the attacker already hold gateway or agent access to an OpenClaw Windows Node running a version before 2026.7.1, which is why PR is not None. From that position the attacker uses the system.run tool, which normally restricts execution to an allowlist of tools (git, dotnet, java). The specific bypass: the ExecEnvSanitizer denylist fails to block the code-loading environment variables GIT_CONFIG_* (git config injection setting core.pager/core.sshCommand/alias.*), the git command hooks GIT_PAGER/GIT_EDITOR/GIT_SEQUENCE_EDITOR/GIT_EXTERNAL_DIFF, the .NET loaders DOTNET_STARTUP_HOOKS/DOTNET_ADDITIONAL_DEPS, and the JVM injectors JAVA_TOOL_OPTIONS/_JAVA_OPTIONS/JDK_JAVA_OPTIONS. Code execution only actually occurs when one of those allowlisted tools is subsequently invoked in the poisoned environment (the AT:P attack requirement). Limiting factors: it is not remote-unauthenticated (requires gateway/agent access), it is Windows-only, and it requires that at least one of git/dotnet/java be present and reachable through system.run.

Impact

This is a genuine high-severity issue but not a top-tier emergency, driven mostly by the RCE technical impact rather than by ease of reach. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H, 7.7) tells a consistent story: network-facing, low complexity, but requiring some privilege (PR:L - the attacker must already have gateway or agent access to the node) and an attack requirement (AT:P) reflecting that code execution only fires when an allowlisted tool (git/dotnet/java) is actually invoked in the poisoned environment. All three impacts are HIGH because the payload achieves arbitrary code execution with the node process's privileges. There is NO EPSS score, NO CISA KEV listing, and NO public exploit - status is 'no public exploit identified at time of analysis.' The absence of exploitation signals combined with the PR:L gate means this is a defense-in-depth / post-compromise-escalation issue rather than a mass-exploitable internet vulnerability: an attacker who already has gateway or agent control (e.g., via prompt injection of the agent) uses it to break out of the system.run command-allowlist sandbox. The root cause is well-confirmed by the vendor patch diff (CWE-184 incomplete denylist). Note the CWE mismatch to verify: NVD/tags imply straightforward RCE but the technical class is an incomplete-blocklist bypass, meaning it chains onto whatever grants gateway/agent access.

Exploit ScenarioDerived

An attacker who has gained gateway or agent access to an OpenClaw Windows Node - for example by prompt-injecting the connected agent - cannot run arbitrary commands directly because system.run enforces a command allowlist. Instead they set environment variables the sanitizer fails to strip (e.g. GIT_CONFIG_COUNT/KEY/VALUE pointing core.sshCommand at a payload, DOTNET_STARTUP_HOOKS to an attacker assembly, or JAVA_TOOL_OPTIONS='-javaagent:evil.jar') and then invoke an allowlisted tool like git, dotnet, or java. The tool loads the attacker-controlled code and executes it with the node's privileges, even though the command string itself never changed. No public PoC exists, but the vendor patch and regression tests fully document the technique.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.7% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 30, 2026

Arbitrary code execution on OpenClaw Windows Node hosts before version 2026.7.1 is achievable by an attacker who already holds gateway or agent access to a node, because the system.run tool's environment-variable sanitizer maintains an incomplete denylist (CWE-184). The attacker supplies variables such as GIT_CONFIG_*, GIT_PAGER, DOTNET_STARTUP_HOOKS, or JAVA_TOOL_OPTIONS alongside a request that runs an allowlisted tool (git, dotnet, java), causing that otherwise-permitted tool to load and execute attacker-controlled code or commands when it is next invoked; this requires the attacker to pass the tool's own arguments unchanged, which is why the attack-complexity/attack-requirements component is elevated. Exploitation is not remote-unauthenticated-it presumes prior gateway or agent access (PR:L), it is Windows-only, and it depends on at least one of git, dotnet, or java being present and reachable through system.run. No public exploit code or confirmed active exploitation was identified at time of analysis; the vendor has released a fixed build.

RemediationAI

Vendor-released patch: upgrade OpenClaw Windows Node to 2026.7.1 or later (release https://github.com/openclaw/openclaw-windows-node/releases/tag/v2026.7.1); the fix commit 261ba11aaad671834ad141bb85101b50cf1a38f6 extends ExecEnvSanitizer to block GIT_PAGER, GIT_EDITOR, GIT_SEQUENCE_EDITOR, GIT_EXTERNAL_DIFF, DOTNET_STARTUP_HOOKS, DOTNET_ADDITIONAL_DEPS, JAVA_TOOL_OPTIONS, _JAVA_OPTIONS, and JDK_JAVA_OPTIONS by name and to prefix-block the entire GIT_CONFIG family, matching the existing LD_/DYLD_ handling. Because the vulnerability requires pre-existing gateway or agent access, the highest-value compensating controls are access-oriented: audit and rotate credentials that grant gateway/agent access, restrict node enrollment to trusted operators, and treat agent access as equivalent to local code execution when scoping trust. If patching must be deferred, remove git, dotnet, and java from the system.run allowlist so the poisoned-tool path cannot be triggered-at the cost of disabling legitimate developer workflows that depend on those tools-or disable the system.run tool entirely for untrusted agents; note that these mitigations degrade core functionality and are temporary. Full details and the vendor's guidance are in the advisory at https://github.com/openclaw/openclaw-windows-node/security/advisories/GHSA-39cf-qcfw-g8pg and the VulnCheck advisory at https://www.vulncheck.com/advisories/openclaw-windows-node-before-2026.7.1-remote-code-execution-via-environment-override.

Affected VersionsENISA

OpenClaw Windows Node 0 <2026.7.1

Affected Packages

euvd openclaw_windows_node fix: 2026.7.1

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 flaw is a classic incomplete-denylist defect (CWE-184) in OpenClaw Windows Node's command-execution path. The system.run tool is intended to restrict execution to an allowlist of well-known developer tools, and it routes child-process environment variables through ExecEnvSanitizer, which blocks dangerous variables either by exact name or by prefix (LD_, DYLD_). The pre-2026.7.1 implementation (visible at src/OpenClaw.Shared/ExecEnvSanitizer.cs lines 15-50) missed entire families of interpreter and tool code-loading variables: git's environment-based config injection (GIT_CONFIG_COUNT with GIT_CONFIG_KEY_n/GIT_CONFIG_VALUE_n, plus GIT_CONFIG_GLOBAL/GIT_CONFIG_SYSTEM redirecting config files, used to set core.pager, core.sshCommand, or alias.* to an attacker command), git's command hooks (GIT_PAGER, GIT_EDITOR, GIT_SEQUENCE_EDITOR, GIT_EXTERNAL_DIFF), the .NET assembly loaders DOTNET_STARTUP_HOOKS and DOTNET_ADDITIONAL_DEPS, and the JVM argument injectors JAVA_TOOL_OPTIONS, _JAVA_OPTIONS, and JDK_JAVA_OPTIONS (which accept -javaagent and similar switches). Because these variables alter the behavior of the tool rather than its command string, an allowlisted invocation of git, dotnet, or java silently executes attacker-supplied code. The fix (commit 261ba11aaad671834ad141bb85101b50cf1a38f6) adds those names to the block list and extends the prefix check to the whole GIT_CONFIG family, mirroring how LD_/DYLD_ are handled, with regression tests covering case-insensitive matching.

Know when Openclaw 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

Vendor (VulnCheck) PRIMARY 7.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.8 HIGH

Network-reachable gateway (AV:N) requiring existing gateway/agent access (PR:L); once there the attacker controls both env and the tool invocation so AC:L; arbitrary code execution yields full C/I/A.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

OpenClaw Windows Node before 2026.7.1 contains an incomplete environment-variable sanitizer in system.run that fails to block GIT_CONFIG_*, DOTNET_STARTUP_HOOKS, and JAVA_TOOL_OPTIONS variables. Attackers with gateway or agent access can supply these variables to allowlisted tools like git, dotnet, or java to load attacker-controlled code and achieve arbitrary code execution.

Technical POC Analysis

Note on metadata: this brief follows CVE-2026-101884 / CWE-184 as supplied.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

OpenClaw Windows Node hosts prior to version 2026.7.1 are affected by a high-severity code execution vulnerability that requires an authenticated attacker with existing gateway or agent access. No public exploit identified at time of analysis, and the vendor has released a patch. Leadership should prioritize remediation because compromised or overly permissive node access could allow unauthorized code execution and lateral movement within Windows environments.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.7%
Top 49% exploitable
Prevalence
Low
niche independent open-source agent node, no broad enterprise footprint
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.7%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

CVE-2026-28446 CRITICAL POC
9.4 Mar 05

Auth bypass in OpenClaw voice-call extension before 2026.2.1. EPSS 0.68%. PoC and patch available.

CVE-2026-33579 CRITICAL POC
9.4 Mar 31

Privilege escalation in OpenClaw (pre-2026.3.28) allows unauthenticated remote attackers to gain administrative access b

CVE-2026-32042 HIGH POC
8.8 Mar 21

OpenClaw versions 2026.2.22 through 2026.2.24 contain a privilege escalation vulnerability that allows authenticated att

CVE-2026-32051 HIGH POC
8.8 Mar 21

An authorization mismatch vulnerability in OpenClaw versions prior to 2026.3.1 allows authenticated users with operator.

CVE-2026-25253 HIGH POC
8.8 Feb 01

OpenClaw versions prior to 2026.1.29 automatically establish WebSocket connections to attacker-controlled gateway URLs e

CVE-2026-32846 HIGH POC
8.7 Mar 26

Path traversal in OpenClaw through version 2026.3.23 enables unauthenticated remote attackers to read arbitrary files in

CVE-2026-100530 HIGH POC
8.5 Sep 26

Directory-context bypass in OpenClaw before 2026.8.1 allows authenticated attackers with user interaction to reuse an 'a

CVE-2026-32064 HIGH POC
8.5 Mar 21

Unauthenticated access to the noVNC observer interface in OpenClaw's Docker sandbox browser allows anyone who can reach

CVE-2026-32055 HIGH POC
7.6 Mar 21

OpenClaw versions before 2026.2.26 allow authenticated attackers to write arbitrary files outside the workspace director

CVE-2026-32056 HIGH POC
7.5 Mar 21

OpenClaw versions prior to 2026.2.22 contain a shell environment variable injection vulnerability in the system.run func

CVE-2026-32049 HIGH POC
7.5 Mar 21

OpenClaw versions prior to 2026.2.22 contain a resource exhaustion vulnerability where the application fails to consiste

CVE-2026-32048 HIGH POC
7.5 Mar 21

OpenClaw versions prior to 2026.3.1 contain a sandbox escape vulnerability that allows authenticated attackers with low

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy