Skip to main content
Vulnerability Database/CVE-2026-109432

CVE-2026-109432: Camunda Expression Injection RCE Vulnerability

CVE-2026-109432 is an expression injection RCE flaw in Camunda that allows authenticated users to execute arbitrary commands via malicious JUEL expressions. This post explains its impact, affected versions, and mitigation steps.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-109432 Overview

CVE-2026-109432 is an expression injection vulnerability in Camunda 7 that enables authenticated remote code execution. The flaw resides in AdhocQueryValidator.validate(), which fails to inspect sub-query expression maps within the orQueries field exposed by TaskQueryDto. Attackers bypass the enableExpressionsInAdhocQueries restriction by embedding a malicious Java Unified Expression Language (JUEL) payload inside an orQueries entry. The injected expression invokes java.lang.Runtime.exec through Java reflection, executing operating-system commands as the Camunda engine service user. The issue affects Camunda 7.24.0 before 7.24.14 and 7.23.0 before 7.23.17.

Critical Impact

Authenticated attackers can achieve arbitrary command execution on the host running the Camunda engine, compromising the service account and any data it accesses.

Affected Products

  • Camunda 7, versions 7.24.0 through 7.24.13
  • Camunda 7, versions 7.23.0 through 7.23.16
  • Deployments exposing the ad-hoc query REST API to authenticated users

Discovery Timeline

  • 2026-10-19 - CVE-2026-109432 published to the National Vulnerability Database
  • 2026-10-19 - Last updated in NVD database

Technical Details for CVE-2026-109432

Vulnerability Analysis

Camunda's ad-hoc query API accepts complex TaskQueryDto objects that describe filtering criteria for process tasks. The engine supports expression-backed fields such as dueAfterExpression, which evaluate JUEL expressions at query time. To prevent abuse, administrators can disable expression evaluation through the enableExpressionsInAdhocQueries configuration setting, which is validated by AdhocQueryValidator.validate().

The validator inspects top-level fields of the query DTO but does not recurse into the orQueries collection. Each entry in orQueries is itself a TaskQueryDto that can carry its own expression fields. Because these nested fields escape validation, the engine evaluates attacker-supplied JUEL expressions regardless of the hardening setting. This flaw is categorized as CWE-78, OS Command Injection.

Root Cause

The root cause is incomplete input validation in AdhocQueryValidator.validate(). The method treats orQueries as an opaque container rather than iterating its members and reapplying the expression-restriction policy. The absence of recursive checks produces a validator-expression evaluator mismatch that attackers exploit for policy bypass.

Attack Vector

An authenticated user submits an ad-hoc query request containing an orQueries array. Inside the nested object, the attacker places an expression field such as dueAfterExpression with a JUEL payload that calls Runtime.getRuntime().exec() through Java reflection. The engine evaluates the expression during query planning, launching the attacker's command as the Camunda service user. Because the attack path uses the standard REST API, no privilege escalation is needed to reach the vulnerable code.

No verified public exploit code is available at this time. For technical specifics, see the CodeAnt RCE Research and the VulnCheck Advisory.

Stop Remote Code Execution Before It Runs

Singularity™ Endpoint detects and blocks exploit attempts at machine speed, including zero-days and novel attack techniques.

Stop Exploit Attempts

Detection Methods for CVE-2026-109432

Indicators of Compromise

  • REST requests to Camunda ad-hoc query endpoints containing an orQueries array with any *Expression field, including dueAfterExpression, dueBeforeExpression, or followUpAfterExpression.
  • Child processes spawned by the Camunda Java process, such as sh, bash, cmd.exe, powershell.exe, or curl, during routine query traffic.
  • Outbound network connections initiated by the engine JVM to previously unseen destinations shortly after ad-hoc query activity.
  • Unexpected files written under the Camunda service user's home directory or temporary paths.

Detection Strategies

  • Inspect HTTP request bodies to /engine-rest/task and related ad-hoc query routes for the literal substrings orQueries combined with Expression.
  • Baseline the process tree of the Camunda JVM and alert when it forks a native shell or interpreter.
  • Correlate authentication events with ad-hoc query submissions to attribute suspicious payloads to specific user accounts.

Monitoring Recommendations

  • Enable verbose request logging on the Camunda REST API and forward logs to a central analytics platform for retention and search.
  • Monitor JUEL evaluation errors and stack traces that reference java.lang.Runtime or java.lang.reflect.
  • Track changes to the enableExpressionsInAdhocQueries configuration and alert on toggles that enable evaluation.

How to Mitigate CVE-2026-109432

Immediate Actions Required

  • Upgrade Camunda 7.24.x to 7.24.14 or later, and Camunda 7.23.x to 7.23.17 or later.
  • Restrict access to the Camunda REST API through network controls and strong authentication until patches are deployed.
  • Audit recent ad-hoc query traffic for orQueries payloads containing expression fields and investigate matches.
  • Rotate credentials and secrets accessible to the Camunda service user if compromise is suspected.

Patch Information

Camunda has released fixed builds in versions 7.24.14 and 7.23.17. Enterprise customers can obtain updated artifacts from the Camunda Enterprise Download Documentation. Review the VulnCheck Advisory for upgrade guidance and additional vendor references.

Workarounds

  • Place the Camunda REST API behind a reverse proxy that rejects requests containing orQueries entries with any *Expression field.
  • Run the Camunda engine under a least-privilege service account that cannot spawn shells or write to sensitive directories.
  • Apply operating-system allowlisting to prevent the JVM from executing unauthorized binaries such as sh, bash, or cmd.exe.
  • Limit ad-hoc query API access to a dedicated administrative role and remove the permission from general users.
bash
# Configuration example: block orQueries expression fields at an ingress proxy
# NGINX snippet rejecting ad-hoc queries with expression payloads inside orQueries
location /engine-rest/ {
    if ($request_body ~* "orQueries\".*Expression\"") {
        return 403;
    }
    proxy_pass http://camunda_backend;
}

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.