/

CVE-2026-25040

Severity:

HIGH RISK

(8.8)

Improper Authorization in Budibase Role Management

CVE-2026-25040

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Privilege Escalation to Administrative Control

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 versions up to and including 3.26.3 contain an improper authorization flaw in the user invitation API, allowing Creator-level users to invite new accounts with elevated roles such as Admin.

By manipulating backend API requests outside of the normal UI workflow, a Creator can assign arbitrary roles and groups to new users, resulting in full privilege escalation and potential takeover of the workspace or organization.

Affected context

This vulnerability affects Budibase deployments where:

  • Creator-level users exist and can access the application backend APIs,
  • The invitation and role-assignment logic is enforced primarily at the UI layer rather than via server-side permission checks,
  • API endpoints accept role and group assignments directly from the client without robust authorization validation.

In such environments, a Creator who can issue crafted HTTP requests to the Budibase backend may gain access to invitation capabilities and assign elevated privileges to newly invited accounts.

Exploit preconditions

  • Attack surface: Budibase backend HTTP API responsible for user invitations, role assignment, and group membership.
  • Required access: Valid Creator-level account within the target workspace or organization; network access to the Budibase server.
  • Trigger point: Submission of crafted API requests that invoke invitation endpoints with higher-privileged roles or arbitrary group IDs, bypassing UI constraints.
  • Why exploitation is possible: Authorization decisions rely on client-side/UI restrictions instead of strong server-side role checks. The server trusts role and group parameters supplied by a Creator and does not strictly enforce that only Admins may invite users or assign privileged roles.

Why this happens

The root cause is a missing or incorrect server-side authorization check on the user invitation and role assignment functionality.

While the UI hides invitation options from Creators, the backend API still accepts and processes invitation requests containing high-privilege roles and arbitrary group assignments from those users.

This maps to CWE-863: Incorrect Authorization, where the system fails to validate whether the acting user is authorized to perform a privileged action (inviting users and assigning roles), leading to unauthorized elevation of privileges.

Potential impact

  • Creation of new Admin accounts under attacker control.
  • Complete takeover of a Budibase workspace or entire organization.
  • Unauthorized modification or deletion of applications, workflows, and data.
  • Addition of attacker-controlled users to sensitive groups, expanding access to internal tools and systems integrated with Budibase.
  • Long-term persistence via backdoor accounts with elevated privileges.

General mitigation guidance

Effective mitigation centers on enforcing server-side authorization and tightening privilege boundaries around user management:

  • Ensure invitation, role assignment, and group membership changes are guarded by robust backend checks that verify the acting user's role (e.g., only Admins can create or elevate users).
  • Treat all client-supplied role and group identifiers as untrusted; derive permissible roles and groups based on the caller's identity and policy, not on request parameters.
  • Centralize authorization logic for user management operations to avoid duplicated or inconsistent checks between UI flows and APIs.
  • Apply least-privilege by minimizing which roles have access to user and role management capabilities and by separating administrative actions from everyday Creator tasks.
  • Introduce defense-in-depth controls such as requiring additional verification or approval flows for granting administrative roles.

How teams detect issues like this

Detection can focus on both code-level authorization gaps and runtime misuse patterns:

  • Static analysis and code review:
  • Look for user management endpoints (invite, role update, group assignment) that do not consistently validate the caller's role or permission set.
  • Identify API handlers that rely on the client-side UI to hide functionality instead of performing explicit authorization checks.
  • Flag any direct use of client-supplied role or group parameters without mapping them through an authorization policy.
  • Runtime and logging analysis:
  • Monitor audit logs for invitations or role changes initiated by non-admin roles, particularly Creators.
  • Alert on unusual spikes of new Admin or high-privilege accounts or mass additions of users to sensitive groups.
  • Policy enforcement:
  • Enforce organization-wide security policies that require explicit permission checks around administrative operations.
  • Integrate automated security review tools into CI/CD pipelines to detect missing authorization checks on sensitive endpoints.

Sources

SourceLink
drive.google.comdrive.google.com/file/d/1Dtn1WLJILRYUeoMjEbUfCbqQ3g2AW2Qz/view?usp=sharing
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-4wfw-r86x-qxrm
github.comgithub.com/user-attachments/files/22066135/budibase-privileged-esc-poc.txt

Frequently asked

questions

Any authenticated Creator-level user in an affected Budibase instance can exploit this issue, provided they can send custom HTTP requests to the backend API. The vulnerability does not require prior administrative access, but it is limited to users who already have Creator permissions.

No. Exploitation only requires application-level access: an authenticated Creator account and network reachability to the Budibase HTTP API. The attack can be carried out using standard tools (e.g., browser dev tools or API clients) to modify or replay invitation requests.

Consolidate user management logic behind server-side authorization controls that strictly check the acting user's role before allowing invitations, role assignments, or group changes. Never rely solely on UI restrictions, and ensure that all administrative actions are enforced by centralized permission checks in the backend.

Adopt a defense-in-depth authorization strategy: design APIs under the assumption that clients may be malicious, centralize access-control checks, use role- and permission-based guards for every sensitive operation, and maintain comprehensive logging and monitoring of administrative actions. Regular security reviews and automated tests for privilege boundaries help prevent regressions.

Find out what's already
exploitable in your codebase.