/

CVE-2026-46425

Severity:

CRITICAL RISK

(9.9)

Missing Authorization in Budibase SCIM API Endpoints

CVE-2026-46425

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Full Tenant Compromise

Severity:

CRITICAL RISK

(9.9)

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 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.

Sources

SourceLink
github.comgithub.com/Budibase/budibase/releases/tag/3.38.2
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-q9rw-q89f-jx2f

Frequently asked

questions

Yes, if the Budibase worker's SCIM endpoints are network-accessible, any remote attacker with valid credentials can exploit the issue over HTTP(S). The scope is limited by who can authenticate and reach the worker, but not by role.

The attacker only needs an authenticated Budibase user account and network access to the worker service. Even low-privileged roles such as BASIC users or workspace-scoped builders can abuse the SCIM endpoints in affected versions.

Apply explicit authorization checks to all SCIM routes and other identity-management endpoints, ensuring that only designated administrative roles can perform user and group CRUD operations. Use a centralized access control mechanism so that no sensitive route can bypass authorization by accident.

Adopt a "deny by default" design for all management APIs, enforce role-based or attribute-based access control through shared middleware or policy layers, and complement this with automated tests and reviews that validate low-privileged users cannot reach administrative functions.

Find out what's already
exploitable in your codebase.