/

CVE-2026-56424

Severity:

HIGH RISK

(8.8)

Broken Access Control (CWE-639) in MISP Core Data Paths

CVE-2026-56424

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-639, CWE-862, CWE-863

Impact:

Cross-Organization Unauthorized Data Modification

Severity:

HIGH RISK

(8.8)

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 broken access-control issues in MISP core allow users with valid feature permissions to modify or delete data belonging to other organizations when authorization is checked against the wrong entity or omitted on write paths.

Under conditions where users can see, but should not be able to edit, cross-organization objects, these flaws can lead to unauthorized changes to shared intelligence artifacts and disruption of analyst workflows.

Affected context

These flaws occur in MISP core subsystems that manage collaborative intelligence objects, such as event reports, collections and their elements, analyst data, template elements, and decaying models.

The vulnerabilities arise when users from one organization have legitimate read access or feature-specific permissions that expose objects owned by other organizations, but where write operations do not correctly enforce ownership or editability checks.

The risk is highest in deployments where multiple organizations share a MISP instance and rely on fine-grained access control to protect the integrity of shared data.

Exploit preconditions

  • Attack surface: Authenticated web application interface and API endpoints for MISP core subsystems (event reports, collections, analyst data, templates, decaying models).
  • Required access: A lower-privileged account with appropriate subsystem-specific permissions (e.g., ability to manage tags, collections, analyst data, templates, or models) and visibility into cross-organization objects through normal sharing mechanisms.
  • Trigger point: Invoking write or mutation routes (tag removal, bulk deletion, nested updates, template element edits, model edits or mappings) where the authorization logic checks the wrong identifier or omits ownership/editability validation.
  • Why exploitation is possible: The application authorizes the operation based on an entity that the user is allowed to manage (or merely view), while performing the actual mutation on a different entity or without re-verifying that the target object is editable by the user's organization. This mismatch between view-scope and edit-scope validation creates a broken access control condition mapped to CWE-639, CWE-862, and CWE-863.

Why this happens

The underlying bug class is broken access control: authorization logic is either tied to the wrong resource or missing on modification paths.

In several MISP subsystems, the code uses IDs or relationships that do not correspond to the actual parent object whose integrity should be protected, or it applies view-only access checks to operations that change state.

For example, bulk operations authorize against a collection whose identifier matches a collection-element row ID rather than the element's true parent collection, and nested analyst data updates bypass the usual canEditAnalystData ownership check.

Similarly, template element editing and decaying model write paths rely on view-scope access to visible objects but fail to validate that the user's organization owns or can edit the targeted elements or models.

Abstractly, this reflects insecure authorization patterns where trust decisions are based on incomplete or incorrect context, consistent with CWE-639 (authorization by incorrect entity), CWE-862 (missing authorization), and CWE-863 (authorization on wrong side of trust boundary).

Potential impact

  • Authenticated users may perform unauthorized cross-organization modification of event report tags, altering how intelligence artifacts are classified or discovered.
  • Users could delete collection elements from collections they do not own, disrupting curated datasets and shared intelligence structures.
  • Analyst data records could be overwritten across organizational boundaries, corrupting analytical findings, annotations, or investigative context.
  • Template elements owned by other organizations can be edited, affecting shared workflows, enforced structures, and data entry consistency.
  • Decaying models and their mappings may be modified by non-owning organizations, skewing scoring, aging behavior, and automated prioritization of events and attributes.
  • Overall, shared intelligence integrity can be degraded, with unauthorized tampering impacting trust between organizations and weakening collaborative threat analysis.

General mitigation guidance

Effective mitigation focuses on consistently enforcing ownership-aware authorization on all write paths and ensuring that the resource being modified is the same resource that was validated.

Common defensive patterns include:

  • Centralizing authorization checks in reusable policies that explicitly differentiate between view and edit permissions and require ownership or delegated control for modifications.
  • Passing explicit resource identifiers through the authorization layer and validating relationships (e.g., parent-child associations) before mutating nested elements, rather than relying on convenience IDs or inferred mappings.
  • Applying can-edit checks for analyst data, template elements, decaying models, and collection elements that confirm the user's organization is the owner or has explicit rights to change the targeted object.
  • Using server-side enforcement of access control rules with strong separation between read and write routes, and avoiding assumptions that visibility implies editability.
  • Adopting secure-by-default access policies where shared objects are read-only unless explicitly configured for collaborative editing, and designing bulk operations to revalidate each element's authorization individually.

How teams detect issues like this

Broken access control issues are often surfaced through a combination of code review, security testing, and policy-driven analysis:

  • Static analysis and custom linting rules can flag patterns where authorization is performed on one object while a different object is later modified, or where write handlers lack explicit ownership/editability checks.
  • Security-focused code reviews should examine controllers and services handling bulk operations, nested updates, and cross-organization data to ensure that every mutation path invokes the correct authorization policy aligned with the target resource.
  • Automated tests and penetration tests can simulate users from different organizations with varying permissions to confirm that view-only access does not permit changes to foreign objects.
  • Policy enforcement in CI/CD pipelines can require that all new routes declare and use standardized access control helpers, and tools that model data relationships can help identify routes where parent-child authorization linkage is missing or incorrect.

Sources

SourceLink
github.comgithub.com/MISP/MISP/commit/24d7e91339a3ef043652dd5799c36e5065b2bb4a
github.comgithub.com/MISP/MISP/commit/3aecc04d5816189412b589cf590c6dbe9a8db5c0
github.comgithub.com/MISP/MISP/commit/57ad774d21bd1863d060a9e6e73ae54eb96784ce
github.comgithub.com/MISP/MISP/commit/744005cefdc3b943bd29669c3b34cc66a5fc2154
github.comgithub.com/MISP/MISP/commit/ba2f51fe7440ba2c6043ccde858cac1e25f96931

Frequently asked

questions

Exploitation is limited to authenticated users who already have subsystem-specific permissions and visibility into shared objects, but within that scope it can be widely impactful because it allows cross-organization tampering with multiple types of MISP data.

No. A lower-privileged user with the relevant feature permissions and access to shared or visible objects can trigger the flawed write paths. The vulnerabilities arise from incorrect or missing authorization checks, not from elevated roles.

The safest pattern is to centralize and enforce ownership-aware authorization on all modification routes, ensuring that the exact resource being changed is the one that was authorized and that edit checks, not just view checks, are applied before any state change.

Preventive strategies include designing clear separation between read and write permissions, using standardized authorization helpers for all controllers, adding tests that simulate cross-organization scenarios, and reviewing bulk and nested update logic for correct use of resource identifiers and ownership checks.

Find out what's already
exploitable in your codebase.