Skip to main content

ZeroClaw EUVDEUVD-2026-90258

| CVE-2026-101885 HIGH
Path Traversal (CWE-22)
2026-09-30 VulnCheck GHSA-7wjp-5q22-qfc3
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft plugin with traversal wasm_path
  2. Delivery
    Convince user to install plugin
  3. Exploit
    Installer writes outside plugins dir
  4. Execution
    Overwrite shell startup file
  5. Impact
    Code executes on next shell login

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK

2 techniques across 2 tactics: Discovery, Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires: (1) a ZeroClaw build compiled with the plugins-wasm feature; (2) a version before 0.8.5; (3) plugin signature verification in its default Disabled mode (the patch tests note the path guard is the only gate in that mode); and (4) a victim being persuaded to install an attacker-supplied plugin whose manifest.toml contains a wasm_path with '..' or absolute/root/drive-prefix components. The decisive limiting factor is the required user action (UI:P) - the victim must actively install the malicious package - and the local attack vector (AV:L); there is no remote or unauthenticated path to the sink. Impact is realized only when the overwritten file (e.g., a shell startup script) is subsequently executed.

Impact

This is a genuine but conditional local vulnerability, not a mass-exploitable network flaw. The vendor CVSS 4.0 vector (CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H) scores 8.5 largely because it credits full high confidentiality/integrity/availability impact from the resulting code execution, but the AV:L and UI:P (passive user interaction) metrics correctly capture that an attacker cannot reach the sink remotely - a user must be socially engineered into installing a malicious plugin. No EPSS score was provided, the CVE is not in CISA KEV, and no standalone public exploit was identified; however, the patch commit ships a working regression test (install_rejects_wasm_path_traversal) that concretely demonstrates the '../../pwned.wasm' traversal write, so a reliable reproducer effectively exists in the open. Signal alignment is consistent: this reads as a real but lower-urgency issue whose practical risk hinges on social-engineering the victim, not on raw score. The main caveat is prevalence - ZeroClaw appears to be a small/niche Rust project, so real-world exposure is limited even though the technical impact (code execution via poisoned shell startup files) is severe.

Exploit ScenarioDerived

An attacker publishes a crafted ZeroClaw plugin package whose manifest.toml sets wasm_path to a traversal path like '../../.bashrc' or another shell startup file. When a victim running a vulnerable ZeroClaw build (with the plugins-wasm feature, before 0.8.5) is convinced to install it, the installer writes the attacker-controlled file outside the plugins directory, planting code that executes the next time the user opens a shell. A functional reproducer is embedded in the fix's regression tests, so the technique is publicly demonstrable even though no packaged exploit is catalogued.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% 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 file write during plugin installation in ZeroClaw before 0.8.5 (when built with the plugins-wasm feature) lets attackers place files outside the plugins directory by supplying a crafted manifest.toml whose wasm_path field contains '..' or absolute/root/drive-prefix components; overwriting shell startup files or similar executed content yields code execution under the victim's account. The attack is local (AV:L) and unauthenticated per the assessed vector (PR:N), but it requires user interaction (UI:P/UI:R) - the victim must be persuaded to install the attacker-supplied plugin package - and only functions when plugin signature verification is left in its default Disabled mode, making the path check the sole gate. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor has released a fix in v0.8.5.

RemediationAI

Vendor-released patch: upgrade to ZeroClaw 0.8.5 (release tag v0.8.5), which incorporates commit 432e034d3cb024610d5916a2f328678d151c1dd5 adding the validate_manifest_subpath guard that rejects absolute, '..', root, and drive-prefix wasm_path values; see the advisory at https://github.com/zeroclaw-labs/zeroclaw/security/advisories/GHSA-93f6-34w8-5g98 for the full coordinated disclosure. Where upgrading is not immediately possible, the most effective compensating control is to treat plugin installation as a trusted operation: only install plugin packages from sources you control and inspect each manifest.toml for a wasm_path that stays inside the package (a relative name with no '..'), since the traversal only triggers on an attacker-supplied manifest - the trade-off is that this relies entirely on operator discipline and does not scale to untrusted plugin ecosystems. Additionally, enable plugin signature verification instead of the default Disabled mode, because the upstream regression test notes the path guard is the only gate when signatures are off; the trade-off is that this requires provisioning and managing signing keys and will reject any previously unsigned plugins. If WASM plugins are not required in a deployment, building ZeroClaw without the plugins-wasm feature removes the vulnerable install path entirely, at the cost of losing plugin functionality. No vendor-released patch beyond 0.8.5 was identified, and no public exploit code was identified at time of analysis.

Affected VersionsENISA

ZeroClaw 0 <0.8.5

Affected Packages

euvd zeroclaw fix: 0.8.5

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

ZeroClaw is a Rust-based agent/runtime that supports loadable WebAssembly plugins when compiled with the plugins-wasm feature. The vulnerable code lives in crates/zeroclaw-plugins/src/host.rs, where the plugin host reads a plugin package's manifest.toml and later joins the manifest-supplied wasm_path to the plugin/destination directory (plugin_dir.join(p) / dest_dir.join(p)) during discovery and installation. Because no validation was performed, a value such as '../../pwned.wasm' resolves outside the plugins directory, writing attacker-controlled bytes to an arbitrary location reachable by the process's permissions - the classic CWE-22 path traversal root cause. The upstream fix (commit 432e034d) adds a validate_manifest_subpath helper that rejects any wasm_path that is absolute or contains ParentDir, RootDir, or Windows Prefix components, returning PluginError::InvalidManifest; regression tests confirm both that a traversal path is rejected with nothing written outside the plugins directory and that a legitimate relative wasm_path still installs. Critically, the commit's own test comments state signature mode is Disabled by default, so the new path guard is the only barrier in the default configuration.

Know when Zeroclaw 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 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

Local because the malicious plugin must be installed on the host (AV:L); UI:R since the user must be tricked into installing it; PR:N as no prior privileges are needed, and arbitrary file write yields full code execution (C/I/A:H).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
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

ZeroClaw versions before 0.8.5 built with plugins-wasm feature contain a path traversal vulnerability in plugin installation that fails to validate the wasm_path manifest field. Attackers can convince users to install crafted plugins that write arbitrary files to paths outside the plugins directory, such as shell startup files, enabling code execution.

Technical POC Analysis

Advisory GHSA-93f6-34w8-5g98 reports High 7.8 (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and notes "No known CVE" at publication; the CVE record assigns 8.5.

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

ZeroClaw installations prior to version 0.8.5 that were compiled with the plugins-wasm feature allow a crafted plugin manifest to write files outside the intended plugins directory, which can overwrite shell startup files and lead to code execution under the user's own account. Because this capability is gated only by a path check whenever plugin signature verification remains in its default Disabled state, any user persuaded to install a malicious plugin package effectively hands an attacker a foothold on their workstation or build host. Leadership should care because the affected population is end users and developers running ZeroClaw plugin workflows, and a successful compromise can spread laterally through developer credentials and local configuration files.

Business Impact: High
Compensating Controls

Apply vendor patch. (Interim: enable plugin signature verification instead of the default Disabled mode, and restrict plugin installation to trusted sources.)

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Rare
obscure indie Rust agent project, negligible 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.2%
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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.

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

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