CVE-2026-103235 in MISP
Summary
by MITRE • 09/30/2026
MISP contains a mass assignment vulnerability in the event delegation feature. When a user with delegation permission submits a delegation request, the application authorized the user against the event identified in the URL but then persisted the entire submitted record, including caller-supplied fields such as the primary key and event_id.
An authenticated attacker could inject a primary key or event_id into the delegation payload to retarget an existing delegation record to any event on the instance. Because a delegation row grants the requesting organisation read access to the event it references, this effectively granted read access to arbitrary events belonging to other organisations. If the target organisation subsequently accepted the delegation, ownership of the event was transferred and the original record was deleted.
Preconditions:
- An authenticated user with the delegation permission (perm_delegate)
- The MISP.delegation server setting must be enabled
Impact:
- Confidentiality: read access to any event on the instance
- Integrity: overwriting existing delegation records and transferring event ownership
Affected versions: MISP < 2.5.48
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 09/30/2026
The vulnerability identified in Malware Information Sharing Platform (MISP) represents a critical mass assignment flaw within its event delegation subsystem, specifically affecting versions prior to 2.5.48. This security defect arises from improper validation of user-supplied input during the persistence phase of an API request or form submission. When an authenticated user possessing the perm_delegate permission submits a delegation request, the application correctly validates that the requester has authorization for the event specified in the URL parameter. However, the backend logic fails to restrict the fields written to the database record based on this validation scope. Instead, it persists the entire submitted object, including sensitive internal identifiers such as the primary key and the target event_id field provided by the client. This architectural oversight allows an attacker to manipulate these protected attributes, effectively bypassing the intended access control boundaries that should limit modifications to only those fields explicitly permitted for delegation requests.
From a technical perspective, this flaw is classified under CWE-915: Improper Control of Dynamically-Managed Code Resources, specifically manifesting as mass assignment or unsafe deserialization of untrusted data where object properties are updated without sufficient validation against the user's permissions. The attacker exploits this by injecting arbitrary values for the event_id into the delegation payload. By doing so, they can redirect a delegation request from its intended target to any other event hosted on the MISP instance. This manipulation is particularly dangerous because it does not require privilege escalation in terms of account rights; rather, it abuses existing low-level permissions to achieve high-impact outcomes. The vulnerability aligns with MITRE ATT&CK technique T1078: Valid Accounts, as it leverages legitimate credentials and authorized actions to perform unauthorized data access and modification operations within the application logic layer.
The operational impact of this vulnerability is severe, compromising both the confidentiality and integrity of the threat intelligence shared through the platform. Regarding confidentiality, an attacker can successfully grant read access to any event on the instance by retargeting a delegation request to events belonging to other organizations. Since MISP relies heavily on trust relationships between organizations for sharing sensitive indicators of compromise and malware samples, this breach allows unauthorized entities to view proprietary threat data intended only for specific partners or internal teams. This exposure can lead to significant intelligence leakage, potentially revealing the nature of ongoing investigations, the identity of affected systems, or the presence of critical vulnerabilities within an organization's infrastructure.
Furthermore, the integrity impact is equally concerning due to the subsequent workflow triggered by delegation acceptance. If a target organization accepts the manipulated delegation request, MISP transfers ownership of the event from its original owner to the requesting attacker’s organization and deletes the original record. This action results in permanent data loss for the victim organization and grants the attacker full administrative control over that specific piece of intelligence. The attacker can then modify, delete, or republish this stolen intelligence under their own authority, potentially spreading false information or disrupting collaborative threat hunting efforts across the MISP community. This chain of events demonstrates a clear path from initial input manipulation to complete compromise of data ownership and availability for targeted victims.
To mitigate this vulnerability, organizations running affected versions of MISP must immediately upgrade to version 2.5.48 or later, where the mass assignment flaw has been patched by implementing strict field whitelisting during object persistence. Administrators should also ensure that the delegation feature is only enabled when necessary and restrict perm_delegate permissions to trusted users within their organization. Regular auditing of delegation logs can help detect any anomalous patterns indicative of exploitation attempts before they result in data exfiltration or ownership transfer. Additionally, implementing robust input validation at both the API gateway level and the application service layer provides defense-in-depth against similar mass assignment attacks across other modules of the platform.