/

CVE-2026-48152

Severity:

HIGH RISK

(8.1)

Broken Access Control / Authorization in Budibase REST

CVE-2026-48152

Deferred

Vulnerability type

Category:

Broken Access Control / Authorization

CWE:

CWE-863

Impact:

Server-Side Secret Disclosure via Broken Authorization

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's REST datasource endpoints allowed users with only a basic application role to perform actions that should be restricted to builders or administrators.

By abusing overly broad table-read based guarding and redacted secret handling, an attacker could exfiltrate builder-configured REST authorization credentials via server-side requests to an attacker-controlled endpoint.

Affected context

This vulnerability affects Budibase instances where:

  • REST datasources and relative-path REST queries are configured by builder/admin users
  • The built-in Basic app user role retains WRITE-level capabilities including table read/write and query write
  • Single-datasource GET and PUT routes are guarded only by generic TABLE READ, without enforcing Builder/Admin permissions or datasource-specific ownership checks

In such environments, application-level users may unintentionally gain the ability to manipulate datasource configuration in ways that interact with stored secrets.

Exploit preconditions

  • Attack surface: Budibase REST API routes for single-datasource GET and PUT operations.
  • Required access: Valid Basic app user role or any role mapped to the WRITE permission set with table read and query write capabilities.
  • Trigger point: Reading an existing REST datasource configuration (with authConfigs redacted), then submitting an update that:
  • Leaves the redaction placeholders intact for secret fields
  • Modifies config.url to an attacker-controlled base URL
  • Preserves or uses an existing relative-path REST query tied to that datasource
  • Why exploitation is possible:
  • Authorization is enforced using generic TABLE READ rather than builder/admin or resource-level ownership checks, so application users can access and modify datasource configuration.
  • During update, mergeConfigs() restores previously stored secrets when it detects redaction placeholders, silently reattaching secrets to attacker-influenced configuration.
  • On execution, Budibase prefixes the attacker-chosen config.url to the relative query path and sends requests with the restored auth headers to an attacker-controlled server, disclosing the authorization secret at the protocol level.

Why this happens

The core issue stems from improper authorization checks on sensitive configuration endpoints combined with implicit secret restoration behavior.

Instead of binding datasource GET/PUT routes to builder/admin roles or enforcing datasource-specific ownership/resource controls, the platform relies on a broad TABLE READ permission that is also granted to Basic app users.

This aligns with CWE-863: Incorrect Authorization, where an operation that requires a higher level of privilege is guarded by a weaker permission that many more users possess.

The problem is amplified by the design of mergeConfigs(), which treats the presence of redaction placeholders as a signal to transparently reinsert stored secrets into the effective configuration.

In abstract terms, the pattern is:

  • Sensitive administrative operations (datasource configuration and secret-bearing auth headers) are exposed through endpoints protected only by generic data-access permissions.
  • Secret masking in responses is cosmetic; the API still allows low-privileged users to influence where those secrets are later applied, effectively turning configuration edits into a vector for server-side secret exfiltration.

Potential impact

  • Attacker-controlled HTTP endpoints can receive requests containing builder-configured REST Authorization headers or tokens.
  • Disclosure of API keys, bearer tokens, or other credentials used in REST datasources.
  • Unauthorized access to third-party services or internal APIs that rely on the compromised credentials.
  • Lateral movement within the environment by reusing stolen tokens against other systems.
  • Compromise of data integrity or confidentiality in upstream services accessed by the REST datasource.

General mitigation guidance

Effective mitigation focuses on tightening authorization boundaries and separating administrative configuration from application-level usage:

  • Enforce role-appropriate authorization: Restrict datasource GET/PUT routes and other configuration endpoints to builder/admin-level roles, and avoid guarding them solely with generic table permissions.
  • Apply resource-level ownership checks: Validate that the caller has explicit rights to manage a given datasource or query, not just the ability to read tables.
  • Decouple secrets from user-controlled configuration: Avoid designs where low-privileged users can influence the targets, paths, or hosts on which existing secrets will be used.
  • Constrain where secrets can be sent: Introduce allowlists or strict rules for endpoints that can receive authenticated requests, especially for server-side HTTP connectors.
  • Harden secret redaction and restoration logic: Treat redacted values as write-only; avoid blindly restoring secrets based on placeholders if the caller lacks explicit secret-management permissions.
  • Limit permissions of basic roles: Review default role mappings so that Basic or equivalent roles are granted only the minimal read/write capabilities required for app usage, not configuration control.

How teams detect issues like this

Organizations can detect and monitor this class of issue through a combination of code-level and operational controls:

  • Static analysis / code scanning:
  • Flag API routes that expose configuration or credentials but are guarded only by broad permissions (e.g., generic table read/write).
  • Identify functions that restore or merge secrets from storage based on placeholder values and ensure they are reachable only from privileged code paths.
  • Code review practices:
  • Require reviewers to verify that endpoints touching datasource configuration, auth headers, or connection details enforce builder/admin or resource-level access checks.
  • Examine changes to role/permission mappings to ensure that application roles cannot gain implicit access to administrative actions.
  • Policy and architectural checks:
  • Use security design reviews to validate that secret-handling flows never depend solely on front-end redaction and that secret restoration is gated by strong authorization.
  • Runtime monitoring:
  • Inspect server logs for requests where low-privileged users modify datasource URLs or connection endpoints.
  • Monitor outbound traffic for unusual destinations receiving authenticated requests from REST connectors, especially newly configured hosts.

Sources

SourceLink
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-3gp5-q4jw-3v94

Frequently asked

questions

Yes, if the Budibase instance is exposed and an attacker can authenticate as a Basic app user (or any role mapped to the relevant WRITE/TABLE READ permissions), they can remotely interact with the affected endpoints and direct authenticated server-side requests to their own infrastructure.

The attacker needs at least application-level credentials mapped to the Basic role or another role that inherits the WRITE permission set and generic TABLE READ access.

No builder or admin privileges are required when the vulnerable authorization model is in place.

The safest pattern is to enforce strict, role-aware authorization on all configuration and secret-bearing endpoints, ensuring only builder/admin-level principals or explicit owners can read or modify datasources and their auth settings.

Additionally, secret restoration logic should be accessible only through privileged paths and should not be driven by untrusted placeholders from low-privileged callers.

Future designs should:

  • Treat configuration and secret management as administrative operations with dedicated, tightly scoped permissions.
  • Use defense-in-depth: combine role checks, resource ownership checks, and explicit secret-management APIs instead of overloading generic data permissions.
  • Ensure redaction is not just a UI concern; back-end logic must enforce that masked secrets cannot be redirected or reused by untrusted roles.
  • Incorporate security threat modeling and authorization-focused reviews into the development lifecycle, especially around connectors, datasources, and secret handling.
Find out what's already
exploitable in your codebase.