/

CVE-2026-46427

Severity:

HIGH RISK

(7.7)

Sensitive Information Exposure in Budibase Snowflake

CVE-2026-46427

Deferred

Vulnerability type

Category:

Sensitive Information Exposure

CWE:

CWE-200

Impact:

Exposure of Authentication Secrets and Unauthorized Access

Severity:

HIGH RISK

(7.7)

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 exposed Snowflake datasource private keys in plaintext because its secret-masking logic only handled password-typed fields and skipped fields typed as SENSITIVE_LONGFORM.

An authenticated BASIC user with any app role could call the datasource retrieval endpoint and receive the full Snowflake PEM private key, risking unauthorized database access and broader environment compromise.

Affected context

This vulnerability appears in Budibase server deployments using the Snowflake integration where datasource configurations are retrievable via the /api/datasources/:datasourceId endpoint.

It specifically affects environments where:

  • Snowflake datasources are configured with a privateKey field typed as SENSITIVE_LONGFORM
  • The same Budibase instance grants BASIC users any application role
  • Datasource metadata is accessible through authorized routes protected by PermissionType.TABLE with PermissionLevel.READ

In such setups, the masking layer applies only to fields typed as DatasourceFieldType.PASSWORD, leaving the Snowflake PEM private key unmasked.

Exploit preconditions

  • Attack surface: HTTP API endpoint GET /api/datasources/:datasourceId on the Budibase server.
  • Required access:
  • Valid authenticated Budibase account classified as BASIC user (non-admin),
  • Any app role that satisfies TABLE read permissions for the targeted datasource.
  • Trigger point: Calling the datasource retrieval endpoint for a Snowflake datasource whose configuration includes a privateKey defined as SENSITIVE_LONGFORM.
  • Why exploitation is possible:
  • The removeSecrets helper filters out only fields typed as DatasourceFieldType.PASSWORD.
  • The Snowflake privateKey field is typed as SENSITIVE_LONGFORM, so it is not recognized as a secret and passes through unmasked.
  • The authorized route design assumes masking occurs at the server layer, so it returns the raw configuration, including the PEM private key.

Why this happens

The underlying issue is an incomplete and type-coupled secret-scrubbing implementation in the Budibase server.

The removeSecrets function in packages/server/src/sdk/workspace/datasources/datasources.ts is designed to strip sensitive values from datasource configurations before they are returned to clients.

However, it relies on a narrow type check, masking only fields whose schema type is DatasourceFieldType.PASSWORD.

The Snowflake integration models its privateKey as SENSITIVE_LONGFORM, which is semantically sensitive but not included in the masking logic.

This mismatch between data classification and masking rules leads to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, because the server returns unredacted secret material to users with broader access than intended.

Potential impact

  • Attackers with BASIC accounts could obtain Snowflake PEM private keys and use them to authenticate directly against Snowflake, depending on external controls.
  • Unauthorized reading or modification of data stored in the Snowflake warehouse connected to the Budibase app.
  • Lateral movement into other systems if the same or similar keys are reused or if Snowflake access yields additional secrets.
  • Breach of data confidentiality and potential regulatory or compliance violations due to exposure of production data.
  • Increased risk of long-lived compromise if private keys are not rotated promptly after leak.

General mitigation guidance

Effective mitigation focuses on robust, schema-independent secret handling and least-privilege data exposure patterns:

  • Treat all fields explicitly marked as sensitive (e.g., SENSITIVE_LONGFORM, secret, token, key) as secrets, not just password-typed fields.
  • Centralize secret classification so that any new secret-like field type is automatically included in masking/redaction routines.
  • Apply a deny-by-default approach: redact all non-essential configuration fields from API responses, whitelisting only metadata required by the client.
  • Separate storage of secrets from general configuration, ideally using dedicated secret stores or encrypted fields that are never returned via general-purpose read endpoints.
  • Enforce least privilege on application roles: only components that strictly require secrets for connection management should access them, and clients should rely on server-side connection management rather than handling raw keys.
  • Encourage operational practices such as key rotation and distinct keys per environment to reduce blast radius if a secret is exposed.

How teams detect issues like this

Detection and prevention can be supported by layered review and policy mechanisms:

  • Static analysis and linters: Define rules that flag API responses returning fields whose names or types suggest secrets (e.g., key, token, secret, privateKey, or custom sensitive enums).
  • Schema-driven checks: Implement tests that iterate over datasource schemas and verify that all fields marked as sensitive are covered by masking logic.
  • Security-focused code review: During review of integration adapters and datasource schemas, explicitly verify that any new secret-like field types are integrated into the redaction pipeline.
  • Runtime logging and monitoring: Monitor access logs for patterns of non-admin users calling configuration endpoints, and alert on anomalous or high-volume reads of datasource definitions.
  • Automated API contract tests: Create regression tests that call configuration endpoints and assert that sensitive values are redacted, using representative datasources like Snowflake as fixtures.

Sources

SourceLink
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-qv26-4hvj-m7fv

Frequently asked

questions

Exploitation is limited to authenticated users who hold at least BASIC accounts with an app role that grants TABLE read permissions on the relevant datasource. It is not directly exploitable by unauthenticated external attackers, but any user who can reach the endpoint with sufficient permissions could extract Snowflake private keys.

The attacker must be able to authenticate to the Budibase instance and have an app role that permits reading datasource configurations through the authorized routes. They do not need administrative privileges; a BASIC user with the right role is sufficient in the vulnerable configuration.

Implement a centralized secret redaction layer that:

  • Treats all sensitive field types (passwords, keys, tokens, long-form secrets) uniformly as secrets,
  • Redacts or omits these fields from all user-facing responses,
  • Uses a default-deny approach where only non-sensitive metadata is exposed by configuration APIs.

Align type systems and security policies so that any field classified as sensitive is automatically subject to masking; add schema-based tests to prevent regressions; design APIs so that clients never need raw secrets; and perform regular security reviews of new integrations and field types to ensure they are included in the secret-handling pipeline.

Find out what's already
exploitable in your codebase.