Summary
Budibase's SCIM API endpoints lacked proper authorization checks, allowing any authenticated user who could reach the worker to perform user and group management operations.
Under these conditions, a low-privileged user could invoke SCIM endpoints to create, read, update, or delete every user and group in the tenant, leading to full account takeover and tenant-wide disruption.
Affected context
This vulnerability occurs in Budibase deployments that expose the worker's SCIM routes, particularly in Enterprise setups where SCIM is enabled.
The SCIM router in packages/worker/src/api/routes/global/scim.ts only enforced feature-flag and configuration checks, but did not enforce role- or permission-based authorization.
Any authenticated account capable of sending requests to the worker—regardless of role level—could interact with the SCIM API in the affected versions.
Exploit preconditions
- Attack surface: Budibase worker service SCIM endpoints (e.g.,
/scim/Users,/scim/Groups) exposed over HTTP(S). - Required access: Any authenticated Budibase user account that can reach the worker (e.g., BASIC role, workspace-scoped builder, or other non-admin roles).
- Trigger point: Sending crafted SCIM requests (create, update, delete, list) to the SCIM endpoints.
- Why exploitation is possible: The SCIM router applies middleware that only verifies SCIM is configured (
requireSCIM) and sets SCIM context (doInScimContext) but does not enforce authorization logic, so role checks are skipped and all authenticated users are implicitly treated as fully privileged for SCIM operations.
Why this happens
The underlying issue is a missing authorization control on sensitive API endpoints, mapped to CWE-862: Missing Authorization.
In the SCIM router, the middleware stack validates that SCIM is enabled and initializes context, but omits a role- or permission-checking layer before executing handlers that manage users and groups.
As a result, access control decisions are not made at the point where they are needed, and the SCIM operations implicitly trust any authenticated caller without validating whether they are authorized to perform directory-wide identity management actions.
Potential impact
- A low-privileged user may create new privileged accounts (e.g., administrative users) within the tenant.
- An attacker could modify existing users and groups, altering roles, group memberships, and access rights.
- All users and groups in the tenant can potentially be deleted, locking out legitimate users and causing denial of service.
- Sensitive user attributes (emails, names, membership data) can be enumerated and exfiltrated.
- Identity and access management rules enforced via SCIM-integrated directories may be subverted or bypassed.
General mitigation guidance
Effective mitigation focuses on enforcing robust authorization on all identity-management endpoints and ensuring that feature checks are not treated as access control.
Recommended patterns include:
- Applying explicit role- and permission-based guards on SCIM routes, restricting user and group CRUD operations to narrowly defined administrative roles.
- Centralizing authorization logic so that sensitive actions (user creation, role changes, group membership updates) are always passed through a consistent policy engine.
- Designing SCIM handlers according to the principle of least privilege, granting minimal required capabilities and separating read operations from write operations when possible.
- Validating that feature flags or configuration checks do not replace proper authorization checks; they should only influence availability, not permissions.
- Segmenting internal services and applying network-level controls so that only intended frontends or service accounts can reach high-risk management APIs.
How teams detect issues like this
Organizations can detect similar authorization gaps using a combination of architectural review and automated analysis:
- Static analysis / code scanning: Search for route definitions or controllers that manipulate users, groups, or roles but lack calls to common authorization middleware or policy checks.
- Code review indicators: Flag any management or provisioning endpoints (SCIM, admin APIs) that only verify configuration or authentication but do not enforce explicit role-based or attribute-based access control.
- Security testing: Perform role-based API testing to ensure low-privileged accounts cannot access or modify directory resources; integrate these tests into CI pipelines.
- Runtime monitoring: Configure logs and alerts for abnormal patterns such as user management operations initiated by non-admin accounts or from unexpected IP ranges.

