/

CVE-2026-41271

Severity:

HIGH RISK

(8.3)

SSRF in Flowise API Chain Components

CVE-2026-41271

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Access to Internal Services and Data Exfiltration

Severity:

HIGH RISK

(8.3)

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

Flowise API Chain components previously contained a Server-Side Request Forgery (SSRF) flaw that allowed crafted prompt templates to make the server initiate arbitrary HTTP requests.

An unauthenticated attacker could abuse these components to reach internal or otherwise restricted endpoints, enabling internal network probing and possible data exfiltration.

Affected context

This vulnerability occurs in Flowise deployments that expose the POST/GET API Chain components and allow user-controlled prompt templates to influence outbound HTTP requests.

It is especially relevant when the Flowise server:

  • Has network connectivity to internal services, metadata endpoints, or other sensitive infrastructure
  • Runs with permissions that allow access to protected APIs or internal-only hosts
  • Does not enforce strict allowlists or hostname/IP validation on API Chain destinations

In such contexts, untrusted users can indirectly control where the server sends HTTP requests.

Exploit preconditions

  • Attack surface: Public or semi-public Flowise instances exposing API Chain components over HTTP(S)
  • Required access: Ability to submit or influence prompt templates used by POST/GET API Chain nodes; no authentication may be required in some setups
  • Trigger point: Execution of an API Chain flow where the destination URL or request parameters are derived from attacker-controlled prompt content
  • Why exploitation is possible: The server trusts user-influenced prompt data when constructing outbound HTTP requests, without robust validation or restriction on target hosts, schemes, or paths.

Why this happens

The root cause aligns with CWE-918: Server-Side Request Forgery (SSRF).

The API Chain components combine user-controlled prompt templates with HTTP request logic in a way that allows users to override or bypass intended API documentation constraints.

Instead of treating prompts as untrusted data, the system implicitly trusts their content when forming request URLs or endpoints, providing a channel for attackers to redirect server-initiated requests to arbitrary internal or external resources.

This pattern reflects a lack of strict outbound request validation, insufficient separation between user input and network control logic, and missing network-layer defense-in-depth such as allowlists or network egress controls.

Potential impact

  • Internal network reconnaissance, including discovery of internal hosts, ports, and services accessible from the Flowise server
  • Access to internal HTTP-based administrative panels, dashboards, or configuration services that are not exposed externally
  • Retrieval of sensitive data from internal APIs, metadata services, or private backend endpoints
  • Use of the Flowise server as a pivot point for further attacks within the infrastructure
  • Interaction with external services in ways that could be used for data exfiltration or abuse of third-party APIs

General mitigation guidance

Effective mitigation focuses on constraining server-initiated HTTP requests and reducing trust in user-controlled prompts:

  • Introduce strict allowlists for outbound HTTP targets that API Chains can reach (hostnames, IP ranges, and schemes).
  • Validate and sanitize all user-controlled values that influence URLs or network destinations, blocking direct control over protocol, host, and port.
  • Separate the concept of "prompt content" from "network configuration" so that user text cannot override documented API endpoints or base URLs.
  • Apply network-level egress controls (firewalls, service mesh policies, VPC security rules) to prevent the Flowise server from reaching internal or highly sensitive infrastructure unnecessarily.
  • Run Flowise with least-privilege network access and credentials, ensuring it cannot access high-value internal services except where strictly needed.
  • Prefer secure, high-level API client abstractions that encapsulate fixed endpoints over generic HTTP clients that accept user-derived URLs.

How teams detect issues like this

Useful detection approaches include:

  • Static analysis rules or linters that flag dynamic URL construction in API Chain code paths where values are derived from prompts or other untrusted fields.
  • Code review checklists that require explicit outbound request validation, host allowlisting, and clear separation between user input and network configuration.
  • Runtime monitoring of outbound HTTP traffic from Flowise instances, with alerts for connections to unexpected internal IP ranges, metadata endpoints, or non-standard ports.
  • Web application firewall (WAF) or API gateway policies that inspect and constrain request parameters used by API Chain endpoints, especially those controlling URLs or hosts.
  • Periodic security tests and SSRF-focused penetration testing targeting exposed Flowise flows to validate that internal resources cannot be reached from user-controllable inputs.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-6r77-hqx7-7vw8

Frequently asked

questions

Yes. If a Flowise instance is accessible over the internet and exposes the vulnerable API Chain components, unauthenticated users may be able to trigger SSRF by crafting malicious prompt templates, subject to the network connectivity of the server.

An attacker generally needs the ability to supply or influence prompt templates or flow inputs that feed into POST/GET API Chain components. In some deployments, this may require only access to a public Flowise UI or endpoint, with no authentication.

The safest pattern is to strictly control server-initiated HTTP requests by enforcing outbound allowlists, decoupling user input from URL and host configuration, and validating any potentially user-controlled network parameters before use. Network egress restrictions and least-privilege connectivity should complement application-level checks.

Treat any user-influenced data as untrusted and never allow it to directly define network destinations. Build flows where endpoints are predefined and centrally configured, apply robust validation and allowlisting for any dynamic aspects, and enforce network-layer controls to prevent access to internal or sensitive resources even if application-level checks fail.

Find out what's already
exploitable in your codebase.