/

CVE-2026-45548

Severity:

HIGH RISK

(7.7)

SSRF in Budibase AI Automation URL Processing

CVE-2026-45548

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources via server-side requests

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 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 processUrlFile step 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 fileUrl pointing to internal IPs or hostnames (e.g., RFC1918 addresses, metadata endpoints) that processUrlFile will fetch.
  • Why exploitation is possible: Unlike other automation steps, processUrlFile performs a direct fetch(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.

Sources

SourceLink
github.comgithub.com/Budibase/budibase/releases/tag/3.38.4
github.comgithub.com/Budibase/budibase/security/advisories/GHSA-rpj4-7x2v-wjrf

Frequently asked

questions

It is exploitable by any remote user who can authenticate to the affected Budibase instance and create or trigger an automation that uses the vulnerable AI step. The actual requests originate from the Budibase server, not from the user's client.

The attacker must have valid credentials and sufficient permissions to configure or execute automations that invoke the processUrlFile-backed step. Anonymous or unauthenticated users cannot exploit this issue directly.

The most robust approach is to centralize all outbound HTTP requests behind a shared network helper that enforces IP blacklist/allowlist checks and other SSRF mitigations, then ensure every automation step and feature uses that helper instead of making direct fetch calls.

Adopt a secure-by-default network design where application code cannot make arbitrary outbound requests, require that any new feature using URLs passes through established SSRF filters, and enforce this via code review guidelines, automated checks, and network egress controls.

Find out what's already
exploitable in your codebase.