Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious dataset cache file to victim
-
ExploitVictim loads dataset via Ultralytics
-
Executionload_dataset_cache_file deserializes untrusted data
-
ImpactArbitrary code executes as current user
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim to load an attacker-supplied dataset whose cache file is processed by Ultralytics' load_dataset_cache_file function, which deserializes the untrusted cache data without proper validation; the description explicitly requires user interaction - the target must visit a malicious page or open/load a malicious file. Limiting factors that reduce realistic risk: the attack vector is LOCAL (AV:L), not remote network-triggerable, and success depends entirely on social engineering the user into loading attacker-controlled cache/dataset content. Code executes only in the context of the current user (S:U), so impact is bounded by that user's privileges. No specific non-default configuration is named as a prerequisite beyond use of the vulnerable cache-loading code path. |
| Impact | This is a locally-exploitable, user-interaction-dependent remote code execution flaw via insecure deserialization (CWE-502) in Ultralytics' load_dataset_cache_file function. The CVSS 3.0 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 7.8) is internally consistent: it is NOT a network-facing, unauthenticated, click-free bug despite PR:N - the AV:L and UI:R metrics mean an attacker needs the victim to open or load a malicious file/page locally, which materially reduces real-world urgency compared to a true remote RCE. Signal comparison: the vuln.today decision label is 'this_week' (elevated but not act_now/emergency); the finding originates from ZDI (ZDI-26-816 / ZDI-CAN-30124), a credible research source, but there is NO CISA KEV listing, NO EPSS score, and NO verified public exploit code in the provided data. No conflicting signals are present, but several are simply absent (EPSS and KEV both missing). Bottom line: a genuine high-impact code-execution bug worth patching promptly, but the local vector plus mandatory user interaction make it targeted/social-engineering-dependent rather than a wormable mass-exploitation threat - prioritize this week, not as a same-day emergency. |
| Exploit ScenarioDerived | An attacker crafts a malicious dataset cache file and distributes it (e.g., bundled with a shared dataset, model repo, or linked from a malicious page) to a developer or ML practitioner using Ultralytics. When the victim loads the dataset and load_dataset_cache_file deserializes the untrusted cache, embedded attacker-controlled objects execute arbitrary code in the context of the current user. No verified public exploit code is identified in the available data, though ZDI holds a non-public advisory (ZDI-26-816). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Deserialization of untrusted data in Ultralytics' load_dataset_cache_file function allows arbitrary code execution in the context of the current user when a victim loads an attacker-supplied dataset whose cache data is processed by that routine. The flaw is rated 7.8 (CVSS:3.0/3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) because exploitation is local rather than network-reachable and depends entirely on convincing the user to open or load the malicious file - a social-engineering prerequisite that meaningfully narrows realistic exposure despite the high confidentiality, integrity and availability impact. Reported to the vendor by Trend Micro Zero Day Initiative (ZDI-CAN-30124 / ZDI-26-816); no public exploit code has been identified at time of analysis and no CISA KEV entry exists, and the source data provides no EPSS score.
RemediationAI
No vendor-released patch or fixed version is identified in the available data, so the first step is to track ZDI-26-816 (https://www.zerodayinitiative.com/advisories/ZDI-26-816/) and the Ultralytics release notes for a patched version and upgrade to it as soon as one is published. Because exploitation requires the victim to load an attacker-supplied dataset whose cache data is passed to load_dataset_cache_file, the practical risk reduction available today is to treat dataset directories and cache artifacts as untrusted input: do not load datasets, archives, or cache files obtained from third parties or untrusted repositories, and obtain datasets only from sources you control or have verified - the trade-off is loss of convenience when using shared or community-provided datasets and pre-built caches, and re-downloading data instead of reusing distributed caches. Running dataset loading with the lowest practical privileges limits the blast radius, since code executes only in the context of the current user, but it does not prevent the deserialization itself and should not be treated as a fix. No configuration flag or hardening option that disables the vulnerable cache-loading path is documented in the supplied sources.
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 vulnerability is a CWE-502 (Deserialization of Untrusted Data) flaw in Ultralytics' dataset cache loading path, implemented in the load_dataset_cache_file function. Rather than validating that cached data originates from a trusted source, the routine deserializes attacker-influenced content, so a crafted cache/dataset artifact can instantiate objects that execute commands under the privileges of the process that loaded it. The affected component is the Ultralytics Python package, identified in the CPE data as cpe:2.3:a:ultralytics:ultralytics, with the version field left as a wildcard - the available sources do not enumerate which releases contain the vulnerable code path. The specific serialization mechanism used for the cache and the precise code-level trigger are not described in the supplied sources; what is confirmed is that user interaction is required (UI:R in the assessed vector) and that the attack vector is local (AV:L), meaning the malicious dataset or cache artifact must be delivered to and loaded by the victim rather than being triggered directly over the network. Severity metrics reflect post-exploitation impact only (C/I/A all High) and should not be read as describing a remotely reachable condition.
Know when Ultralytics 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
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Local vector because exploitation needs the user to open/load a crafted cache file (UI:R); no privileges needed (PR:N); deserialization yields full code execution so C/I/A all High, scope unchanged.
Primary rating from Vendor (zdi).
CVSS VectorVendor: zdi
DescriptionCVE.org
Ultralytics load_dataset_cache_file Deserialization of Untrusted Data Remote Code Execution Vulnerability. This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ultralytics. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file.
The specific flaw exists within the load_dataset_cache_file function. The issue results from the lack of proper validation of user-supplied data, which can result in deserialization of untrusted data. An attacker can leverage this vulnerability to execute code in the context of the current user. Was ZDI-CAN-30124.
Zero Day Initiative Advisories
Executive ViewAI
Ultralytics' dataset caching function contains a high-severity deserialization flaw that enables arbitrary code execution when a user loads a malicious dataset. This affects data scientists, engineers, and analysts who use Ultralytics tools, potentially leading to full system compromise via social engineering. Leadership should prioritize remediation due to the severe impact on confidentiality, integrity, and availability, despite the local attack vector.
No vendor-released patch identified at time of analysis; implement application whitelisting, restrict dataset loading to trusted sources, and use sandboxed execution environments for data processing.
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
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
More in Ultralytics
View allPath traversal in Ultralytics's Google Drive download handling lets remote, unauthenticated attackers place files outsid
Code injection in Ultralytics' parse_model function lets an attacker execute arbitrary Python code with the privileges o
Code injection in Ultralytics' parse_model function lets an attacker execute arbitrary Python in the context of the curr
OS command injection in Ultralytics' torch_safe_load function allows an attacker who supplies a crafted model file to ex
Code injection in the Ultralytics Python package's check_det_dataset function lets an attacker execute arbitrary Python
Deserialization of untrusted data in Ultralytics' torch_load function allows code to run in the context of the current u
EUVD-2026-112262
GHSA-79w4-wpg3-29fc
NVD
CVE.org
Exploit-DB