Summary
Multiple Flowise tools previously issued outbound HTTP requests using raw clients (node-fetch, axios) instead of the framework's secured wrapper, bypassing centralized request controls.
When a tool's target URL or parameters can be influenced by user input or external configuration, an attacker may be able to coerce the server into making arbitrary backend HTTP requests, leading to server-side request forgery (SSRF).
Affected context
This issue affects Flowise deployments using tool nodes that rely on raw HTTP clients rather than the secured HTTP wrapper, including:
- OpenAPIToolkit/OpenAPIToolkit.ts
- WebScraperTool/WebScraperTool.ts
- MCP/core.ts
- Arxiv/core.ts
The vulnerability becomes relevant where Flowise flows accept user-supplied URLs, API endpoints, or query parameters that are ultimately passed to these tools, and where the Flowise instance is able to reach internal or otherwise non-public network resources.
Exploit preconditions
- Attack surface: HTTP APIs exposed by the Flowise instance, or any interface that lets users configure tool parameters (such as URLs, domains, or API endpoints).
- Required access: Ability to submit prompts, configure nodes, or otherwise influence the request target or parameters consumed by affected tools.
- Trigger point: Execution of a Flowise flow that invokes one of the affected tools, causing it to perform an outbound HTTP request through node-fetch or axios directly.
- Why exploitation is possible: Direct usage of raw HTTP clients bypasses centralized validation, allowlisting, and proxy logic provided by the secured wrapper. As a result, hostile or unvalidated URLs can be requested from the server's network context.
Why this happens
The core issue is an architectural bypass of standardized, security-aware network access controls. Instead of routing outbound HTTP traffic through a single secured abstraction (the Flowise HTTP wrapper), several tool implementations directly instantiate node-fetch or axios.
This design decision aligns with CWE-918: Server-Side Request Forgery (SSRF): user- or configuration-controlled URLs are invoked from the server side without appropriate validation, allowlisting, or network segmentation. Because these tools operate from the server's perspective, they can inadvertently grant the attacker the ability to pivot into internal services or sensitive metadata endpoints.
Potential impact
- May allow an attacker to probe and interact with internal network services not directly exposed to the internet.
- Could enable access to cloud metadata services and retrieval of temporary credentials or sensitive configuration data.
- Can facilitate partial network reconnaissance (port scanning-style behaviors) from the Flowise server's network position.
- Might be combined with other weaknesses (e.g., permissive internal APIs) to achieve data exfiltration or remote code execution in downstream services.
- May allow abuse of API keys or tokens configured within the Flowise environment if those are automatically attached to outbound requests.
General mitigation guidance
Effective mitigation focuses on consolidating and hardening outbound HTTP behavior:
- Route all tool HTTP requests through a centralized, security-conscious HTTP wrapper that enforces allowlists, protocol restrictions (e.g., no file:// or gopher://), and hostname/IP validation.
- Apply strict URL and domain validation on any user-controlled or dynamic endpoints, favoring explicit allowlists over blocklists.
- Segregate network access so that Flowise components have only the minimal outbound connectivity they require; deny access to cloud metadata endpoints and sensitive internal services where feasible.
- Treat tool configuration and prompt-controlled URLs as untrusted input, validating or normalizing them before use, and avoiding implicit trust in LLM-generated URLs.
- Use defense-in-depth controls such as egress firewalls, HTTP proxies, or service meshes to constrain where server-side tools can connect.
How teams detect issues like this
Detection can combine code-centric and operational approaches:
- Static analysis: Search the codebase for direct imports and use of node-fetch, axios, or other HTTP clients in tool implementations instead of the approved wrapper. Enforce rules that flag any direct outbound HTTP usage outside the central abstraction.
- Code review: Mandate review guidelines that require new tools and integrations to use the secured HTTP wrapper and justify any deviations explicitly.
- Policy enforcement: Use pre-commit hooks or CI policies to reject changes that introduce unauthorized HTTP client usage or that handle URLs without validation.
- Runtime monitoring: Inspect network egress logs for unusual patterns, such as requests from Flowise components to internal IP ranges, link-local addresses, or cloud metadata endpoints.
- Automated tooling: Integrate SAST/IAST tools that recognize SSRF patterns, especially user-controlled URLs reaching HTTP sinks without intermediate checks.

