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.ALLorallowAllAccess(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.

