/

CVE-2026-41267

Severity:

HIGH RISK

(8.1)

Improper Mass Assignment / JSON Injection in Flowise Cloud

CVE-2026-41267

Analyzed

Vulnerability type

Category:

Improper Mass Assignment / JSON Injection

CWE:

CWE-639, CWE-915

Impact:

Privilege Escalation and Multi-Tenant Isolation Bypass

Severity:

HIGH RISK

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

Flowise Cloud's account registration endpoint previously allowed client-supplied JSON to overwrite server-managed fields through improper mass assignment.

An unauthenticated attacker could inject ownership metadata, organization associations, and role mappings at signup, potentially escalating privileges and breaching tenant isolation in multi-tenant deployments.

Affected context

This vulnerability affects Flowise Cloud deployments where:

  • Account registration is exposed to the public internet or untrusted clients
  • The backend directly binds JSON request bodies to account, organization, or membership models
  • Server-managed fields (e.g., owner IDs, tenant IDs, roles, timestamps) are not explicitly protected from client input

The issue is specific to the registration flow, where newly created accounts and their tenant/role metadata are initialized based on user-submitted JSON.

Exploit preconditions

  • Attack surface: Public account registration endpoint in Flowise Cloud
  • Required access: None beyond network reachability; exploitation can occur pre-authentication
  • Trigger point: Sending a crafted JSON payload during account creation that includes additional or overridden fields (e.g., organizationId, role, owner, nested permission objects)
  • Why exploitation is possible: The server trusts incoming JSON for model binding and fails to restrict which properties can be written, allowing client-controlled values to flow into server-managed and authorization-relevant fields.

Why this happens

The root cause is an improper mass assignment pattern, where the server deserializes client JSON directly into internal account and tenant-related models without whitelisting allowed fields.

Instead of mapping only specific, user-controllable attributes (such as email and password), the registration handler implicitly accepts and persists additional properties, including nested objects tied to authorization and tenancy.

This aligns with CWE-915: Improperly Controlled Modification of Dynamically-Determined Object Attributes, and is closely related to CWE-639: Insecure Direct Object Reference when client-controlled identifiers (like organization or user IDs) are used to cross authorization boundaries.

Potential impact

  • Creation of accounts bound to arbitrary organizations or tenants that the attacker should not control
  • Unauthorized elevation of roles (e.g., assigning administrative or elevated permissions to a newly registered account)
  • Manipulation of ownership metadata, enabling the attacker to appear as the owner of resources or workspaces
  • Tampering with timestamps or audit-related fields, undermining audit trails and incident reconstruction
  • Violation of tenant isolation, potentially leading to cross-tenant data exposure or administrative access
  • Long-term persistence of improper permissions that can be difficult to detect post-compromise

General mitigation guidance

Effective mitigation focuses on controlling which attributes can be set from client input and separating trust boundaries in your data model:

  • Explicitly whitelist fields that may be populated during registration (e.g., email, display name, password) and ignore any extra attributes in the JSON payload.
  • Treat server-managed attributes (e.g., owner ID, tenant/organization ID, roles, system timestamps, status flags) as write-protected; always derive them from authenticated context and server logic, not client input.
  • For multi-tenant systems, derive tenant association from secure mechanisms (such as the authenticated user, invite tokens, or dedicated provisioning flows) rather than allowing clients to specify tenant identifiers directly.
  • Centralize creation of role mappings and permission assignments in privileged server-side routines, separate from generic model binding and outside of public registration endpoints.
  • Use data transfer objects (DTOs) or schema definitions that explicitly define allowed fields, instead of binding HTTP request bodies directly to persistence models or ORM entities.
  • Apply least-privilege defaults: newly created accounts should start with minimal roles and no administrative capabilities unless explicitly granted via a separate, controlled workflow.

How teams detect issues like this

Detection typically involves reviewing both code and runtime behavior for mass assignment patterns:

  • Static analysis & code review:
  • Look for controller or route handlers that bind request bodies directly to ORM or persistence models (e.g., spreading request JSON into model constructors, or using generic update/save with req.body).
  • Flag the presence of sensitive properties (roles, tenant IDs, owner IDs, status flags) in models that are not explicitly excluded from mass assignment or omitted from public DTOs.
  • Review registration and onboarding flows specifically for the use of dynamic property assignment or blind JSON merging.
  • Policy enforcement:
  • Enforce code review checklists that require explicit whitelisting of input fields for any publicly exposed endpoints, especially in authentication/registration and tenant management areas.
  • Adopt API schema validation (e.g., JSON Schema, OpenAPI validation middleware) that rejects unknown or extra fields for security-critical endpoints.
  • Runtime monitoring:
  • Log and monitor unusual combinations of fields in registration requests, such as attempts to set role, organization, owner, or nested permission structures.
  • Use anomaly detection to spot newly created accounts with administrative roles or cross-tenant associations that deviate from normal provisioning flows.
  • Automated scanning tools or SAST solutions can be configured with rules for identifying unsafe mass assignment patterns and unvalidated field mappings in common web frameworks.

Sources

SourceLink
github.comgithub.com/FlowiseAI/Flowise/security/advisories/GHSA-48m6-ch88-55mj

Frequently asked

questions

Yes. If the Flowise Cloud registration endpoint is exposed, an attacker can exploit this issue remotely by sending crafted JSON during signup, without prior authentication.

No. The vulnerability resides in the account creation flow, so an unauthenticated attacker can attempt to inject server-managed fields as part of the initial registration request.

The safest approach is to remove generic mass assignment from public endpoints. Introduce explicit DTOs or input schemas that list only allowed fields, ignore or reject unexpected properties, and ensure that server-managed attributes (tenant IDs, roles, ownership, timestamps) are never sourced from client input.

Standardize secure patterns across the codebase: use schema validation middleware, enforce whitelisted attribute binding, and encapsulate permission, role, and tenant handling into dedicated service layers. Include checks for mass assignment and ID-based authorization bypass in security reviews and CI/CD pipelines to catch similar problems early.

Find out what's already
exploitable in your codebase.