Summary
Budibase versions prior to 3.34.8 contain a server-side request forgery (SSRF) flaw in the AI automation processUrlFile step, which uses fetch(fileUrl) without applying the usual IP blacklist validation.
An authenticated user can abuse this to make the server issue HTTP requests to internal network addresses, potentially reaching services that are not exposed publicly.
Affected context
This vulnerability occurs in Budibase's automation engine, specifically within the AI-related processUrlFile step implemented in packages/server/src/automations/steps/ai/extract.ts.
It applies when:
- Automations are configured to accept or process user-controlled URLs
- The AI
processUrlFilestep is available and callable by authenticated users - The Budibase server has network connectivity to internal or sensitive endpoints that are not otherwise exposed to users
Exploit preconditions
- Attack surface: Budibase automation workflows, particularly AI automation steps that accept a URL or reference processed by
processUrlFile. - Required access: Authenticated access to a Budibase instance with permission to create or trigger automations using the affected step.
- Trigger point: Submission or configuration of a crafted
fileUrlpointing to internal IPs or hostnames (e.g., RFC1918 addresses, metadata endpoints) thatprocessUrlFilewill fetch. - Why exploitation is possible: Unlike other automation steps,
processUrlFileperforms a directfetch(fileUrl)call without applying the common IP blacklist or SSRF protections, allowing arbitrary server-initiated HTTP requests to attacker-chosen targets reachable from the Budibase server.
Why this happens
The underlying issue is inconsistent application of SSRF defenses across automation steps.
While most Budibase automation HTTP interactions are wrapped with IP blacklist checks and validation logic, the processUrlFile function in the AI extract step bypasses this shared protection and issues a raw fetch(fileUrl) call.
This design oversight stems from treating URL input as inherently safe within a new or specialized code path instead of enforcing a centralized network access policy.
Conceptually, this maps to CWE-918: Server-Side Request Forgery (SSRF), where user-influenced URLs lead the server to initiate network requests toward potentially sensitive internal resources.
Potential impact
- Access to internal web services that are not directly exposed to end users
- Enumeration of internal hostnames, ports, and services reachable from the Budibase server
- Interaction with cloud or platform metadata endpoints, which may expose credentials or configuration data
- Pivoting into internal APIs to perform unauthorized actions, depending on trust relationships and network layout
- Collection of sensitive data returned by internal endpoints (configuration, diagnostics, or application data)
General mitigation guidance
Effective mitigation focuses on applying consistent SSRF defenses and tightening the trust boundary around server-initiated HTTP requests:
- Route all outbound HTTP calls through a centralized utility that enforces IP blacklist/allowlist checks, hostname validation, and protocol restrictions.
- Restrict server egress to only the domains and networks required for normal operation (e.g., via firewall rules, VPC security groups, or egress proxies).
- Normalize automation step implementations so that any new step using URLs automatically inherits shared SSRF protections rather than calling network APIs directly.
- Treat user-supplied or indirectly influenced URLs as untrusted input and constrain how they are resolved (e.g., preventing private IP ranges, loopback, link-local, and metadata endpoints).
- Apply least-privilege network design, ensuring application servers cannot directly reach highly sensitive administrative or control-plane services.
- Log and monitor unusual outbound request patterns from automation features, especially to non-standard or internal destinations.
How teams detect issues like this
Detection can combine code-level analysis with runtime monitoring:
- Static analysis: Search for direct usage of low-level HTTP/fetch clients (e.g.,
fetch,axios,http.request) that bypass shared network utilities or omit SSRF filters. Flag any network calls that take user- or workflow-controlled URLs. - Code review signals: In review checklists, include explicit SSRF considerations for any new code that originates outbound requests, verifying that it uses the standard network abstraction layer with IP/host validation.
- Configuration and policy enforcement: Use CI rules or linters to prevent direct network calls outside approved wrappers, and require feature toggles or additional review for new outbound integrations.
- Runtime monitoring: Instrument logs and metrics for automation-driven requests, flagging or rate-limiting access attempts to private IP ranges, unusual ports, or internal-only hostnames.
- Network-level controls: Employ egress filters and IDS/IPS rules to detect anomalous connections from application nodes to sensitive internal segments or metadata services.

