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_idbelonging 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_idvalues.
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_idbelongs 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.

