Aug 4, 2026·7 min read·21 visits
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.
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.
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.
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 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.
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.
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.3If 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.
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| Product | Affected Versions | Fixed Version |
|---|---|---|
Flowise FlowiseAI | < 3.1.3 | 3.1.3 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-863 |
| Attack Vector | Network (AV:N) |
| CVSS v4.0 Score | 7.1 |
| EPSS Score | None recorded |
| Impact | High Availability Loss |
| Exploit Status | No public exploits |
| KEV Status | Not Listed |
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.
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.
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.
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.
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.
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.
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.