Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with perm_delegate on MISP
-
DeliverySubmit delegation request for accessible event
-
ExploitInject id/event_id into payload
-
ExecutionRetarget delegation row to victim event
-
PersistGain read access to arbitrary org's event
-
ImpactOptionally trigger ownership transfer on acceptance
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V4 - API and Web Service Object attribute protection
|
| Exploitation Conditions | Two concrete preconditions must both hold: (1) the attacker is an authenticated user whose role carries the delegation permission (perm_delegate), and (2) the instance-wide MISP.delegation server setting is enabled, which is not the default. Given both, exploitation is a single crafted POST to the delegateEvent endpoint containing an extra 'id' (primary key) or 'event_id' field in the EventDelegation payload; the controller authorizes only the event named in the URL but saves the full submitted record, so the injected key retargets an existing delegation to an arbitrary event. Limiting factors: valid credentials with the delegation permission (PR:L), dependence on the non-default delegation feature being enabled, and full ownership transfer additionally requiring the target organisation to accept the delegation. No victim user interaction is needed for the read-access disclosure. |
| Impact | This is a genuine, high-priority authenticated authorization flaw rather than a CVSS-inflated non-issue. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:L, score 8.7) is well-supported by the description and by the source-code patch: a low-privileged authenticated user reaches broad confidentiality and integrity impact with no user interaction and low attack complexity. No EPSS score, no CISA KEV listing, and no public POC are provided, so exploitation is currently theoretical (no public exploit identified at time of analysis) - the risk is driven by ease of exploitation and impact severity, not by evidence of active exploitation. The commit diff independently confirms the root cause (create()+save() with a caller-supplied primary key/event_id, fixed via an allow-list), raising confidence well above a description-only report. The two real limiters are that the attacker must already hold the perm_delegate permission and that the non-default MISP.delegation server setting must be enabled; where both hold, this is a real priority for MISP operators running multi-organisation sharing. |
| Exploit ScenarioDerived | An authenticated user in one organisation who holds the delegation permission submits a delegation request for an event they legitimately access, but injects an 'id' (primary key) or 'event_id' field into the payload. The application authorizes only the event named in the URL, then persists the entire submitted record, retargeting an existing delegation row at any event on the instance and granting the attacker's org read access to other organisations' events. No public exploit is identified, but the mass-assignment technique is trivial to reproduce with a standard HTTP client such as PyMISP. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 30, 2026
MISP before 2.5.48 lets an authenticated user holding the delegation permission (perm_delegate) retarget an existing event-delegation record to any event on the instance by injecting an 'id' or 'event_id' field into the delegation submission, because the controller authorizes only the event named in the URL but persists the entire caller-supplied record. The injected row grants the attacker's organisation read access to the targeted event and, if the target organisation accepts the delegation, transfers ownership of that event and deletes the original record - a confidentiality and integrity impact rated 8.7 (CVSS:4.0) and assessed as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L. Exploitation requires two concrete preconditions: an account with perm_delegate and the non-default, instance-wide MISP.delegation setting enabled; there is no public exploit identified at time of analysis, but a vendor fix is available in 2.5.48 (commit d1f5684f9).
RemediationAI
Upgrade to MISP 2.5.48 or later, or apply the vendor patch commit https://github.com/MISP/MISP/commit/d1f5684f9, which rebuilds the EventDelegation row from a strict allow-list and unsets any caller-supplied 'id' - this is the only complete fix, since the vulnerability is in server-side field handling rather than configuration. Where an immediate upgrade is not possible, turn off the instance-wide MISP.delegation setting, which makes the vulnerable delegateEvent() path unreachable; the trade-off is that legitimate cross-organisation event delegation stops working entirely for all users. A narrower compensating control is to review role definitions and strip perm_delegate from every role that does not strictly require it, reducing the attacker population to trusted delegation managers, but this does not remove the flaw for those remaining users. Because exploitation silently creates or repoints delegation rows that grant read access, defenders should also audit the event_delegations table for rows whose event_id, requester_org_id or org_id do not match a legitimate request, and check event ownership changes and deletions for signs of a prior retargeting, then treat any confirmed anomaly as a full compromise of those events' confidentiality.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a classic mass-assignment / improper mass-assignment pattern (CWE-915) in MISP's CakePHP-based EventDelegationsController::delegateEvent() action. CakePHP's ORM turns a save() call into an UPDATE rather than an INSERT when the data array carries an 'id' primary key, so the pre-patch code - which only set distribution, sharing_group_id, event_id and requester_org_id before calling save() on the raw request payload - could be steered into modifying an arbitrary pre-existing EventDelegation row. The authorization checks in that action cover only the event identified in the URL, so a caller-supplied 'id' (to overwrite somebody else's delegation) or 'event_id' (to point a delegation at another organisation's event) escaped the access-control boundary. The impact is amplified by the data model: a delegation row is itself the grant of read access to the event it names, as consumed by Event::fetchEvent, so creating or retargeting a row effectively yields a read grant over any event on the instance. On acceptance by the referenced organisation, ownership of the event moves to the requesting organisation and the original record is deleted, causing integrity damage in addition to disclosure. The affected product is tracked as cpe:2.3:a:misp:misp:*:*:*:*:*:*:*:* and the fix replaces the raw save with an explicit allow-list of fields (event_id, requester_org_id, org_id, message, distribution, sharing_group_id) and drops any caller-supplied key.
Know when Misp gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N
Network endpoint with low complexity but requires the delegation permission (PR:L); read access to any event (C:H) and delegation overwrite/ownership transfer (I:H), with original-record deletion giving limited A:L.
Primary rating from Vendor (CIRCL).
CVSS VectorVendor: CIRCL
DescriptionCVE.org
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
Executive ViewAI
MISP threat intelligence sharing platforms running versions before 2.5.48 with the non-default MISP.delegation setting enabled are exposed to a high-severity authorization flaw that can let an authenticated delegated user read or take ownership of arbitrary events. This undermines the confidentiality and integrity of shared threat intelligence, potentially eroding inter-organizational trust and requiring incident response for affected event data. Leadership should prioritize remediation because the issue is remotely exploitable by an authenticated account with perm_delegate, even though no public exploit identified at time of analysis.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
An issue was discovered in MISP 2.4.9x before 2.4.99. Rated high severity (CVSS 8.8), this vulnerability is remotely exp
An issue was discovered in MISP before 2.4.158. Rated critical severity (CVSS 9.8), this vulnerability is remotely explo
app/Controller/Component/IndexFilterComponent.php in MISP before 2.4.167 mishandles ordered_url_params and additional_de
SQL injection in MISP threat intelligence platform versions prior to 2.5.37 allows remote unauthenticated attackers to m
An issue was discovered in MISP before 2.4.158. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitab
MISP 2.4.172 mishandles different certificate file extensions in server sync. Rated high severity (CVSS 7.5), this vulne
In MISP before 2.4.148, app/Lib/Export/OpendataExport.php mishandles parameter data that is used in a shell_exec call. R
An issue was discovered in app/Controller/UsersController.php in MISP 2.4.92. Rated critical severity (CVSS 9.8), this v
An issue was discovered in MISP 2.4.128. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable,
MISP before 2.4.135 lacks an ACL check, related to app/Controller/GalaxyElementsController.php and app/Model/GalaxyEleme
app/View/Elements/genericElements/IndexTable/Fields/generic_field.ctp in MISP 2.4.144 does not sanitize certain data rel
MISP 2.4.148, in certain configurations, allows SQL injection via the app/Model/Log.php $conditions['org'] value. Rated
EUVD-2026-89728
GHSA-j2mf-q9c3-gwxw
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB