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.

