Summary
OpenStack Mistral through 22.0.0 exposes API endpoints that can be abused to execute arbitrary code when they are reachable to an attacker.
If these endpoints are accessible without strict authorization controls, an attacker may remotely run commands in the Mistral context and exfiltrate service credentials or other sensitive data.
Affected context
This vulnerability arises in OpenStack Mistral deployments (through 22.0.0) where the Mistral API is reachable from untrusted networks or overly broad internal audiences.
In such environments, specific workflow or execution-related endpoints can be invoked without sufficient authorization validation to restrict who can trigger code execution.
The risk is amplified in deployments where Mistral is granted access to service credentials or other sensitive secrets used to orchestrate operations across the OpenStack control plane.
Exploit preconditions
- Attack surface: Mistral API endpoints exposed over the network (e.g., public or shared internal interfaces)
- Required access: Ability to send authenticated or misconfigured-unauthenticated HTTP requests to Mistral; in some cases, weak or mis-scoped roles are sufficient
- Trigger point: Invoking workflow or task-related endpoints that directly or indirectly execute code or shell commands
- Why exploitation is possible: Authorization checks on sensitive endpoints are insufficient or missing, allowing users with inadequate privileges—or in misconfigured cases, any reachable client—to trigger actions that lead to arbitrary code execution
Why this happens
The core issue maps to CWE-863: Improper Authorization, where the system fails to verify that the actor invoking a protected operation is permitted to perform it.
In Mistral, workflow and execution APIs are designed to orchestrate complex actions and can include code execution capabilities.
When these powerful endpoints are not guarded by strict role- and scope-based controls, they effectively expose a remote code execution capability to users or services that should not have it.
This is a logic-level access control flaw: the functionality itself behaves as designed, but the authorization layer does not correctly enforce who may use high-privilege operations.
Potential impact
- Remote execution of arbitrary code or commands in the context of the Mistral service
- Exfiltration of service credentials and other secrets accessible to Mistral
- Unauthorized access to other OpenStack services using compromised credentials
- Lateral movement within the cloud control plane and tenant environments
- Full compromise of workflow automation and orchestration pipelines
- Disruption or sabotage of automated operations, including deletion or modification of resources
General mitigation guidance
Effective mitigation centers on tightening authorization boundaries and reducing the blast radius of orchestration components:
- Ensure that code-execution and workflow-execution endpoints are restricted to a minimal set of highly privileged roles and scopes.
- Adopt a strict role-based access control (RBAC) model and regularly audit Mistral roles, policies, and service accounts to confirm that only trusted principals can trigger high-privilege actions.
- Segregate network access to the Mistral API, limiting exposure to administrative or orchestration networks rather than general tenant or public networks.
- Apply least-privilege principles to Mistral's credentials, providing only the permissions needed for workflows and avoiding shared, over-privileged service accounts.
- Where possible, design workflows so that arbitrary command execution is avoided or heavily constrained, favoring parameterized, vetted actions over free-form code.
- Introduce security reviews and threat modeling for new workflows to identify and limit operations that could act as RCE primitives.
How teams detect issues like this
Organizations can improve detection of similar issues and active exploitation by:
- Reviewing Mistral policy and configuration files for endpoints or actions that lack appropriate role or scope restrictions.
- Using static or configuration analysis tools to flag overly permissive RBAC rules, broad wildcards, and "admin-equivalent" roles assigned to non-administrative users.
- Monitoring API logs for unusual usage patterns, such as non-admin users invoking workflow or execution endpoints, or unexpected spikes in task creation and execution.
- Implementing SIEM rules to detect suspicious commands or workflow definitions that include shell execution, file exfiltration, or network reconnaissance.
- Applying automated policy enforcement in CI/CD pipelines for infrastructure-as-code or configuration changes that modify access control rules for Mistral.

