Summary
Flowise exposed a public chatflow configuration endpoint without enforcing authentication, allowing retrieval of internal workflow metadata tied to OAuth credentials.
An unauthenticated attacker could leverage these identifiers to refresh and obtain valid OAuth 2.0 access tokens associated with the public chatflow, potentially accessing connected third-party services under certain configurations.
Affected context
This vulnerability arises in Flowise deployments that:
- Expose one or more chatflows as "public"
- Allow public access to chatflow configuration or metadata endpoints
- Store or reference OAuth 2.0 credentials as part of a chatflow's internal workflow configuration
- Support token refresh using stored identifiers or refresh tokens without additional verification
In such contexts, public chatflows effectively extended their trust boundary to unauthenticated users, unintentionally exposing data necessary to obtain valid OAuth 2.0 access tokens.
Exploit preconditions
- Attack surface: HTTP/HTTPS API endpoints serving public chatflows
- Required access: Network access to the Flowise instance and knowledge or discovery of a public chatflow identifier or URL
- Trigger point: Issuing a request to the public chatflow configuration endpoint that returns internal workflow data, including OAuth credential identifiers or refresh-related metadata
- Why exploitation is possible: The endpoint responsible for returning chatflow configuration did not enforce authentication or adequately filter sensitive fields, allowing unauthenticated clients to obtain data sufficient to perform OAuth token refresh operations
Why this happens
The core issue maps to CWE-306: Missing Authentication for Critical Function.
Flowise treated the chatflow configuration retrieval function as public because the chatflow itself was intended to be public-facing. However, this configuration payload contained security-sensitive information—such as identifiers or references to OAuth credentials—needed to refresh OAuth 2.0 access tokens. Since no authentication or additional access control checks were enforced on this endpoint, untrusted clients could call a critical backend function (token refresh) indirectly by first retrieving configuration data, then using it to obtain valid access tokens.
Architecturally, this reflects an insecure pattern where:
- Business logic for viewing public content is coupled with configuration or secrets intended only for trusted actors.
- Sensitive metadata (e.g., OAuth client identifiers, refresh references, or token exchange parameters) is exposed via public APIs without redaction.
- Token lifecycle operations assume that possession of specific identifiers implies authorization, rather than enforcing explicit authentication and authorization decisions for each sensitive operation.
Potential impact
- An attacker may obtain valid OAuth 2.0 access tokens associated with a public chatflow's integrations.
- An attacker could access third-party services (e.g., APIs, data stores, SaaS platforms) configured in the chatflow, subject to the scopes and permissions granted to the OAuth client.
- An attacker might read or manipulate data processed by the chatflow's downstream integrations, potentially leading to data exposure or modification.
- An attacker could impersonate the chatflow's integration context when interacting with external systems, causing unwanted actions or automated workflows to trigger.
- Depending on the privileges attached to the OAuth tokens, an attacker may escalate impact to broader account or environment compromise in connected services.
General mitigation guidance
Mitigation revolves around strictly separating public endpoints from sensitive operations and enforcing authentication for any function that can reveal or derive credentials.
Recommended defensive patterns include:
- Ensuring that configuration or metadata endpoints that contain or reference credentials, tokens, or refresh parameters always require authentication and appropriate authorization checks, regardless of whether the associated resource is "public".
- Designing public APIs to return only non-sensitive configuration fields; redact or omit any fields that could directly or indirectly be used to obtain secrets, tokens, or privileged identifiers.
- Treating token issuance and refresh as privileged operations that are gated by robust authentication, explicit authorization rules, and contextual checks (e.g., client binding, audience restrictions).
- Implementing a clear separation between "runtime configuration needed by clients" and "backend secrets or credential handles", with the latter never leaving trusted server-side boundaries.
- Applying least-privilege principles to OAuth scopes and permissions so that, even if a token is exposed, its capabilities are constrained.
- Introducing centralized access control policies for all endpoints that interact with authentication data, ensuring that future features inherit secure defaults.
How teams detect issues like this
Detection typically focuses on identifying unauthenticated access paths to sensitive configuration and improper exposure of credential-related metadata.
Useful approaches include:
- Implementing static analysis or API contract checks that flag endpoints returning fields related to credentials, tokens, or OAuth configuration when those endpoints are marked as public or unauthenticated.
- Reviewing route definitions and middleware usage to ensure that all endpoints handling authentication, token refresh, or secret material have explicit authentication and authorization guards, with automated tests verifying these assumptions.
- Performing security-focused code reviews or threat modeling on flows that expose "public" resources, specifically checking that public exposure does not extend to configuration or secrets.
- Using dynamic application security testing (DAST) or API scanning tools to probe for unauthenticated endpoints that leak internal configuration, keys, or credential identifiers.
- Enforcing logging and monitoring around token issuance and refresh events, looking for anomalous patterns such as refreshes originating from unexpected IP ranges or user agents.

