/

CVE-2026-41272

Severity:

HIGH RISK

(7.1)

SSRF in Flowise Core Security Wrappers

CVE-2026-41272

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized network access to internal or protected resources via SSRF

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

Flowise's core HTTP security wrappers (secureAxiosRequest and secureFetch) contain logic flaws that allow attackers to bypass SSRF protections and make arbitrary outbound requests from the server.

When the allow/deny lists are misapplied or not enforced, an attacker can exploit DNS rebinding and default configurations to reach internal or otherwise restricted network resources through the Flowise instance.

Affected context

This vulnerability affects Flowise deployments where server-side flows can initiate HTTP(S) requests using secureAxiosRequest or secureFetch.

It is most relevant when:

  • User-controlled or partially trusted input influences request destinations
  • The application relies on allow/deny lists for network egress control
  • The default configuration is used or deny lists are not explicitly defined

Under these conditions, SSRF defenses may not reliably prevent access to internal services, metadata endpoints, or other sensitive network locations.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints or workflow steps in Flowise that accept or derive URLs, hosts, or endpoints from user input or data controlled by an attacker.
  • Required access: Ability to interact with the Flowise UI, APIs, or nodes that cause secureAxiosRequest/secureFetch to be invoked with attacker-influenced URLs or hostnames.
  • Trigger point: Submission or propagation of crafted URLs/hostnames through a flow that appears to be filtered by allow/deny lists.
  • Why exploitation is possible:
  • Logic flaws in the security wrappers introduce Time-of-Check Time-of-Use (TOCTOU) gaps, enabling DNS rebinding to change the resolved IP address after validation.
  • The default configuration does not enforce an effective deny list, leaving sensitive address ranges insufficiently protected.
  • Validation is applied to hostnames or URLs in a way that does not fully account for dynamic DNS behavior or all internal addressing schemes.

Why this happens

The root cause lies in incomplete and logically flawed SSRF mitigation logic inside the HTTP client wrappers.

Instead of enforcing network-layer restrictions at the moment of connection, the code performs hostname or URL checks that can be invalidated between validation and actual use (a TOCTOU pattern that DNS rebinding can exploit).

Additionally, relying on a non-enforcing default configuration leaves the deny list effectively unused, weakening the security posture.

This aligns with CWE-918: Server-Side Request Forgery, where server-side components issue network requests to user-specified locations without robust constraints or isolation.

Potential impact

  • Access to internal services (e.g., databases, message brokers, admin panels) that are not directly exposed to the internet
  • Interaction with cloud instance metadata services, which could lead to credential or token disclosure
  • Network mapping and reconnaissance of internal IP ranges and services
  • Bypassing network segmentation or firewall rules that assume the application server is trusted
  • Pivoting from the Flowise server to other internal assets as part of a broader intrusion

General mitigation guidance

Mitigation focuses on hardening outbound request control and avoiding reliance on fragile hostname-level checks:

  • Enforce strict egress policies at the network layer (firewalls, service mesh, or proxy) so application code cannot directly reach sensitive internal ranges or metadata services.
  • Implement robust IP- and CIDR-based validation that re-resolves and re-checks addresses immediately before connection, accounting for DNS rebinding and redirects.
  • Use explicit, minimal allow lists of external services that flows are permitted to contact, rather than broad or implicit defaults.
  • Ensure deny lists cover common sensitive targets (loopback, link-local, RFC1918 private ranges, metadata endpoints) and are applied consistently, not just in default or optional paths.
  • Separate high-privilege components and sensitive internal services from the network zones reachable by Flowise, applying least-privilege network access.

How teams detect issues like this

Effective detection combines code-level review with runtime monitoring:

  • Static analysis and code review:
  • Look for any HTTP client wrapper that validates hostnames or URLs without re-checking after DNS resolution or redirects.
  • Flag code paths where deny lists are optional, unused, or default to "allow all" behavior.
  • Identify flows where user input (e.g., node parameters, configuration fields) directly influences request URLs or hosts.
  • Runtime and logging:
  • Log outbound requests with resolved IP addresses and correlate them with request initiators to spot calls to internal ranges or metadata endpoints.
  • Use anomaly detection on egress traffic to identify unusual destinations or protocols coming from the Flowise server.
  • Policy enforcement:
  • Integrate security tests in CI/CD that exercise HTTP nodes with attacker-like URLs (internal IPs, metadata services, unusual ports) to verify that policies block them.
  • Consider automated review tools that can highlight SSRF patterns and missing network restrictions in configuration and code.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-2x8m-83vc-6wv4

Frequently asked

questions

Yes, if a Flowise deployment exposes flows or endpoints that let remote users influence HTTP request destinations, an attacker can leverage those interfaces to attempt SSRF, subject to any surrounding access control and network defenses.

The attacker generally needs the ability to configure or trigger flows that cause secureAxiosRequest or secureFetch to run with attacker-controlled URLs.

This could be authenticated access to the Flowise UI, API, or any integration that translates external input into HTTP requests.

Combine robust IP-based validation and re-checking (right before connection) with strict network-layer egress controls.

Avoid relying solely on hostname-based allow/deny lists or permissive defaults, and explicitly block sensitive ranges and metadata endpoints.

Design flows and nodes assuming all externally influenced URLs are untrusted.

Centralize outbound request handling behind hardened proxies or service meshes, use explicit and minimal allow lists, enforce least-privilege network access, and include SSRF-focused tests and reviews as part of your standard security development lifecycle.

Find out what's already
exploitable in your codebase.