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.

