/

CVE-2026-82240

Severity:

HIGH RISK

(8.1)

Authorization Bypass (CWE-862) in Budibase User API

CVE-2026-82240

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Unauthorized Application Access

Severity:

HIGH RISK

(8.1)

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 does not properly validate app-scoped builder role assignments in public user creation and update endpoints. An authenticated builder may exploit this weakness to grant builder access to unrelated applications within the same tenant.

Affected context

The vulnerability occurs in Budibase deployments where app-scoped builders can use public user management endpoints and the server accepts builder application assignments without adequately checking their scope. The risk is present when a request can influence builder role fields for applications outside the caller's authorized set.

Exploit preconditions

  • Attack surface: Public user creation or update API endpoints
  • Required access: An authenticated account with app-scoped builder privileges
  • Trigger point: Processing user role or builder application assignments
  • Why exploitation is possible: The server fails to verify that requested builder access is limited to applications the caller is authorized to manage

Why this happens

The underlying bug is an authorization design failure in which user-supplied role scope is trusted without an object-level permission check. The endpoint validates or processes builder assignment data but does not consistently compare each requested application against the caller's permitted tenant and application scope. This maps to CWE-862: Missing Authorization, because access-control enforcement is absent or incomplete for a protected operation.

Potential impact

  • An authenticated builder may gain unauthorized builder access to other applications
  • Attackers could modify application configuration or content
  • Sensitive application data could be exposed or altered
  • Tenant-level trust boundaries may be weakened
  • Further privilege escalation or business-logic abuse could occur

General mitigation guidance

Mitigation generally focuses on enforcing authorization at the server-side resource boundary rather than trusting client-provided role scope.

Common defensive patterns include:

  • Authorizing every requested application assignment against the acting user's effective permissions
  • Applying deny-by-default checks to role and scope changes
  • Deriving allowable application identifiers from server-side authorization state
  • Separating tenant, application, and administrative permissions explicitly
  • Limiting builder accounts and service identities to the minimum required privileges
  • Auditing role changes and rejecting requests containing out-of-scope assignments

How teams detect issues like this

Detection can include static and dynamic checks for user-management handlers that accept role, scope, or application identifiers without corresponding authorization calls.

Code reviews should examine whether every affected object is authorized individually, whether tenant boundaries are enforced, and whether client-supplied permission fields are treated as untrusted. API monitoring and policy enforcement can flag builder role changes involving applications outside the requester's established scope. Automated security review tools may help identify missing object-level authorization patterns.

Sources

SourceLink
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-468g-55qj-v8rr
vulncheck.comvulncheck.com/advisories/budibase-before-3.41.3-privilege-escalation-via-user-update-api

Frequently asked

questions

Exploitation generally requires an authenticated account with app-scoped builder privileges in an affected Budibase deployment.

Not necessarily. The scope depends on the tenant configuration, endpoint behavior, and the applications represented in the crafted assignment request, but unrelated applications may become accessible.

Enforce server-side, object-level authorization for every application included in a role assignment, using permissions derived from trusted server state rather than client-provided fields.

Apply deny-by-default authorization, test cross-application and cross-tenant access boundaries, audit permission changes, and include authorization checks in code review and automated API security testing.

Find out what's already
exploitable in your codebase.