/

CVE-2026-29789

Severity:

CRITICAL RISK

(9.9)

Missing Authorization in Vito Workflow Site-Creation Across

CVE-2026-29789

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Cross-Project Privilege Escalation and Unauthorized Resource Management

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

A missing authorization check in Vito's workflow site-creation actions allows an authenticated user with workflow write access in one project to create and manage sites on servers that belong to other projects by specifying a foreign server_id.

This becomes risky in multi-project or multi-tenant deployments where users are expected to be isolated, as it enables unauthorized control over infrastructure they should not manage.

Affected context

The vulnerability occurs in Vito instances where:

  • Multiple projects exist, often serving different teams, applications, or tenants, and
  • Users are granted workflow write access within a specific project but should not manage resources in others.

The issue specifically affects workflow site-creation and related management actions that accept a server_id parameter, where the application does not consistently enforce that the referenced server belongs to the same project as the workflow.

Exploit preconditions

  • Attack surface: Vito web application API or UI endpoints handling workflow site-creation and management.
  • Required access: Authenticated account with workflow write permissions in at least one project.
  • Trigger point: Submitting a site-creation or site-management request that includes a server_id belonging to a different project.
  • Why exploitation is possible: The backend logic does not perform a proper authorization check to ensure that the requesting user (and their project-scoped workflow) is allowed to operate on the referenced server, allowing cross-project resource manipulation based solely on knowledge or guessing of server_id values.

Why this happens

The root cause aligns with CWE-862: Missing Authorization. The application trusts that any provided server_id in workflow site-creation actions is valid for the caller's project, without re-verifying that:

  • The server is owned by, or bound to, the same project as the workflow, and
  • The caller has management rights over that server.

This missing project- and resource-level authorization check creates an insecure pattern where access control is enforced only at the workflow level, not at the underlying server resource level. As a result, an authenticated but otherwise unprivileged user relative to other projects can indirectly operate on foreign servers by passing their identifiers.

Potential impact

  • An attacker could create new sites on servers belonging to other projects.
  • An attacker could manage or modify existing sites on foreign servers, depending on the workflow actions exposed.
  • Cross-project isolation could be broken, leading to unauthorized deployment of PHP applications onto other teams' or tenants' infrastructure.
  • Misconfiguration, downtime, or service disruption on affected servers controlled via unauthorized workflows.
  • Increased blast radius in case a single compromised user account gains unintended control over multiple projects.

General mitigation guidance

Effective mitigation focuses on consistent, resource-level authorization rather than relying solely on project or UI scoping:

  • Enforce checks that bind every workflow site-creation and management action to the project context, verifying that the referenced server_id belongs to the same project as the workflow and is authorized for the current user.
  • Treat all incoming identifiers (such as server_id) as untrusted; re-derive permissions based on the current authenticated user and active project context on the server side rather than trusting client-supplied relationships.
  • Centralize authorization logic into a reusable policy or middleware layer that applies uniform checks to all sensitive actions involving cross-entity relationships (projects, servers, sites, workflows).
  • Implement least-privilege role design so that workflow write access does not implicitly grant broad infrastructure control across projects.
  • Design APIs so that resource selection is constrained by server-side project context (e.g., selecting from the caller's project-bound servers) rather than by arbitrary identifier submission.

How teams detect issues like this

To detect and monitor similar issues:

  • Use static analysis and code review to flag controller or service methods that:
  • Accept resource identifiers (e.g., server_id, project_id) from the client, and
  • Perform state-changing operations without explicit authorization checks linking the resource to the current user and project.
  • During code review, trace how project context is established and ensure that each resource access is validated against it, especially in multi-tenant or multi-project code paths.
  • Apply security tests that attempt cross-project operations by reusing identifiers from one project in another, verifying that requests are rejected.
  • Integrate automated policy enforcement or access control frameworks (e.g., centralized authorization libraries or policy-as-code systems) and validate that workflows, servers, and sites all have consistent access rules.
  • Monitor application logs for patterns such as a single user operating on servers associated with multiple projects, especially when that behavior is not expected under the role model.

Sources

SourceLink
github.comgithub.com/vitodeploy/vito/commit/0fdcfe5f0b93da644a0456e0e4544763828e3326
github.comgithub.com/vitodeploy/vito/pull/1036
github.comgithub.com/vitodeploy/vito/releases/tag/3.20.3
github.comgithub.com/vitodeploy/vito/security/advisories/GHSA-3m6w-8qh4-qr76

Frequently asked

questions

Yes. Any remote user who can authenticate to the Vito instance and has workflow write access in a project can exploit this issue through the web UI or API by targeting foreign server_id values.

The attacker needs a valid account on the Vito instance with permissions to create or manage workflows in at least one project. No direct access to other projects is required; the missing authorization check enables cross-project actions.

The safest pattern is to enforce strict, server-side authorization for every operation that manipulates servers or sites, verifying that the referenced resources belong to the caller's project and that the user holds the necessary role. Centralizing these checks and tying them to a consistent authorization policy reduces the chance of similar gaps.

Preventing similar bugs involves designing APIs around project-scoped resource queries instead of trusting arbitrary IDs, centralizing access control logic, performing security-focused code reviews on multi-tenant boundaries, and adding automated tests that attempt cross-project actions to ensure isolation holds.

Find out what's already
exploitable in your codebase.