Summary
A mass assignment vulnerability in Flowise's chatflow update endpoint lets authenticated users overwrite server-controlled properties such as deployment state, visibility, workspace ownership, and timestamps.
When combined with missing authorization checks, this enables cross-workspace resource reassignment and unauthorized modification of how and where chatflows are deployed and exposed.
Affected context
This vulnerability appears in Flowise deployments where the chatflow update API directly binds client-supplied JSON to backend models without restricting which fields can be modified.
It becomes relevant in multi-user or multi-workspace environments where chatflows are expected to be isolated and controlled by specific owners or admins, but the server does not enforce strict field-level validation or workspace-level authorization on update.
Any authenticated user with access to the chatflow update endpoint can potentially influence attributes that should normally be managed only by the system or privileged roles, such as workspace assignment, deployment status, and public visibility.
Exploit preconditions
- Attack surface: The authenticated HTTP API, specifically the chatflow update endpoint exposed by Flowise.
- Required access: A valid authenticated account with permission to update at least one chatflow; no special administrative role is required.
- Trigger point: Sending an update request that includes additional fields such as
deployed,isPublic,workspaceId,createdDate, andupdatedDatein the payload. - Why exploitation is possible: The server performs broad object binding (mass assignment) without whitelisting safe fields and does not enforce robust authorization checks to ensure that only permitted attributes are altered and that workspace relationships are preserved.
Why this happens
The core issue is improper control over which model properties can be modified by client input, mapping to CWE-915: Improperly Controlled Modification of Dynamically-Determined Object Attributes (Mass Assignment).
Instead of explicitly enumerating and validating updatable fields, the chatflow update endpoint relies on generic binding that accepts arbitrary attributes from the request body, including those intended to be server-controlled.
This weak field-level control is compounded by missing or insufficient authorization checks (related to CWE-284 and CWE-639), allowing users to reassign chatflows across workspaces or toggle deployment and visibility flags that should only be managed by privileged actors.
Potential impact
- Users may reassign chatflows to workspaces they do not own, breaking tenant isolation.
- Attackers could make private chatflows public or alter visibility flags, exposing sensitive flows or data.
- Unauthorized deployment or undeployment of chatflows can disrupt workflows or cause unintended exposure of LLM-based services.
- Manipulation of metadata such as creation and update timestamps can degrade auditability and incident response capabilities.
- In multi-tenant scenarios, cross-workspace access control assumptions may be undermined, enabling broader lateral movement.
General mitigation guidance
Mitigation generally focuses on tightening server-side control over which attributes are updatable and who is allowed to update them.
Recommended defensive patterns include:
- Implementing whitelists (allow-lists) of fields that can be changed through the chatflow update API, rejecting or ignoring any extra attributes in the request.
- Performing strict authorization checks on every update, verifying that the caller owns the chatflow or has an appropriate role within the target workspace before applying changes.
- Treating fields like
workspaceId,deployed,isPublic, and system timestamps as server-managed attributes, updated only via internal logic rather than direct client input. - Enforcing multi-tenant isolation by validating that any change in workspace association or visibility is explicitly allowed by policy and cannot be driven solely by user-supplied identifiers.
- Centralizing access control logic so that similar endpoints reuse consistent checks instead of re-implementing authorization in an ad hoc way.
How teams detect issues like this
Detection can combine code-level analysis with behavioral monitoring:
- Static analysis: Look for controller or handler code that binds entire request bodies directly into ORM or model instances without explicit field whitelisting, especially near update operations on multi-tenant resources.
- Code review: Flag patterns such as
object.assign(req.body)or genericupdate(req.body)calls on models that possess sensitive attributes (workspace IDs, visibility flags, deployment states, system timestamps). - Access control audits: Examine whether updates to workspace associations, public/private flags, and deployment states consistently pass through authorization checks tied to the current user and workspace.
- Runtime monitoring: Log and review changes to critical properties like
workspaceId,deployed, andisPublic, alerting on unusual cross-workspace modifications or frequent toggling by low-privileged accounts. - Automated tools: Incorporate security linters or SAST tools into CI pipelines to identify mass assignment and broken access control patterns early.

