Skip to main content

Appwrite EUVDEUVD-2026-81906

| CVE-2026-89036 HIGH
Improper Neutralization of Argument Delimiters in a Command ('Argument Injection') (CWE-88)
2026-09-17 VulnCheck GHSA-qqx6-v32j-728q
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Authenticate with functions.write/sites.write
  2. Delivery
    Submit deployment with TAB-laced providerRootDirectory
  3. Exploit
    escapeshellcmd fails to strip TABs
  4. Execution
    Injected tar --checkpoint-action=exec runs
  5. Impact
    Execute arbitrary commands as builds worker

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Argument sanitization
Exploitation Conditions

Requires an authenticated Appwrite account (version before 2.0.0) holding functions.write or sites.write permission - this is the primary limiting factor, not an admin-only privilege. The attacker must be able to submit a deployment whose providerRootDirectory parameter reaches the GNU tar command construction in the builds worker; injection succeeds because the code uses escapeshellcmd (which does not escape TAB argument separators) instead of escapeshellarg and does not quote the parameter. No user interaction and no non-default configuration toggle are required - the vulnerable build path is standard. Exploitation is bounded only by the need for the functions.write/sites.write capability and network reachability of the Appwrite instance.

Impact

This is a genuine high-priority issue, not a CVSS-inflated one. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H, base 8.7) is internally consistent with the description: a network-reachable, low-complexity argument-injection flaw achieving full remote code execution as the builds worker process user. The only gating signal is PR:L - exploitation requires an authenticated account holding functions.write or sites.write, which meaningfully narrows the attacker pool but does not require admin/privileged roles, and in many Appwrite deployments project members or self-service developers hold exactly these permissions. The technical mechanism is well-understood and confirmed by source-code evidence: escapeshellcmd (which does not neutralize argument-splitting whitespace) is used instead of escapeshellarg, and the unquoted providerRootDirectory lets injected TAB characters spawn new GNU tar arguments such as --checkpoint-action=exec. No EPSS score, CISA KEV entry, or public POC was provided in the input, so this is best characterized as no public exploit identified at time of analysis - but the low technical barrier (a known tar-injection gadget) and VulnCheck's involvement make weaponization straightforward. Bottom line: real RCE, low complexity, authenticated-but-common privilege - patch promptly.

Exploit ScenarioDerived

An attacker who has (or registers/obtains) an Appwrite account with functions.write or sites.write permission creates or updates a function/site deployment, setting the providerRootDirectory field to a value containing TAB characters followed by a malicious GNU tar flag such as --checkpoint=1 --checkpoint-action=exec=<command>. When the builds worker constructs and runs the tar command, escapeshellcmd fails to neutralize the TABs, tar interprets the injected flags, and arbitrary commands execute as the builds worker process user. No public POC was provided, but the --checkpoint-action=exec tar technique is a well-documented gadget.

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 17, 2026

Argument injection in Appwrite before 2.0.0 allows an authenticated user holding the functions.write or sites.write permission to turn a crafted providerRootDirectory value into arbitrary GNU tar command-line arguments, escalating to remote code execution as the builds worker process user via payloads such as --checkpoint-action=exec. The flaw is not admin-only: the assessed CVSS:3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, vendor score 8.7 under CVSS 4.0) reflects that a low-privileged, authenticated account with deployment-write rights over a reachable Appwrite instance is sufficient, with no user interaction and no non-default configuration required. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; a vendor-released fix is available in Appwrite 2.0.0, making this a genuine high-priority issue rather than a CVSS-inflated one.

RemediationAI

