/

CVE-2026-41273

Severity:

HIGH RISK

(8.2)

Missing Authentication / Authorization in Flowise Public

CVE-2026-41273

Modified

Vulnerability type

Category:

Missing Authentication / Authorization

CWE:

CWE-306

Impact:

Unauthorized Access to OAuth Tokens and Connected Resources

Severity:

HIGH RISK

(8.2)

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

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-6f7g-v4pp-r667

Frequently asked

questions

The issue is exploitable wherever a Flowise instance exposes public chatflows whose configuration endpoints can be reached by an unauthenticated user. Any attacker with network access to such an instance and knowledge or discovery of a public chatflow identifier could attempt exploitation.

No prior authentication is required. The attacker needs only network access to the Flowise deployment and the ability to interact with the public chatflow configuration endpoint. From there, they can use the exposed information to attempt OAuth token refresh operations.

The safest pattern is to require authentication and appropriate authorization for any endpoint that returns or influences credential material, tokens, or token refresh workflows. Additionally, public-facing endpoints should avoid returning sensitive configuration fields entirely, ensuring that secrets or credential handles remain exclusively server-side.

Prevention involves designing APIs with explicit trust boundaries: treat "public" resources as separate from their backend configuration and ensure that all security-sensitive operations (like token refresh) are guarded by authentication and fine-grained authorization. Incorporate security reviews for new public endpoints, automate checks for sensitive fields in responses, and adopt secure defaults where new routes are private unless deliberately made public under strict constraints.

Find out what's already
exploitable in your codebase.