/

CVE-2026-41278

Severity:

HIGH RISK

(7.5)

Information Exposure in Flowise Public Chatflows

CVE-2026-41278

Analyzed

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200

Impact:

Sensitive Data Disclosure

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 versions prior to 3.1.0 expose full chatflow objects, including sensitive configuration, through public endpoints without sanitization.

When public chatflows or chatbot configurations are accessed, the API may disclose credential identifiers, plaintext API keys, and password-like fields to any party with the URL, creating a significant risk of account takeover and unauthorized access to external services.

Affected context

This vulnerability affects Flowise deployments that:

  • Use versions prior to 3.1.0 (including the v3.0.13 Docker image),
  • Enable or rely on "public" chatflows and/or public chatbot configuration endpoints, and
  • Store secrets (such as API keys, credential IDs, or password-type values) inside chatflow configuration (flowData).

In these environments, the GET /api/v1/public-chatflows/:id and related public-chatbotConfig endpoints return the complete flowData objects without removing or masking sensitive fields, turning public sharing of chatflows into an unintentional secret exposure channel.

Exploit preconditions

  • Attack surface: HTTP(S) public endpoints:
  • GET /api/v1/public-chatflows/:id
  • Public chatbot configuration endpoints (e.g., public-chatbotConfig).
  • Required access: Ability to reach the public Flowise instance and know or discover a valid public chatflow ID or chatbot identifier. No authentication is required when endpoints are configured as public.
  • Trigger point: Any HTTP GET request to the affected public endpoints for a configured public chatflow or chatbot.
  • Why exploitation is possible: The backend returns raw flowData objects and related configuration structures without invoking a sanitization routine (the sanitizeFlowDataForPublicEndpoint function is absent in v3.0.13), causing secrets embedded in configuration to be included in API responses.

Why this happens

The underlying defect is a missing data sanitization step for structures exposed through public APIs.

Rather than separating internal configuration (which includes secrets) from public metadata, Flowise reuses the same flowData object for both internal use and public sharing.

In affected versions, the intended sanitization function is either absent or not applied, so fields meant to remain confidential (e.g., credential IDs, plaintext API keys, password-type fields) are serialized directly into public responses.

This behavior maps to CWE-200: Information Exposure, where a system inadvertently provides sensitive information to actors who should not have access due to incomplete access control and inadequate output filtering.

Potential impact

  • Exposure of plaintext API keys used by the chatflows (e.g., for LLM providers, vector stores, or other integrations).
  • Disclosure of password-type configuration fields, enabling unauthorized login to dependent services.
  • Leakage of credential IDs and related secrets that can be combined with other information to escalate access.
  • Abuse of exposed keys to perform arbitrary operations on connected services (e.g., issuing LLM queries, accessing data stores, or invoking third-party APIs).
  • Facilitation of account takeover, data exfiltration, and potential financial impact (e.g., cloud usage costs) through misuse of compromised credentials.

General mitigation guidance

Mitigation approaches generally focus on separating secrets from public objects and ensuring only non-sensitive data is ever exposed via public endpoints.

Common defensive patterns include:

  • Designing public APIs to work on derived, sanitized representations of internal models, ensuring confidential fields are never part of the response schema.
  • Implementing robust output filtering for any endpoint that can be accessed without strong authentication, explicitly enumerating which fields are allowed to be returned.
  • Storing API keys, passwords, and other secrets in dedicated secret stores or environment variables instead of embedding them directly in user-editable flow configuration.
  • Applying role-based access control (RBAC) to endpoints, limiting which data is exposed to anonymous users versus authenticated administrators.
  • Providing safe-by-default configurations, where new public sharing features exclude sensitive fields unless explicitly whitelisted by maintainers.

How teams detect issues like this

Detection typically relies on a combination of configuration review and automated checks:

  • Static and dynamic API response inspection: Regularly inspect and test public endpoints for the presence of secrets or credential-like patterns (e.g., API key formats, tokens, or password fields) in JSON responses.
  • Code review signals: Identify controllers or routes serving "public" resources and verify they use explicit sanitization or response DTOs that omit sensitive fields.
  • Security testing in CI/CD: Integrate automated tests or DAST tools that crawl public endpoints and flag responses containing patterns that resemble secrets (such as high-entropy strings, known provider key prefixes, or fields named apiKey, secret, password, etc.).
  • Policy enforcement: Define development guidelines that prohibit direct serialization of internal configuration objects to HTTP responses, and enforce these via linting rules or internal code review checklists.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-w47f-j8rh-wx87

Frequently asked

questions

Any user or script that can reach the affected Flowise instance and knows or can guess a public chatflow or chatbot ID may retrieve full configuration data, including secrets, without authentication. The scope encompasses all secrets stored in public chatflows.

Only network access to the Flowise public endpoints is required. There is no need for a valid user account if the chatflow or chatbot is configured as public; access is based on the ability to call the public API with a valid identifier.

Implement a strict separation between internal configuration and public representations: define explicit response schemas for public endpoints, whitelist only non-sensitive fields, and ensure all secret-bearing fields are excluded or replaced with non-sensitive references before serialization.

Treat all public endpoints as untrusted consumers, design them with "minimum data necessary" principles, and incorporate security reviews focused on secret exposure. Combine this with automated testing for secret patterns in responses and architectural patterns that keep secrets in dedicated stores rather than in user-facing configuration objects.

Find out what's already
exploitable in your codebase.