Summary
Budibase's outbound fetch automation flow can be abused by authenticated users with automation permissions to bypass SSRF blacklist protections via DNS rebinding.
By serving different IP addresses during validation and actual connection, an attacker can turn external-looking hostnames into non-blind SSRF requests against internal services reachable from the Budibase host.
Affected context
This vulnerability manifests in Budibase deployments where automation features allow users to configure outbound HTTP requests through the platform's fetch flow. The security check only validates the hostname against a blacklist at one point in time and does not bind the validated IP to the subsequent socket connection. In environments where DNS records can be attacker-controlled, and Budibase has network reachability to internal systems (loopback, RFC1918 addresses, or cloud metadata services), a DNS rebinding attack can convert apparently safe external hostnames into internal SSRF targets.
Exploit preconditions
- Attack surface: Budibase automation actions that issue outbound HTTP requests (e.g., webhooks, integrations, scheduled automations).
- Required access: Authenticated user account with automation permissions capable of configuring or triggering outbound fetch calls.
- Trigger point: Execution of a fetch automation referencing an attacker-controlled hostname that supports DNS rebinding behavior.
- Why exploitation is possible: Hostname validation against a blacklist happens prior to the real network connection, and the resolved IP address is not pinned. A later DNS resolution performed by
node-fetchcan return a different IP (internal/private), allowing the request to be sent to targets that should have been denied.
Why this happens
The core issue is a time-of-check, time-of-use discrepancy in how Budibase validates outbound request destinations. The hostname is checked once against a blacklist using an initial DNS resolution, but the actual socket connection later performs a new DNS lookup that may yield a different IP address. Because the system trusts the hostname-level validation and does not bind or re-validate the resolved IP at connection time, attacker-controlled DNS records can present benign public IPs during validation and then rebind to internal IPs for the actual request. This aligns with CWE-367 (Time-of-check Time-of-use) and CWE-918 (Server-Side Request Forgery), where insufficiently anchored validation permits server-side requests to unintended internal resources.
Potential impact
- Non-blind SSRF to internal HTTP services reachable from the Budibase host
- Access to loopback services (e.g.,
127.0.0.1) that are otherwise non-exposed - Interaction with RFC1918 private network endpoints and internal APIs
- Possible retrieval of cloud provider instance metadata and credentials
- Pivoting into internal systems for further reconnaissance or exploitation
General mitigation guidance
Effective mitigation focuses on hardening outbound request validation and minimizing trust in DNS resolution for security decisions. Patterns include:
- Binding outbound connections to the IP address validated at check time, ensuring subsequent socket connections cannot silently re-resolve to different addresses.
- Validating both hostname and resolved IP against strict allow/deny policies immediately before establishing the network connection.
- Restricting automation features so they cannot freely reach arbitrary hostnames, preferring curated destination lists or allowlists.
- Implementing layered network controls (e.g., egress filters, host firewall rules) to block application-level traffic to known-sensitive ranges such as loopback, RFC1918 blocks, and metadata endpoints.
- Applying least-privilege principles to Budibase runtime environments so that even if SSRF is possible, the reachable internal surface is minimized.
How teams detect issues like this
Detection efforts typically combine code-level and operational signals:
- Static analysis or manual code review to identify outbound HTTP flows where hostname validation is performed separately from the final DNS resolution and socket creation.
- Inspection of SSRF blacklist implementations to verify that IP pinning or re-validation occurs at the moment of connection, not just at configuration or pre-flight stages.
- Logging and monitoring of automation-driven outbound requests, with anomaly detection for traffic to internal ranges, loopback addresses, or metadata service endpoints.
- Policy-based checks in CI/CD pipelines ensuring any new outbound network functionality includes robust SSRF protections and avoids TOCTOU patterns around DNS.
- Optional use of automated security review tools that specialize in SSRF and DNS-related vulnerabilities to flag suspect request flows.

