/

CVE-2026-30820

Severity:

HIGH RISK

(8.8)

Authorization Bypass in Flowise Admin APIs

CVE-2026-30820

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation and Unauthorized Administrative Actions

Severity:

HIGH RISK

(8.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

Flowise versions prior to 3.0.13 improperly trust the x-request-from: internal HTTP header to decide whether a request is internal, allowing tenants to bypass authorization checks on /api/v1/** endpoints.

With only an authenticated browser session, a low-privilege tenant can call internal administration APIs such as API key management, credential stores, and custom function execution, resulting in effective privilege escalation.

Affected context

This vulnerability affects Flowise deployments where:

  • Multi-tenant or shared environments are used
  • HTTP clients can set arbitrary headers, including x-request-from
  • The server treats the presence of x-request-from: internal as proof that a request is trusted or internal
  • Authorization logic for /api/v1/** endpoints relies on this header rather than a robust trust boundary

In such setups, any authenticated tenant session operating through a browser or API client may be able to reach internal administration functionality.

Exploit preconditions

  • Attack surface: Flowise HTTP API, specifically /api/v1/** endpoints including administrative and internal routes.
  • Required access: Valid low-privilege tenant session (e.g., standard user account with a browser cookie).
  • Network position: Ability to send HTTP requests to the Flowise server (often over the public or internal network where the app is exposed).
  • Trigger point: Crafting requests that include the header x-request-from: internal so that the server treats them as internal.
  • Why exploitation is possible: The authorization layer implicitly trusts a client-controlled header as evidence of internal origin, allowing a normal tenant to bypass intended access control checks for administrative APIs.

Why this happens

The root cause is an authorization decision based on a spoofable client header, rather than on a verifiable trust boundary or authenticated role.

This aligns with CWE-863: Incorrect Authorization, where the system fails to enforce proper authorization on sensitive endpoints. Flowise assumes that any request presenting x-request-from: internal is trusted and internal, but HTTP clients can freely set or modify such headers. As a result, low-privilege tenants can masquerade as internal callers and access endpoints that should require elevated privileges or backend-only access. The defect is conceptual: mixing logical trust boundaries (internal vs external) with untrusted client-provided metadata.

Potential impact

  • Low-privilege tenants may invoke internal administrative APIs.
  • Attackers could manage or exfiltrate API keys and other secrets from credential stores.
  • Unauthorized execution of custom functions or flows that run with elevated or system-level permissions.
  • Exposure or modification of configuration that affects other tenants or the overall system.
  • Potential lateral movement across tenants by abusing shared administrative resources.
  • Integrity and confidentiality compromise of data processed by Flowise.

General mitigation guidance

Effective mitigation generally involves removing trust from client-controlled headers and enforcing strict, server-side authorization policies:

  • Avoid using request headers under the client's control (such as custom x-* headers) as the primary signal of being an "internal" caller.
  • Enforce role- and tenant-based access control at the controller or route level for all /api/v1/** endpoints, including internal or admin routes.
  • Isolate truly internal endpoints behind non-public network interfaces, service-to-service authentication, or dedicated internal gateways.
  • Centralize authorization logic so administrative operations are guarded by explicit privilege checks rather than ad-hoc flags or headers.
  • Apply least-privilege design for tenant roles, ensuring that API keys, credentials, and function-execution capabilities are never exposed to roles that do not require them.
  • Consider defense-in-depth controls such as rate limiting, audit logging, and anomaly detection on sensitive administrative actions to reduce the blast radius of misuse.

How teams detect issues like this

Detection can focus on both code-level patterns and runtime behavior:

  • Static code review / analysis:
  • Search for authorization logic conditioned on request headers like x-request-from, X-Forwarded-*, or similar client-controlled attributes.
  • Identify controller methods for /api/v1/** that lack explicit authentication and authorization checks or rely on a generic "internal" flag.
  • Enforce secure coding guidelines that forbid using client headers as proof of internal origin.
  • Configuration and architecture review:
  • Validate that internal-only endpoints are not reachable from public networks.
  • Confirm that API gateway or reverse proxy configurations do not pass sensitive internal-only headers from untrusted clients.
  • Runtime and log-based monitoring:
  • Monitor logs for tenant-originated traffic that includes x-request-from: internal or other internal markers.
  • Alert on low-privilege accounts performing administrative operations, especially outside normal operational patterns.
  • Automated tools:
  • Incorporate SAST/DAST tools capable of detecting missing authorization on sensitive routes.
  • Use API security scanners to fuzz custom headers and identify privilege escalations due to header spoofing.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/releases/tag/flowise%403.0.13
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-wvhq-wp8g-c7vq

Frequently asked

questions

Yes, if the Flowise instance is exposed over a network reachable by tenants. Any authenticated tenant who can send HTTP requests and set the x-request-from header can potentially exploit the issue, assuming no additional network-level protections are in place.

No. A low-privilege tenant account with a valid session cookie is sufficient, because the privilege escalation occurs when the server incorrectly trusts the x-request-from: internal header rather than enforcing proper role-based checks.

Replace header-based trust with explicit, server-side authorization for every sensitive endpoint. Administrative APIs should require specific roles or permissions, and any notion of "internal" access should be enforced via network boundaries and authenticated service identities, not via client-modifiable headers.

Establish a security guideline that client-controlled data (headers, query parameters, body fields) must never be used alone to decide trust level or internal vs external origin. Implement centralized access control, conduct regular access control reviews on new APIs, and integrate automated checks that flag endpoints lacking explicit authorization requirements.

Find out what's already
exploitable in your codebase.