/

CVE-2026-25045

Severity:

HIGH RISK

(8.8)

Broken Access Control / Missing Authorization

CVE-2026-25045

Analyzed

Vulnerability type

Category:

Broken Access Control / Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Full Tenant Compromise

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

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/users endpoints 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/users operation 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.

Sources

SourceLink
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-2g39-332f-68p9

Frequently asked

questions

Any authenticated Creator-level user in an affected Budibase tenant can potentially exploit this issue. Exploitation is scoped to the tenant where the attacker has a Creator account but may affect all users and roles within that tenant.

No. The vulnerability specifically allows a non-admin Creator to perform actions reserved for Tenant Admins or Owners, such as changing roles and modifying other users' details.

Centralize and enforce server-side authorization for all user and role management endpoints. Each operation should have clearly defined required permissions, and the backend must verify that the authenticated user meets these requirements before acting on any target user or resource.

Adopt a "deny by default" access control model, require every new endpoint to specify required roles or permissions, and enforce these via shared authorization middleware. Combine this with thorough code review practices, automated tests for privilege boundaries, and periodic security assessments focused on IDOR and broken access control patterns.

Find out what's already
exploitable in your codebase.