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

