Summary
Budibase's global user management API endpoints lack proper server-side role-based access control checks, allowing a lower-privileged Creator user to perform actions reserved for tenant owners and admins.
By replaying or crafting requests to the /api/global/users endpoints with their own session token, a Creator can change user roles and account details, potentially leading to full tenant compromise.
Affected context
The vulnerability occurs in Budibase deployments where:
- The
/api/global/usersendpoints are exposed as part of the normal multi-user tenant setup. - Role-based permissions (Viewer, Creator, Tenant Admin, Owner) are intended to restrict who can manage users and roles.
- The backend relies on client-side UI constraints or assumptions, but does not enforce server-side checks for the calling user's role when processing user management requests.
In this context, any authenticated Creator user is able to issue management operations that should be restricted to tenant-level administrators or owners.
Exploit preconditions
- Attack surface: HTTP(S) API endpoints under
/api/global/users. - Required access: Valid authenticated session as a Creator-level user within a tenant.
- Trigger point: Sending requests to user management endpoints that update user roles, permissions, or account details (e.g., promoting/demoting users, editing profile data).
- Why exploitation is possible: The backend accepts and executes user and role modification requests based solely on the request payload and target user identifiers, without validating that the requester's role is authorized to perform those operations. This results in a combination of vertical privilege escalation and IDOR behavior.
Why this happens
The core issue is a missing server-side authorization check on sensitive user management operations, aligning with CWE-862: Missing Authorization.
The API for /api/global/users trusts that any authenticated caller is allowed to manipulate arbitrary user records and roles, instead of:
- Enforcing strict role-based access control (RBAC) on the server for each operation.
- Scoping operations to what the current user is allowed to change.
Because object access decisions are made implicitly (or not at all), a Creator can submit requests that reference other users' identifiers and privileged role changes, and the server processes them without verifying whether the caller's role is permitted to do so. This combines vertical privilege escalation (low role performing high-privilege actions) with an IDOR pattern (direct references to other users' records).
Potential impact
- A Creator user could promote themselves or another low-privileged user to Tenant Admin or equivalent high-privilege role.
- A Creator could demote existing Tenant Admins to App Viewer, effectively locking legitimate administrators out of their management capabilities.
- A Creator could modify the Owner's account details (such as name and other editable fields), potentially causing confusion or assisting in social engineering.
- Full compromise of the tenant environment, including control over users, permissions, and downstream application configurations.
- Persistent loss of integrity for access control policies, with attackers able to maintain elevated privileges.
General mitigation guidance
Effective mitigation generally focuses on enforcing robust server-side authorization for all sensitive operations and strictly scoping what a user can do:
- Implement explicit RBAC checks on the backend for every
/api/global/usersoperation that reads, updates, or deletes user records or roles. The effective permission must be derived from the authenticated user's server-side role, not from client assumptions. - Ensure each endpoint validates that the caller is allowed to perform the specific action (e.g., role changes restricted to Tenant Admin/Owner only; Creators only permitted to perform non-administrative actions).
- Apply object-level access control by verifying that the authenticated user is authorized to act on the target user/resource identified in the request (preventing IDOR-like patterns).
- Prefer secure-by-default controller patterns where handlers declare required permissions/roles, and a central authorization middleware denies requests that do not meet the criteria.
- Minimize the privileges associated with lower roles like Creator and Viewer, and avoid overloading roles with both content and administrative capabilities.
How teams detect issues like this
Organizations can detect and prevent similar access control issues using several complementary approaches:
- Static analysis and code review: Search for controller methods or route handlers under
/api/global/users(and similar administrative paths) that: - Do not call a centralized authorization/permission-checking function.
- Rely solely on authentication checks (e.g., "is logged in") without validating role or ownership.
- Policy enforcement: Introduce architectural rules that any endpoint that modifies user accounts, roles, or permissions must declare required roles/permissions, enforced by middleware or an authorization service.
- Automated tests and security regression tests: Implement integration tests that attempt administrative actions (promote/demote users, edit others' profiles) from lower-privileged accounts and assert that they are denied.
- Logging and monitoring: Log all role changes and user-management actions with actor, target, and result; alert on suspicious patterns such as Creators or Viewers initiating administrative operations or sudden role escalations.
- Optionally use API security testing tools or automated DAST/SAST solutions configured to probe for IDOR and missing authorization across user management endpoints.

