CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-69262

CVE-2026-69262: Incorrect Authorization Flaw in Flowise Chatflow Deletion Endpoint

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 4, 2026·7 min read·21 visits

Executive Summary (TL;DR)

Flowise versions prior to 3.1.3 contain an incorrect authorization flaw allowing users with limited deletion permissions (e.g., agentflows only) to delete other flow types (e.g., chatflows) due to missing resource-type validation checks in the deletion service layer.

CVE-2026-69262 is a high-severity incorrect authorization vulnerability (CWE-863) within the Flowise drag-and-drop LLM flow platform. Prior to version 3.1.3, Flowise did not enforce resource-type validation on its deletion endpoint. Although routing middleware ensured users held deletion privileges for either chatflows or agentflows, the service level lacked validation checks to verify whether the target resource matched the user's specific permissions. Consequently, an authenticated user with only agentflow deletion permissions could delete arbitrary chatflow configurations, leading to unauthorized state modification and service disruption.

Vulnerability Overview

Flowise is an open-source, low-code platform designed for orchestrating and managing large language model (LLM) workflows. The platform exposes administrative and configuration interfaces via HTTP REST APIs, allowing users to build, run, and modify agents, vector stores, and conversational pipelines. The core of this functionality relies on the Express-based backend server component, which exposes various APIs for managing entity data and session state.

This vulnerability, tracked as CVE-2026-69262 (GHSA-p5w8-m249-4r4v), is classified under CWE-863: Incorrect Authorization. In collaborative or multi-tenant deployment scenarios, access to specific entity types like chatflows, agentflows, or assistants is governed by granular permission roles. However, the system's deletion workflow failed to properly enforce these boundaries, exposing the internal state to unauthorized operations.

Because the backend did not cross-reference the entity type of the target database record with the caller's specific permission scope, the deletion endpoint allowed users to modify resources beyond their assigned roles. The attack surface is accessible to any authenticated user with at least some basic deletion permissions, presenting a significant threat to resource integrity and service availability in multi-user environments.

Root Cause Analysis

The root cause of this vulnerability lies in a structural mismatch between the route-level middleware definitions and the downstream service-level verification logic. Flowise routes utilize an Express middleware helper called checkAnyPermission to filter requests based on permission groups. For the chatflow deletion endpoint (DELETE /api/v1/chatflows/:id), the middleware was initialized to allow access to users holding either chatflow or agentflow deletion privileges.

This configuration behaves as a logical OR statement. If the requesting user possesses agentflows:delete but lacks chatflows:delete, the middleware successfully validates the request and passes execution to chatflowsController.deleteChatflow. The routing logic assumes that the downstream controller or service will perform more precise validation, but this critical verification was absent.

Once the controller received the request, it forwarded the target identifier (:id) directly to chatflowsService.deleteChatflow. The service queried the database, retrieved the ChatFlow object, and directly invoked the database delete function. Because both chatflows and agentflows reside within the same database table and share identical identifier formats, the application deleted the resource without checking if the user possessed the specific permission corresponding to the resource's type attribute.

Code Analysis

To completely remediate this flaw, the Flowise development team modified the routing, controller, and service-level components to enforce type mapping. Instead of relying solely on the routing middleware, the system now maps the user's explicit permissions to a restricted set of allowed database entity types before performing the database operation.

Below is the vulnerable controller logic contrasted with the patched controller implementation in packages/server/src/controllers/chatflows/index.ts:

// VULNERABLE CONTROLLER LOGIC
const deleteChatflow = async (req: Request, res: Response, next: NextFunction) => {
    try {
        // Directly passes parameters to service without evaluating user permission types
        const apiResponse = await chatflowsService.deleteChatflow(req.params.id, orgId, workspaceId)
        return res.json(apiResponse)
    } catch (error) {
        next(error)
    }
}
// PATCHED CONTROLLER LOGIC
const deleteChatflow = async (req: Request, res: Response, next: NextFunction) => {
    try {
        const userPermittedTypes: EnumChatflowType[] = []
        const permissions = req.user!.permissions
        if (req.user?.isOrganizationAdmin) {
            // Administrators automatically acquire all permissions
            userPermittedTypes.push(EnumChatflowType.CHATFLOW)
            userPermittedTypes.push(EnumChatflowType.AGENTFLOW)
            userPermittedTypes.push(EnumChatflowType.MULTIAGENT)
            userPermittedTypes.push(EnumChatflowType.ASSISTANT)
        } else {
            // Map explicit permission strings to database enum values
            if (permissions.includes(`chatflows:delete`)) userPermittedTypes.push(EnumChatflowType.CHATFLOW)
            if (permissions.includes(`agentflows:delete`)) {
                userPermittedTypes.push(EnumChatflowType.AGENTFLOW)
                userPermittedTypes.push(EnumChatflowType.MULTIAGENT)
            }
            if (permissions.includes(`assistants:delete`)) userPermittedTypes.push(EnumChatflowType.ASSISTANT)
            if (userPermittedTypes.length === 0)
                throw new InternalFlowiseError(StatusCodes.FORBIDDEN, `You do not have permission to delete any chatflow types`)
        }
        // Pass mapped userPermittedTypes downstream
        const apiResponse = await chatflowsService.deleteChatflow(req.params.id, orgId, workspaceId, userPermittedTypes)
        return res.json(apiResponse)
    } catch (error) {
        next(error)
    }
}

