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

