/

CVE-2026-22683

Severity:

HIGH RISK

(8.8)

Missing Authorization in Windmill Workspace API

CVE-2026-22683

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation to Remote Code Execution

Severity:

HIGH RISK

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

Windmill incorrectly omits authorization checks on certain workspace endpoints, allowing users with the Operator role to create and modify entities they should not control.

Because Operators can also execute scripts via the jobs API, this gap enables privilege escalation to remote code execution within the Windmill deployment when an Operator abuses script and flow management capabilities.

Affected context

This vulnerability appears in Windmill deployments that:

  • Use versions 1.56.0 through 1.614.0
  • Rely on the documented Operator role to be restricted from creating or modifying workspace entities
  • Expose the backend workspace and jobs APIs to Operator accounts

In this context, workspace endpoints for scripts, flows, apps, and raw_apps do not enforce the intended Operator limitations, even though product documentation and pricing assume those restrictions are in place.

Exploit preconditions

  • Attack surface: Windmill backend workspace and jobs APIs.
  • Required access: A valid Operator-level account within a Windmill workspace (no admin or higher privileges required).
  • Trigger point: Issuing API requests to create or update scripts, flows, apps, or raw_apps, followed by script execution via the jobs API.
  • Why exploitation is possible: Authorization logic does not consistently enforce the Operator role's documented restrictions on entity creation and modification, allowing Operators to manage executable content and then run it.

Why this happens

The core issue is incomplete authorization enforcement for a specific role on sensitive backend endpoints.

While the product model defines Operators as unable to create or modify entities, the underlying access control logic on workspace APIs fails to check and deny these actions for Operator accounts.

This aligns with CWE-862: Missing Authorization, where a system trusts that authenticated users are permitted to perform certain actions without verifying their actual privileges.

Conceptually, the bug is an inconsistent mapping between documented role capabilities and the enforcement rules applied by the API.

Potential impact

  • Operators may create new scripts that run arbitrary code in the Windmill environment.
  • Operators may modify existing scripts, flows, apps, or raw_apps to alter business logic or introduce malicious behavior.
  • Operators can escalate their effective privileges to achieve remote code execution within the Windmill deployment.
  • Operators may access or manipulate data processed by the affected scripts and flows.
  • Operators could undermine separation-of-duties assumptions based on the documented role model.

General mitigation guidance

Effective mitigation revolves around strengthening authorization checks and limiting what lower-privileged roles can change:

  • Ensure that backend APIs consistently enforce role-based permissions, especially on endpoints that manage executable or configuration entities.
  • Centralize authorization logic so that all workspace entity operations (create, update, delete) pass through a uniform permission check rather than relying on client-side or documentation-based constraints.
  • Apply the principle of least privilege for non-admin roles, explicitly denying entity management operations unless they are strictly required.
  • Introduce server-side policy definitions that describe which roles can manage scripts, flows, apps, and raw_apps, and have the API enforce these policies by default.
  • Consider adding workflow-based approvals for changes to executable content in environments where Operators must propose changes but not directly deploy them.

How teams detect issues like this

Organizations can look for this class of issue using a combination of code and behavior analysis:

  • Static analysis and code review:
  • Identify controllers or handlers for workspace entity operations and verify that each path invokes a centralized authorization check using the caller's role.
  • Flag any endpoints that rely solely on authentication (e.g., "is logged in") without checking specific permissions or role capabilities.
  • Access control policy review:
  • Compare documented role capabilities against actual permissions defined in code or configuration, noting discrepancies.
  • Use automated policy-as-code tools to enforce that certain operations (e.g., script creation) are only permitted to specific roles.
  • Runtime monitoring and logging:
  • Log all create/update operations for scripts, flows, apps, and raw_apps along with the initiating role.
  • Alert on patterns where Operator accounts are performing actions that should be restricted, indicating either ongoing exploitation or misconfiguration.

Sources

SourceLink
apps.nextcloud.comapps.nextcloud.com/apps/flow/releases
chocapikk.comchocapikk.com/posts/2026/windfall-nextcloud-flow-windmill-rce/
github.comgithub.com/Chocapikk/Windfall
github.comgithub.com/windmill-labs/windmill/commit/c621a74804f4f6e8318819c01e3a23a17698588b
github.comgithub.com/windmill-labs/windmill/releases/tag/v1.615.0
windmill.devwindmill.dev/

Frequently asked

questions

It is highly exploitable wherever Operator accounts exist because a legitimate Operator can directly call the affected APIs without bypassing authentication or crafting complex payloads.

No. Exploitation only requires access as an Operator within a workspace; higher privileges are not needed to create or modify entities via the backend API and then execute them.

The safest pattern is to centralize authorization and explicitly define which roles may perform each action, then enforce those checks on every relevant endpoint. Do not rely on documentation, UI restrictions, or pricing tiers as a substitute for server-side authorization.

Design and implement role-based access control as code from the outset, add tests that assert which roles can perform each operation, and integrate security review or automated checks into the development and deployment pipeline to catch endpoints that lack proper authorization.

Find out what's already
exploitable in your codebase.