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
:idvalue. - 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.

