/

CVE-2026-56275

Severity:

HIGH RISK

(7.1)

SSRF (CWE-918) in Flowise Execute Flow base URL

CVE-2026-56275

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources

Severity:

HIGH RISK

(7.1)

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 vulnerability in Flowise's Execute Flow node allows attackers to supply intranet or cloud metadata URLs via the base URL field and have the server issue HTTP requests on their behalf.

When security validation is bypassed due to missing secureFetch checks, this becomes risky because external users can reach internal services that would normally be inaccessible from the outside.

Affected context

This vulnerability occurs in Flowise deployments where the Execute Flow node accepts user-controlled base URLs and forwards them to backend HTTP request logic without enforcing strict outbound request policies.

It is relevant when Flowise is deployed in environments that have network connectivity to internal services, intranet APIs, or cloud provider metadata endpoints, and where the same application server is allowed to initiate arbitrary HTTP requests.

Exploit preconditions

  • Attack surface: HTTP interface exposing the Execute Flow node or any feature that lets users configure or trigger flows with a base URL parameter.
  • Required access: Ability to create or modify flows, or otherwise submit requests that control the base URL field; may be via authenticated access, shared workspaces, or exposed APIs.
  • Trigger point: Execution of a flow that causes the backend to call secureFetch or similar request functions without proper verification of the target address.
  • Why exploitation is possible: The httpSecurity.ts logic lacks robust validation of outbound destinations, allowing user input to directly influence the request target and enabling SSRF to internal or metadata endpoints.

Why this happens

The underlying issue is an absence of strict validation and restriction on server-initiated HTTP requests whose destinations are derived from user input.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where untrusted client-controlled URLs are used by the server to perform network calls as a more privileged actor.

In Flowise, the Execute Flow node forwards the base URL into HTTP request logic (e.g., secureFetch) without enforcing rules such as hostname allowlists, IP range checks, or prohibitions on accessing internal addresses and cloud metadata services.

Potential impact

  • Attackers may access internal HTTP services that are not directly exposed to the internet.
  • Attackers could query cloud provider metadata endpoints and potentially obtain sensitive instance or credential information.
  • Attackers can enumerate internal services, ports, and APIs by observing responses to crafted requests.
  • Attackers may pivot to exploit other vulnerabilities on internal services reachable from the Flowise server.

General mitigation guidance

Effective mitigation focuses on restricting where server-initiated HTTP requests are allowed to go and decoupling user input from direct control over outbound destinations.

Common defensive patterns include:

  • Implementing strict allowlists for external domains and APIs that flows are permitted to contact.
  • Rejecting or sanitizing URLs that resolve to private IP ranges, loopback addresses, link-local addresses, and cloud metadata endpoints.
  • Introducing centralized outbound request policies in httpSecurity.ts that all network calls must pass through, with clear checks on hostname, scheme, and port.
  • Minimizing the privileges of the application server and segmenting the network so that sensitive internal services and metadata endpoints are not directly reachable.
  • Providing safer, higher-level abstractions for external integrations that hide raw URL configuration and enforce secure defaults.

How teams detect issues like this

Detection generally relies on identifying unsafe outbound request patterns and monitoring for anomalous network activity originating from the application server.

Helpful approaches include:

  • Static analysis rules that flag use of HTTP client APIs where the URL is derived from user-controlled fields, particularly within flow execution logic.
  • Code review practices that require inspection of any functionality that initiates server-side HTTP requests, ensuring use of centralized security helpers and destination validation.
  • Runtime monitoring of outbound connections for requests to internal IP ranges, cloud metadata endpoints, or unusual domains, coupled with alerting on suspicious patterns.
  • Configuration and policy enforcement that prevent developers from bypassing secureFetch or outbound request wrappers, potentially verified using automated code review tools or CI checks.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-9hrv-gvrv-6gf2
vulncheck.comvulncheck.com/advisories/flowise-server-side-request-forgery-via-execute-flow-base-url

Frequently asked

questions

Yes, it can be remotely exploitable if the Execute Flow functionality or related APIs are accessible to external users who can control the base URL field.

An attacker generally needs the ability to create, modify, or trigger flows that define the base URL, which may require authenticated access or exploitation of any interface that exposes that configuration.

The safest fix is to enforce strict validation and restriction of outbound HTTP destinations using a centralized security layer, allowing requests only to a curated set of external services and blocking internal or metadata addresses regardless of user input.

Prevent SSRF by treating all user-supplied URLs as untrusted, routing all outbound calls through security-aware helpers, applying network egress controls, and incorporating SSRF-focused checks into design reviews, code review guidelines, and automated analysis tools.

Find out what's already
exploitable in your codebase.