Vendor-released patch: upgrade to Appwrite 2.0.0 (see https://github.com/appwrite/appwrite/releases#release-2.0.0), which contains the upstream fix delivered through pull request https://github.com/appwrite/appwrite/pull/13028 and commit https://github.com/appwrite/appwrite/commit/a82dc6e386a6ac7b88e853a1e6fdb59e0b79ddca; reapplying the corrected code path without upgrading is not a supported substitute. If immediate upgrade is not possible, apply these compensating controls in order of effectiveness: (1) audit and tightly restrict the functions.write and sites.write permissions so that only fully trusted operators can create or update deployments - this directly removes the attacker's foothold, but it constrains normal CI/CD and developer workflows that legitimately need those scopes, and it does not protect against a compromised trusted account; (2) restrict network reachability of the Appwrite API/deployment endpoints to trusted networks or a VPN/zero-trust proxy so untrusted users cannot reach the vulnerable build path - this reduces exposure but is ineffective against insiders or already-compromised credentials; (3) run the builds worker with the least privilege feasible (non-root user, no host mounts, egress filtering, and a hardened/seccomp profile) to limit what an injected command can reach - this is a blast-radius containment measure, not a fix, and it can break builds that legitimately require broader filesystem or network access; (4) monitor build-worker process trees and deployment requests for TAB characters or unexpected tar arguments such as --checkpoint-action, plus abnormal child processes spawned by tar, as a detection control. Note that the supplied reference diff removes the _APP_BUILDS_BACKEND orchestrator selection code, so environments relying on the orchestrator build backend should validate build behavior after upgrading to 2.0.0. No public exploit code has been identified at time of analysis, but the primary control remains patching, since the vulnerable path requires no non-default configuration.

Affected VersionsENISA

Appwrite 0 <2.0.0

Affected Packages

euvd appwrite fix: 2.0.0

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 root cause is CWE-88 (improper neutralization of argument delimiters in a command), a class that is frequently confused with, but distinct from, classic shell metacharacter command injection. Appwrite's build/deployment flow constructs a GNU tar invocation and sanitizes the attacker-influenced providerRootDirectory parameter with PHP's escapeshellcmd() rather than escapeshellarg(), and additionally fails to wrap the parameter in quotes. escapeshellcmd() escapes shell metacharacters (;, |, &, $, newlines, etc.) but deliberately leaves whitespace characters untouched because they are legitimate argument separators; a TAB therefore survives sanitization. When the resulting string reaches the shell, the TAB splits the single intended argument into multiple arguments, letting an attacker append arbitrary GNU tar flags. GNU tar's --checkpoint-action=exec option executes a supplied command each time a checkpoint is reached, converting the argument-injection primitive into command execution in the context of the Appwrite builds worker process. The CPE entry cpe:2.3:a:appwrite:appwrite:*:*:*:*:*:*:*:* with no version bound in the supplied data is consistent with the description's "before 2.0.0" scope, i.e. all prior Appwrite releases are affected. The referenced upstream pull request (#13028) and commit (a82dc6e386a6ac7b88e853a1e6fdb59e0b79ddca) form the patch path for the affected build flow; the visible portion of that diff refactors the deployment backend layer (notably removing the _APP_BUILDS_BACKEND orchestrator/executor toggle and consolidating the Deployment backend class), which is the same code region that dispatches builds.

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

Network-reachable API, low complexity, requires an authenticated functions.write/sites.write user (PR:L), no user interaction, and yields full RCE on the builds worker (C/I/A:H).

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:N/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
None
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

Appwrite before 2.0.0 contains an argument injection vulnerability that allows authenticated users with functions.write or sites.write permissions to execute arbitrary commands by injecting TAB characters into the providerRootDirectory parameter used to construct GNU tar commands. The application uses escapeshellcmd instead of escapeshellarg and fails to quote the parameter, allowing TAB characters to survive sanitization and be interpreted as argument separators, enabling injection of arbitrary GNU tar arguments such as --checkpoint-action=exec to achieve remote code execution as the builds worker process user.

Executive ViewAI

Why It Matters

Appwrite deployments older than 2.0.0 expose organizations to remote code execution from a low-privileged, authenticated account with deployment-write permissions, not only from administrators. A malicious or compromised user could leverage the builds worker to access application secrets, tamper with build outputs, and disrupt or take over hosted services. Because no public exploit has been identified but a vendor fix exists, leadership should treat remediation as a high-priority, time-bound operational risk.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.7%
Top 48% exploitable
Prevalence
Medium
popular open-source backend-as-a-service, but not universally deployed
Data Quality
6 sources
Confidence: High

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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +44
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.

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