/

CVE-2026-41283

Severity:

CRITICAL RISK

(9.9)

Improper Authorization Enabling Remote Code Execution (CWE-863) in OpenStack Mistral API

CVE-2026-41283

Awaiting Analysis

Vulnerability type

Category:

Improper Authorization / Access Control

CWE:

CWE-863, CWE-749

Impact:

Remote Code Execution and Credential Exfiltration

Severity:

CRITICAL RISK

(9.9)

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

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.

Sources

SourceLink
github.comgithub.com/openstack/mistral/tags
security.openstack.orgsecurity.openstack.org/ossa/OSSA-2026-020.html
openwall.comopenwall.com/lists/oss-security/2026/06/03/14
openwall.comopenwall.com/lists/oss-security/2026/06/03/14
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-41283
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2484607
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-41283.json

Frequently asked

questions

Yes. If the Mistral API is reachable from an attacker-controlled network segment and authorization controls are insufficient, an attacker may be able to remotely invoke endpoints that enable code execution.

Exploitation typically requires network access to the Mistral API and either valid but overly-privileged credentials or the ability to abuse misconfigured authorization rules. In some misconfigurations, minimal or unintended roles can be enough to reach high-privilege endpoints.

The most robust approach is to enforce strict authorization on all workflow and execution endpoints, ensuring that only tightly controlled administrative roles or specific service accounts can trigger operations that lead to code execution. This should be combined with least-privilege credentials and reduced network exposure.

Establish a security baseline for API exposure (network segmentation), adopt a conservative RBAC policy with regular reviews, and integrate automated checks for access control changes. In addition, treat any feature that can run code or shell commands as a high-risk operation requiring explicit, narrowly scoped authorization.

Find out what's already
exploitable in your codebase.