/

CVE-2026-56423

Severity:

HIGH RISK

(8.8)

Broken Bulk Access Control (CWE-862) in MISP Core

CVE-2026-56423

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-862

Impact:

Unauthorized Data Deletion and Cross-Tenant Data Loss

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

MISP Core contained broken access control in bulk deletion handlers for Event Reports and Sharing Groups, where role-level permissions were used instead of per-object authorization checks.

An authenticated user with broad contributor or sharing-group privileges could submit identifiers for objects owned by other organisations and hard-delete them across the instance, making the issue risky wherever multi-tenant or cross-organisation deployments are used.

Affected context

This vulnerability appears in MISP Core instances that expose bulk deletion functionality for Event Reports and Sharing Groups.

It becomes relevant when users are granted global contributor or sharing-group capabilities but the application does not re-validate ownership or per-object authorization for each item in a bulk operation.

In such environments, multi-organisation deployments and shared instances are particularly exposed, as objects belonging to other organisations can be targeted during bulk delete requests.

Exploit preconditions

  • Attack surface: HTTP endpoints implementing bulk deletion for Event Reports and Sharing Groups.
  • Required access: Authenticated user account with contributor-level permissions (for Event Reports) or sharing-group permissions (for Sharing Groups).
  • Trigger point: Submission of a bulk deletion request containing IDs or UUIDs of objects owned by other organisations.
  • Why exploitation is possible: The affected bulk deleteSelection handlers authorize based on broad role-level capabilities, skipping per-object ownership and authorization checks that are applied to single-object deletion flows.

Why this happens

The underlying bug class is broken access control, mapped to CWE-862: Missing Authorization.

Instead of validating whether the requesting user is authorized to delete each specific Event Report or Sharing Group, the bulk deletion handlers relied solely on global permissions such as perm_add or perm_sharing_group.

This insecure pattern treats bulk operations as privileged by default, failing to apply the same object-level authorization gates used elsewhere, and thereby allowing users to operate on resources outside their intended ownership or scope.

Potential impact

  • Authenticated users may delete Event Reports belonging to other organisations.
  • Attackers could hard-delete Sharing Groups they do not own, disrupting sharing configurations.
  • Loss of critical event-report content and associated threat intelligence across the instance.
  • Degradation of trust between organisations using a shared MISP deployment.
  • Operational downtime while administrators restore from backups or reconstruct sharing policies.

General mitigation guidance

Mitigation typically centers on enforcing consistent object-level authorization for all operations, including bulk flows.

Useful patterns include:

  • Applying the same per-object ownership and authorization checks used in single-item actions to bulk handlers.
  • Treating each ID in a bulk request as an independent authorization unit, failing closed when checks cannot be completed.
  • Designing permission models to avoid broad, instance-wide delete capabilities unless strictly necessary and tightly constrained.
  • Logging and monitoring bulk destructive operations and restricting them to highly trusted administrative roles.
  • Implementing least privilege principles so contributor and sharing-group roles can act only within their own organisational scope.

How teams detect issues like this

Detection can focus on both code-level and runtime signals:

  • Reviewing controllers and handlers for bulk operations to ensure they invoke per-object authorization helpers (e.g., ownership or scoped access checks).
  • Using static analysis or policy-as-code rules that flag endpoints performing multi-ID operations without explicit per-resource authorization.
  • Inspecting audit logs for patterns of bulk deletions targeting resources across different organisations or tenants.
  • Incorporating automated security testing that attempts cross-tenant bulk operations to validate that access controls are enforced uniformly.

Sources

SourceLink
github.comgithub.com/MISP/MISP/commit/ada02fa6d7558732aa4712fd5e9451cd8c5b7a64
github.comgithub.com/MISP/MISP/commit/f99b3f16ef22c7acf10e17036c777759cf031c15

Frequently asked

questions

Yes. The issue specifically affects the bulk deleteSelection handlers, which skipped per-object authorization checks. Single-object delete actions used stricter ownership checks and were not described as vulnerable under the same conditions.

An attacker must be an authenticated user with contributor-level permissions for Event Reports or sharing-group capabilities for Sharing Groups. Guest or low-privilege accounts without these role permissions cannot directly exploit the vulnerable endpoints.

The safest pattern is to ensure every operation, including bulk actions, enforces per-object authorization. That means validating ownership or scoped access for each resource ID in the request and denying the entire operation or skipping unauthorized items when checks fail, rather than relying on a single global permission.

Organizations can prevent similar bugs by standardizing authorization helpers, requiring their use in all controllers, and enforcing code review checklists that call out bulk operations as a special risk area. Additionally, adopting least privilege role design, adding automated tests for cross-tenant actions, and integrating authorization-focused static analysis can help catch mismatches between role-level and object-level permissions before deployment.

Find out what's already
exploitable in your codebase.