/

CVE-2026-41266

Severity:

HIGH RISK

(7.5)

Sensitive Information Exposure in Flowise

CVE-2026-41266

Modified

Vulnerability type

Category:

Sensitive Information Exposure

CWE:

CWE-200, CWE-522, CWE-862

Impact:

Credential Theft and Unauthorized Access to Downstream Services

Severity:

HIGH RISK

(7.5)

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 exposes sensitive configuration data, including API keys and HTTP authorization headers, through an unauthenticated /api/v1/public-chatbotConfig/:id endpoint.

Anyone who knows or can guess a chatflow UUID may retrieve credentials stored in password fields and headers, enabling credential theft and subsequent abuse of connected services.

Affected context

This vulnerability occurs in Flowise deployments that expose the public chatbot configuration API (/api/v1/public-chatbotConfig/:id) over a network reachable to untrusted users.

It manifests when:

  • Chatflows are referenced by UUIDs that an attacker can discover, guess, or obtain indirectly (e.g., through URLs, logs, or client-side code).
  • Configuration objects contain secrets such as API keys, tokens, and HTTP authorization headers stored in password-type fields.
  • No authentication or authorization is enforced before returning full configuration data from the public endpoint.

Exploit preconditions

  • Attack surface: Network-accessible Flowise HTTP API (/api/v1/public-chatbotConfig/:id).
  • Required access: No authentication; only the ability to send HTTP requests to the Flowise instance.
  • Knowledge required: A valid chatflow UUID for the targeted chatbot configuration.
  • Trigger point: Direct invocation of the public chatbot config endpoint with a chosen :id value.
  • Why exploitation is possible: The endpoint returns full internal configuration, including secrets, without enforcing authentication or filtering sensitive fields, violating least-privilege and output minimization principles.

Why this happens

The core issue is that an endpoint intended for public or client-facing use returns internal configuration structures without properly redacting or separating sensitive fields.

This maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, as confidential data (API keys, authorization headers, internal settings) is disclosed over an unauthenticated interface.

It is compounded by:

  • CWE-862: Missing Authorization, where access controls are not applied to a resource that clearly requires protection.
  • CWE-522: Insufficiently Protected Credentials, because secrets stored as "password" or credential fields are served back in clear form rather than being isolated from public outputs.

At a design level, the same data model is reused for both internal management and public retrieval, and the system implicitly trusts that "public config" can expose all stored fields instead of using a minimal, sanitized view.

Potential impact

  • Theft of API keys, tokens, and HTTP authorization headers associated with the chatbot.
  • Unauthorized use of third-party services (LLM providers, vector databases, APIs) tied to the stolen credentials.
  • Impersonation of the affected Flowise instance or its operators when calling external services.
  • Abuse of metered resources (e.g., LLM quotas, paid APIs) leading to financial impact.
  • Pivoting into related systems or environments where the same or similar credentials are reused.
  • Increased risk of data exfiltration from downstream services accessed via the compromised credentials.

General mitigation guidance

Effective mitigation focuses on separating public configuration from sensitive internals and enforcing strong access control around any secrets:

  • Design public APIs to return minimal, sanitized views of configuration, excluding credential fields, headers, and internal metadata by default.
  • Introduce strict authentication and authorization for any endpoint that can access or derive sensitive configuration, using role-based access and least privilege.
  • Store credentials in dedicated secret stores or vaults and avoid echoing them back through application APIs; expose only opaque references or key identifiers where necessary.
  • Implement field-level sensitivity classification (e.g., marking password, token, and header fields as non-readable) and enforce this classification in serialization logic.
  • Apply secure-by-default configuration where "public" or anonymous access must be explicitly enabled and is heavily restricted in what it can see.
  • Encourage rotation and compartmentalization of credentials so that any one secret, if accidentally exposed, has limited blast radius.

How teams detect issues like this

Organizations can detect and monitor for this class of vulnerability through a mix of testing and analysis:

  • API security testing and fuzzing: Regularly probe "public" endpoints to verify they only return non-sensitive fields; include tests for configuration and metadata endpoints.
  • Static analysis and code review: Flag controllers or routes marked as public that serialize full configuration models; look specifically for serialization of credential-bearing fields to HTTP responses.
  • Data-flow analysis: Trace flows from secret storage (environment variables, secret stores, password fields) to HTTP response serializers to identify unintended exposures.
  • Configuration policy enforcement: Use automated checks or API gateway policies to block responses that include known sensitive header names or fields (e.g., key, token, secret, password).
  • Runtime monitoring: Inspect logs and outbound responses (with privacy safeguards) for patterns that match API keys or token formats, raising alerts when secrets appear in responses.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-4jpm-cgx2-8h37

Frequently asked

questions

Yes. Any remote user who can reach the Flowise HTTP API and knows or can obtain a valid chatflow UUID can query the vulnerable endpoint and retrieve sensitive data without authentication.

No. The vulnerability lies in a public endpoint that does not enforce authentication or authorization, so account access is not required; only network reachability and a valid chatflow identifier are needed.

Apply authorization to configuration endpoints and redesign the public chatbot configuration API to return a restricted, sanitized view that excludes all secret-bearing fields. Internally, separate the models used for storage from those used for public responses and treat any field containing credentials as write-only.

Adopt a "minimum data exposure" design for all APIs, classify and tag sensitive fields at the data model level, and enforce these tags in serializers and responses. Combine this with mandatory authentication for configuration-related endpoints, regular security testing of public routes, and centralized secret management to ensure that credentials are never returned over client-facing APIs.

Find out what's already
exploitable in your codebase.