/

CVE-2026-45715

Severity:

HIGH RISK

(7.7)

SSRF in Budibase REST Datasource Redirect Handling

CVE-2026-45715

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access / SSRF

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

A server-side request forgery (SSRF) vulnerability in Budibase's REST datasource integration allows HTTP redirects to bypass IP blacklist checks.

An authenticated Builder can craft a request that follows a redirect through an attacker-controlled server to reach internal services such as cloud metadata endpoints or internal databases.

Affected context

This vulnerability affects Budibase deployments where:

  • The REST datasource integration is used for connecting to external HTTP APIs
  • IP-based blacklists or network allow/deny lists are relied upon to restrict outbound connections
  • Redirect handling is enabled and follows HTTP 3xx responses automatically

The risk is most pronounced in environments where Budibase can reach internal HTTP services (e.g., metadata endpoints, internal APIs, databases exposed over HTTP) from the server network context.

Exploit preconditions

  • Attack surface: REST datasource integration within Budibase server-side code
  • Required access: Authenticated Builder-level access capable of configuring REST datasources and issuing requests
  • Trigger point: A crafted REST request to an attacker-controlled URL that returns an HTTP redirect (3xx) pointing to a blacklisted or internal IP/host
  • Why exploitation is possible: The redirect target is not re-validated against the IP blacklist or network restrictions, so the server follows the redirect and issues a request from a trusted network context to an otherwise blocked internal service

Why this happens

The root cause is incomplete enforcement of network access controls when handling HTTP redirects in the REST datasource integration.

Initial outbound requests are checked against an IP blacklist, but subsequent redirect targets are not re-validated, allowing the original security policy to be bypassed.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where user-controlled parameters cause the server to issue HTTP requests to arbitrary locations, including internal or protected network resources.

Conceptually, the bug class is an SSRF arising from trusting intermediate responses (redirects) without re-applying the same network and IP validation logic used for initial requests.

Potential impact

  • An authenticated Builder could access internal HTTP services that should not be reachable from Budibase
  • Exposure of cloud instance metadata, potentially leading to credential or token disclosure
  • Unauthorized interaction with internal APIs or management endpoints
  • Potential enumeration of internal network services accessible over HTTP/HTTPS
  • Indirect assistance in lateral movement by combining SSRF with other weaknesses

General mitigation guidance

Mitigation usually focuses on enforcing consistent network access controls for all outbound HTTP requests, including redirects:

  • Re-apply IP blacklist/allowlist checks after every redirect, validating the final target before sending the follow-up request
  • Implement strict egress filtering at the network level so that application-layer mistakes cannot directly reach sensitive internal endpoints
  • Prefer hostname and IP allowlists for outbound connections, limiting REST datasources to explicitly approved external services
  • Isolate the application from cloud metadata and internal management interfaces using network segmentation and instance metadata protection features
  • Apply least-privilege principles so that even if SSRF occurs, accessed endpoints expose minimal sensitive data or capabilities

How teams detect issues like this

Organizations can detect this class of vulnerability and its misuse through several approaches:

  • Static analysis or code review rules that flag HTTP client code following redirects without revalidating destinations against network policies
  • Security reviews of integration code that originates from user-configurable endpoints, especially where server-side connectors fetch data based on Builder-provided URLs
  • Centralized logging of outbound HTTP requests from the application, including redirect chains, with alerts on connections to internal IP ranges or metadata endpoints
  • Runtime monitoring and egress firewall logs to identify unusual traffic from the application to internal or restricted network segments

Sources

SourceLink
github.comgithub.com/Budibase/budibase/releases/tag/3.38.1
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-fgqv-jh4g-pvg2

Frequently asked

questions

It requires authenticated Builder access to Budibase, so it is not a fully unauthenticated internet-facing issue. However, once an attacker has such access, they can indirectly reach internal services via the SSRF behavior.

An attacker needs Builder-level permissions that allow configuring REST datasources and issuing HTTP requests. Without this, they cannot control the URLs that Budibase contacts.

The safest pattern is to treat every outbound HTTP request—initial and redirected—as untrusted until its destination is fully validated against strict allowlists or IP/network policies, and to avoid relying solely on redirect-following behavior when internal exposure is possible.

Preventing similar issues typically involves combining secure-by-default HTTP client wrappers (that always enforce IP/host validation), strong egress network controls, architectural isolation of sensitive metadata/internal services, and security reviews for any feature that lets users define outbound endpoints.

Find out what's already
exploitable in your codebase.