Following the controller refactoring, the corresponding service component in packages/server/src/services/chatflows/index.ts was patched to validate the fetched record against the permitted array:

// PATCHED SERVICE LAYER LOGIC
const deleteChatflow = async (
    chatflowId: string,
    orgId: string,
    workspaceId: string,
    userPermittedTypes: EnumChatflowType[]
): Promise<any> => {
    try {
        const appServer = getRunningExpressApp()
        const chatflow = await getChatflowById(chatflowId, workspaceId)
        
        // Assert that the fetched flow's type attribute is included in the user's permitted types
        if (!userPermittedTypes.includes(chatflow.type as EnumChatflowType))
            throw new InternalFlowiseError(StatusCodes.FORBIDDEN, `You do not have permission to delete this chatflow type`)
 
        const dbResponse = await appServer.AppDataSource.getRepository(ChatFlow).delete({ id: chatflowId })

Exploitation

Exploitation of CVE-2026-69262 requires authenticated access to a target Flowise workspace, with the attacker possessing a session token assigned with limited deletion capabilities. An attacker lacking any deletion rights is stopped at the routing level, making this vulnerability inaccessible to unauthenticated external threats.

Once authenticated, the attacker identifies the UUID of the target chatflow to be deleted. Because these flow identifiers are represented as UUIDs, they must first be obtained via normal interface usage, application logging, or related endpoint read operations. Once the identifier is obtained, the attacker transmits a direct HTTP DELETE request to the vulnerable endpoint.

The exploit can be reproduced using a standard command-line HTTP utility. The following proof-of-concept curl command executes the deletion of a targeted chatflow using an agentflow editor's authorization header:

curl -X DELETE "http://target-host:3000/api/v1/chatflows/9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d" \
  -H "Authorization: Bearer <agentflow_editor_token>" \
  -H "Content-Type: application/json"

In vulnerable configurations, this request will result in an HTTP 200 OK response status, and the chatflow database entry is permanently removed. Following the application of the patch, this exact request triggers an HTTP 403 Forbidden response and an error payload stating: You do not have permission to delete this chatflow type.

Impact Assessment

The primary operational consequence of this vulnerability is localized denial of service and data destruction. Deleting a chatflow permanently removes its design blueprints, conversational nodes, and integration endpoints. Any application, API client, or customer-facing chatbot relying on the deleted flow's unique identifier will immediately cease functioning.

According to the official CVE record, this vulnerability carries a CVSS v4.0 Base Score of 7.1 (High). The high severity classification is driven by the low attack complexity and the lack of specific user interaction required to execute the exploit. While it does not lead to information disclosure or remote system compromise, its impact on the availability of dependent applications is significant.

No active exploitation in the wild or public exploit code has been identified, and the vulnerability is not currently listed in CISA's Known Exploited Vulnerabilities catalog. However, in shared environments where different teams configure distinct business flows on a single host, this vulnerability introduces a lateral security boundary failure.

Remediation & Mitigation Guidance

The definitive resolution for CVE-2026-69262 is upgrading the Flowise instance to version 3.1.3 or higher. Because the patch resolves the vulnerability at the application layer via controller checks, no database modifications or structural changes to existing database records are needed.

To perform the upgrade using npm or pnpm, execute the corresponding command for your deployment model:

# Global deployment upgrade
npm install -g flowise@3.1.3
 
# Project-level dependency upgrade
npm install flowise@3.1.3

If upgrading immediately is not possible, administrators should restrict workspace access to highly trusted users. Additionally, security teams can configure monitoring systems to alert on HTTP DELETE traffic directed at the /api/v1/chatflows/ path. Cross-correlating these events with active user permission logs can help detect unauthorized deletion attempts before they occur in production.

Security teams should also review other CRUD endpoints (such as PUT /api/v1/chatflows/:id) to ensure they do not permit type mutation bypasses. Allowing users to alter the type attribute of a flow during an update could enable them to alter the permission domain of an existing resource.

Official Patches

FlowiseAIFlowise Security Advisory GHSA-p5w8-m249-4r4v
FlowiseAIFix Pull Request #6445
FlowiseAIFix Commit
FlowiseAIFlowise v3.1.3 Release Tag

Fix Analysis (1)

Technical Appendix

CVSS Score
7.1/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Affected Systems

Flowise Developer Tooling platform

Affected Versions Detail

Product
Affected Versions
Fixed Version
Flowise
FlowiseAI
< 3.1.33.1.3
AttributeDetail
CWE IDCWE-863
Attack VectorNetwork (AV:N)
CVSS v4.0 Score7.1
EPSS ScoreNone recorded
ImpactHigh Availability Loss
Exploit StatusNo public exploits
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-863
Incorrect Authorization

The software performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly verify that the actor is authorized to perform that specific action on that specific resource.

Vulnerability Timeline

Fix authored and committed to Flowise repository
2026-05-30
Security advisory published and CVE assigned
2026-08-04

References & Sources

  • [1]CVE-2026-69262 Detail Record
  • [2]GitHub Security Advisory GHSA-p5w8-m249-4r4v

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•CVE-2026-109481
7.5

CVE-2026-109481: Cross-Site Request Forgery Leading to Elevation of Privilege in ASP.NET Core

CVE-2026-109481 is a high-severity Cross-Site Request Forgery (CSRF) vulnerability in the ASP.NET Core Blazor Server and interactive component architecture. The flaw exists within the internal circuit state synchronization endpoint (`/_blazor/refresh`), which fails to enforce antiforgery token validation or verify cross-origin request headers. By inducing an authenticated victim to issue a cross-site request targeting a pre-allocated circuit identifier, an unauthenticated attacker can bind the victim's security principal to the attacker's active SignalR circuit, resulting in full privilege elevation within the application scope.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 2 hours ago•CVE-2026-126187
9.5

CVE-2026-126187: Unauthenticated Remote Code Execution in React Server Components

A critical deserialization vulnerability exists in React Server Components (RSC) packages (`react-server-dom-webpack`, `react-server-dom-parcel`, and `react-server-dom-turbopack`) across versions 19.0.0 through 19.3.0. The flaw occurs during the processing of React Flight protocol streams when handling multiple typed arrays sharing a backing ArrayBuffer alongside attacker-controlled inputs. By combining byte-stream buffer detachment semantics with unvalidated thenable invocation and exposed internal response states, an unauthenticated attacker can achieve remote code execution on server runtimes supporting React Server Components.

Alon Barad
Alon Barad
12 views•11 min read
•about 3 hours ago•CVE-2026-125123
2.3

CVE-2026-125123: Improper Output Neutralization and CI Workflow Command Injection in compose-lint CLI Parser

An improper output neutralization vulnerability (CWE-117 / CWE-150) exists in compose-lint version 0.31.0. When compose-lint is invoked on untrusted file paths without a preceding '--' option delimiter, Python's standard argparse module rejects malformed or dash-prefixed paths and writes them directly to standard error without passing through the application's output sanitizer. An attacker submitting a pull request containing crafted directory or file names with carriage returns or Unicode whitespace can inject arbitrary CI workflow commands into GitHub Actions or Azure Pipelines job logs.

Alon Barad
Alon Barad
4 views•10 min read
•about 4 hours ago•CVE-2026-125116
4.8

CVE-2026-125116: Type Confusion in Mongoose Discriminator Resolution

CVE-2026-125116 (GHSA-wr5m-5jph-8m96) is a type confusion vulnerability (CWE-843) in Mongoose, the MongoDB object modeling library for Node.js. When resolving discriminator models or schemas via user-supplied discriminator keys (defaulting to `__t`), Mongoose performs direct property indexing on plain JavaScript registry objects without verifying own-property ownership. Supplying inherited `Object.prototype` property names such as `'constructor'` causes Mongoose to resolve built-in functions rather than valid Mongoose constructors, resulting in unhandled runtime exceptions, schema validation bypasses, and persistent collection query denial of service.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-125119
7.5

CVE-2026-125119: Connection-Level Filter Sanitization Bypass in Mongoose ODM

A flaw in Mongoose's query condition casting pipeline causes the `sanitizeFilter` configuration option to be silently ignored when defined at the connection level via `mongoose.connect()` or `mongoose.createConnection()`. Because internal query methods inspect `Connection.options` rather than `Connection.config`, applications relying on connection-scoped filter sanitization remain vulnerable to NoSQL query selector injection (CWE-943), permitting authentication bypass and unauthorized data access across Mongoose versions 6.x through 9.x.

Amit Schendel
Amit Schendel
4 views•9 min read
•about 6 hours ago•CVE-2026-125110
5.3

CVE-2026-125110: Path Canonicalization Mismatch and Security Header Bypass in Rack::Static

CVE-2026-125110 is a path canonicalization mismatch vulnerability in Rack (specifically within the Rack::Static middleware component). When serving static files, Rack normalizes the requested URL path to resolve the physical file on disk, but evaluates configured path-specific header rules against an unnormalized, raw path that has only undergone URL percent-decoding. Unauthenticated remote attackers can exploit this discrepancy by injecting raw or percent-encoded dot-segments into HTTP requests, causing Rack to serve restricted static assets without their intended security headers.

Amit Schendel
Amit Schendel
6 views•10 min read