/

CVE-2026-21445

Severity:

CRITICAL RISK

(9.1)

Missing Authentication in Sensitive Langflow API Endpoints

CVE-2026-21445

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthorized Data Access and Destructive Operations

Severity:

CRITICAL RISK

(9.1)

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

Multiple critical API endpoints in Langflow lack authentication checks, allowing unauthenticated users to directly call operations intended only for logged-in users.

Under these conditions, attackers can access sensitive conversation and transaction data and invoke destructive actions such as message deletion over the network.

Affected context

This vulnerability appears in Langflow deployments where the application is exposed over HTTP(S) and the vulnerable API routes are reachable without additional network-level protections.

It primarily affects endpoints that process or return user-specific resources such as conversations, transaction histories, and system operations that are logically tied to a user session or account.

The issue manifests when these endpoints are deployed without any authentication or authorization middleware guarding them, even though they handle personal data or destructive actions.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoints of a Langflow instance.
  • Required access: Network connectivity to the Langflow service; no valid account, credentials, or session required.
  • Trigger point: Direct invocation of the affected API routes (for example, endpoints that list conversations, fetch conversation details, access transaction or usage history, or delete messages).
  • Why exploitation is possible: The application does not enforce authentication or authorization on certain critical routes, treating all callers as implicitly trusted and allowing them to act as if they were authenticated users.

Why this happens

The underlying issue is a classic case of missing authentication and authorization enforcement on sensitive operations, aligning with CWE-306: Missing Authentication for Critical Function.

In this pattern, developers expose API routes intended for authenticated users but either omit authentication middleware, misconfigure route protection, or assume that the client UI will gate access.

As a result, the backend never verifies the identity or permissions of the caller before returning sensitive information or performing state-changing actions on behalf of a user.

The absence of server-side protections allows any unauthenticated party with network access to directly invoke these endpoints.

Potential impact

  • Unauthorized reading of user conversation histories, including potentially sensitive or personal prompts and responses.
  • Exposure of transaction or usage history data that may reveal billing, usage patterns, or other sensitive metadata.
  • Unauthorized deletion or modification of user messages or conversation records.
  • Loss of data integrity for stored conversations and associated metadata.
  • Potential privacy violations and regulatory exposure if personal data is processed or stored.
  • Facilitation of further social engineering or profiling based on leaked conversation content.

General mitigation guidance

Defensive strategies focus on consistently enforcing authentication and authorization for all sensitive functions:

  • Apply a default-deny posture for API routes so that endpoints are not accessible without explicit authentication and authorization checks.
  • Centralize authentication and authorization logic (e.g., middleware or filters) and ensure it is applied to all endpoints that access user-specific or sensitive data.
  • Distinguish between public and private APIs, and require valid user identity (session, token, or service account) for any operation that reads or modifies user data or system state.
  • Implement role- and permission-based checks for destructive or administrative actions, ensuring only authorized principals can perform them.
  • Minimize the data returned by APIs, applying least-privilege principles and only exposing necessary fields.
  • Use secure, well-established frameworks or libraries for auth handling instead of custom ad hoc mechanisms.
  • Regularly review route definitions to identify and close any gaps where new endpoints were introduced without appropriate protections.

How teams detect issues like this

Detection generally involves reviewing both code and runtime behavior for unguarded endpoints:

  • Static analysis and code review:
  • Search for route or controller declarations that omit authentication/authorization middleware while handling user-specific resources or performing destructive operations.
  • Flag controller methods that reference user data stores or deletion/update operations without checking the caller's identity or role.
  • Enforce linting or policy rules that require explicit access-control annotations or middleware registration on all non-public endpoints.
  • Configuration and architecture review:
  • Examine API gateway, reverse proxy, and routing configurations to ensure that sensitive paths are not exposed as unauthenticated routes.
  • Validate that new endpoints cannot be created without adding them to an access control policy set.
  • Dynamic and runtime testing:
  • Use automated API scanning or integration tests that attempt to access sensitive routes without credentials and verify that access is denied.
  • Monitor logs for suspicious patterns such as frequent requests to user-specific endpoints from IPs without successful authentication events.
  • Automated tools (SAST/DAST and API security scanners) can assist by pinpointing endpoints with missing or inconsistent access-control checks.

Sources

SourceLink
github.comgithub.com/langflow-ai/langflow/commit/3fed9fe1b5658f2c8656dbd73508e113a96e486a
github.comgithub.com/langflow-ai/langflow/security/advisories/GHSA-c5cp-vx83-jhqx

Frequently asked

questions

If the affected Langflow instance is reachable over the network (e.g., internet-facing or on a shared internal network), any party with network access can potentially invoke the exposed endpoints without authentication. The scope includes all users whose data is stored behind those endpoints.

The attacker only needs network-level access to the Langflow API and knowledge—or discovery—of the vulnerable endpoints. No valid user account, token, or prior authentication is required to interact with those routes.

Enforce a strict, centralized authentication and authorization mechanism on all API endpoints that handle user data or system state. Design the API with a default-deny approach so that endpoints must explicitly opt in to being public; otherwise, they automatically require authentication and appropriate permissions.

Adopt secure-by-default API design patterns, including mandatory auth middleware for all new routes, consistent use of role-based access control, and automated checks in CI/CD that fail builds when routes are defined without access controls. Regular security reviews and API testing should validate that no sensitive functionality is reachable without proper authentication.

Find out what's already
exploitable in your codebase.