/

CVE-2026-31829

Severity:

HIGH RISK

(7.1)

SSRF in Flowise HTTP Node for AgentFlow and Chatflow

CVE-2026-31829

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network 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 HTTP Node in AgentFlow and Chatflow can be configured with user-controlled URLs, allowing server-side HTTP requests to arbitrary destinations without host restrictions.

When a chatflow is exposed publicly, any user can abuse this behavior to coerce the Flowise server into making requests to internal or otherwise non-public network resources.

Affected context

This vulnerability appears in Flowise deployments that:

  • Use AgentFlow or Chatflow configurations including the HTTP Node
  • Allow user-controlled or user-influenced URLs to be sent to the HTTP Node
  • Expose chatflows or agents over the internet without strict network egress controls

In such setups, the Flowise server can be abused as an HTTP proxy to reach internal networks, localhost services, or cloud metadata endpoints that would not normally be reachable from the public internet.

Exploit preconditions

  • Attack surface: Publicly accessible Flowise chatflows or AgentFlows that include an HTTP Node.
  • Required access: Ability to interact with a chatflow or agent (e.g., send messages or parameters that influence the requested URL); no direct server access is needed.
  • Trigger point: The moment the HTTP Node processes a request using a URL that is directly or indirectly controlled by the user.
  • Why exploitation is possible: The HTTP Node performs server-side HTTP requests without validating or restricting destination hosts, allowing requests to private IP ranges, localhost, and metadata services.

Why this happens

The core issue stems from treating user-controlled URLs as fully trusted destinations for server-side HTTP requests.

The HTTP Node functions as a generic outbound HTTP client but lacks host validation, network segmentation awareness, or allow/deny lists.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component is tricked into initiating network requests to arbitrary internal or external systems on behalf of an attacker.

Conceptually, the bug class is an over-privileged server-side fetch primitive combined with untrusted input, turning normal HTTP integrations into a network pivot point.

Potential impact

  • Unauthorized access to internal web services, APIs, or admin interfaces that are not exposed to the internet
  • Interaction with cloud metadata endpoints, which can lead to credential exposure or environment data leakage
  • Network scanning of internal hosts and ports using the Flowise server as a vantage point
  • Bypassing IP-based access controls and firewalls that trust the Flowise server's network location
  • Potential chaining with other vulnerabilities on internal services (e.g., exploiting internal-only admin panels)

General mitigation guidance

Effective mitigation focuses on reducing the trust boundary of outbound HTTP requests and constraining where the HTTP Node can connect.

Useful defensive patterns include:

  • Implementing strict allowlists for outbound destinations, limiting the HTTP Node to known, external, HTTPS endpoints
  • Blocking requests to private and link-local address ranges (e.g., RFC 1918, 127.0.0.0/8, 169.254.169.254, ::1) and other non-routable spaces
  • Disallowing or normalizing user-controlled URLs, such as forcing selection from a curated set of base endpoints instead of free-form URLs
  • Enforcing application-layer validation on URLs (scheme, hostname, port) before initiating requests
  • Running Flowise with network egress controls at the infrastructure level (e.g., firewalls, outbound proxies, Kubernetes network policies) to segment access to sensitive internal resources
  • Applying least privilege to any credentials used by Flowise when calling upstream services, minimizing the blast radius of any SSRF attempt

How teams detect issues like this

Detection can rely on both code-centric and runtime-centric approaches:

  • Static analysis & review:
  • Search for HTTP client usage within nodes that consume user-controlled URLs (e.g., generic fetch/http request utilities).
  • Flag patterns where URLs are taken from request payloads, chat parameters, or configuration fields without host validation or filtering.
  • Review node configuration schemas for fields that accept arbitrary URLs and verify whether they are constrained.
  • Policy enforcement:
  • Introduce coding guidelines that require allowlists or host validation for all outbound HTTP nodes.
  • Use CI checks or linters to detect unbounded URL usage in extension nodes or custom connectors.
  • Runtime monitoring:
  • Monitor Flowise server outbound network traffic, especially connections to private ranges, localhost, or cloud metadata IPs.
  • Configure intrusion detection systems or network logs to alert on unusual outbound destinations from the Flowise host.
  • Automated SAST/DAST tools can be used to identify SSRF patterns, but results should always be validated through manual review to understand the actual risk.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-fvcw-9w9r-pxc7

Frequently asked

questions

Yes. When a Flowise chatflow or AgentFlow is exposed over the internet and includes the HTTP Node, an attacker can interact remotely with that flow and provide URLs that cause the server to make internal network requests.

The attacker typically only needs the ability to interact with the public chatflow or API endpoint that ultimately influences the HTTP Node's target URL. No direct shell or administrative access to the Flowise server is required.

Constrain outbound HTTP requests from nodes that accept dynamic URLs by enforcing strict host allowlists, blocking private and metadata address ranges, and validating URL components (scheme, host, and port) before sending requests. Where possible, replace arbitrary URL inputs with selectable, pre-approved endpoints.

Treat any server-side HTTP capability as a sensitive primitive: assume URLs influenced by users are untrusted, require explicit validation and scoping, implement network egress controls around application servers, and embed SSRF checks into code review, architectural design, and automated security testing for any new integration node.

Find out what's already
exploitable in your codebase.