/

CVE-2026-43995

Severity:

CRITICAL RISK

(9.8)

Server-Side Request Forgery (SSRF) in Flowise Tools

CVE-2026-43995

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Server-Side Request Forgery with potential access to internal services and sensitive metadata

Severity:

CRITICAL RISK

(9.8)

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

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.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-qqvm-66q4-vf5c

Frequently asked

questions

Yes, in typical deployments it can be exploited remotely whenever external users can influence tool parameters (such as URLs) via HTTP APIs, UI flows, or integrations that drive Flowise tools.

The attacker generally needs the ability to create or modify flows, invoke existing flows with custom parameters, or otherwise supply data that the affected tools treat as request targets. No direct access to the underlying infrastructure is required beyond interacting with the Flowise interface or API at the level permitted by the deployment.

Consolidate all outbound HTTP traffic through a hardened, centralized HTTP wrapper and remove direct usage of raw HTTP clients from tools. At the same time, apply strict validation and allowlisting for any URL or endpoint used by tools, so that only explicitly permitted destinations can be reached.

Establish architectural rules that all network I/O must go through vetted abstractions, enforce automated checks to detect direct HTTP client usage, and treat any user- or model-influenced endpoints as untrusted. Regular security reviews of new tools and periodic scanning for SSRF patterns further reduce the chance of reintroducing this class of weakness.

Find out what's already
exploitable in your codebase.