/

CVE-2026-58138

Severity:

CRITICAL RISK

(9.8)

Unauthenticated RCE (CWE-94) via Orkes Conductor

CVE-2026-58138

Deferred

Vulnerability type

Category:

Remote Code Execution via Code Injection

CWE:

CWE-94

Impact:

Unauthenticated Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Orkes Conductor contains an unauthenticated remote code execution flaw where inline workflow definitions can embed arbitrary JavaScript or Python expressions that are evaluated with full host access.

When attackers submit malicious workflows to the public workflow API endpoint, they can execute OS commands on the Conductor server before any authentication or sandboxing is enforced.

Affected context

This vulnerability arises in Orkes Conductor deployments that accept workflow definitions over network-accessible API endpoints.

It primarily affects configurations where GraalVM-based script evaluators are enabled with permissive host access settings (e.g., HostAccess.ALL or allowAllAccess(true)) for INLINE, LAMBDA, DO_WHILE, and SWITCH task types.

Environments that expose the workflow API to untrusted or semi-trusted clients, especially without strict authentication or schema controls, are more likely to be impacted.

Exploit preconditions

  • Attack surface: Publicly reachable workflow API endpoint that accepts inline workflow definitions.
  • Required access: Network-level ability to submit workflow definitions; no valid credentials required under affected configurations.
  • Trigger point: Execution of tasks (INLINE, LAMBDA, DO_WHILE, SWITCH) that evaluate embedded JavaScript or Python expressions via GraalVM.
  • Why exploitation is possible: Script evaluators are configured with broad host access (HostAccess.ALL / allowAllAccess(true)), allowing reflection and subprocess APIs to be invoked directly from attacker-controlled code.

Why this happens

The core issue is the combination of dynamic code evaluation on untrusted input and excessive host integration in the scripting engine.

Orkes Conductor uses GraalVM evaluators to run JavaScript and Python expressions defined inline in workflows. When these evaluators are configured with unrestricted host access, attacker-provided scripts can freely call Java reflection or spawn subprocesses.

This aligns with CWE-94: Improper Control of Generation of Code ('Code Injection'), where user-controlled code is executed without adequate validation, sandboxing, or separation from sensitive system capabilities.

Potential impact

  • Remote attackers may execute arbitrary OS commands on the Conductor server.
  • Attackers could read or modify application data managed by Conductor workflows.
  • Compromise of underlying infrastructure accounts and services accessed by workflows.
  • Lateral movement into adjacent systems reachable from the Conductor host.
  • Complete takeover of the workflow orchestration environment and persistent backdoor installation.

General mitigation guidance

Effective mitigation focuses on limiting where and how dynamic code is executed and reducing the privileges of scripting environments.

Recommended design patterns include:

  • Avoid evaluating arbitrary inline scripts from clients; prefer declarative, data-only workflow definitions with constrained expressions.
  • Configure scripting engines with restricted host access, exposing only tightly scoped, vetted APIs rather than blanket access (e.g., avoid HostAccess.ALL).
  • Introduce sandboxing or policy layers that constrain which libraries, system calls, and environment resources script tasks can touch.
  • Enforce strict authentication and authorization on workflow definition endpoints and treat workflow inputs as untrusted data to be validated.
  • Run the workflow engine using least-privilege OS accounts and isolate it from critical infrastructure components to limit blast radius if a script misbehaves.

How teams detect issues like this

Organizations can detect this class of vulnerability by:

  • Reviewing configuration and code for scripting engine initialization that enables full host access, especially GraalVM options like HostAccess.ALL or allowAllAccess(true).
  • Using static analysis or configuration scanning rules to flag dynamic evaluation of client-provided code within workflow task handlers.
  • Performing code reviews focused on INLINE, LAMBDA, DO_WHILE, and SWITCH task implementations to ensure they do not accept arbitrary executable expressions.
  • Monitoring logs and telemetry for anomalous workflow definitions containing reflective calls, process execution patterns, or unexpected access to system-level APIs.
  • Applying security policy checks in CI/CD to prevent introduction of new unsandboxed evaluators or expansion of script privileges.

Sources

SourceLink
github.comgithub.com/conductor-oss/conductor/commit/87a7d96aabbb706d6e84f812b93da5165028d18f
github.comgithub.com/conductor-oss/conductor/commit/c691e35e768caeb802c9f06ecdd9674c80081af1
github.comgithub.com/conductor-oss/conductor/releases/tag/v3.30.2
cve.orgcve.org/CVERecord?id=CVE-2025-26074
vulncheck.comvulncheck.com/advisories/orkes-conductor-unauthenticated-rce-via-graalvm-script-evaluators

Frequently asked

questions

Yes. When the workflow API endpoint is exposed, attackers can submit malicious workflow definitions remotely and reach the scripting evaluator without needing local access.

Under affected versions and configurations, exploitation can occur prior to authentication, meaning valid credentials are not required if the endpoint is reachable and accepts inline workflows.

The most robust approach is to remove or strictly limit the ability to execute attacker-controlled scripts, combined with restricting host access from interpreters to a minimal, well-defined interface that cannot invoke arbitrary system commands.

Avoid executing user-provided code directly, enforce strong authentication and validation on workflow definition endpoints, use sandboxed interpreters with least privilege, and incorporate security-focused reviews and automated checks whenever dynamic evaluation features are introduced.

Find out what's already
exploitable in your codebase.