Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted .blend file to victim
-
DeliveryVictim opens file in Blender
-
Exploitread_struct() skips size validation on matching SDNA
-
ExecutionShort blocks overrun heap buffer
-
PersistField writes and pointer dereferences corrupt memory
-
ImpactCrash or code execution in user context
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a victim to open or import an attacker-supplied, crafted .blend file in a vulnerable Blender build (before 4.5.15, or 5.x before 5.2.3). The specific trigger is a .blend file whose SDNA struct layout compares equal to the expected layout, which causes read_struct() to skip size validation; combined with deliberately short data blocks, subsequent field reads, writes and pointer dereferences overrun the heap. Limiting factors: the vector is local (AV:L) and needs user interaction (UI:P) - the attacker cannot trigger it remotely or without the victim loading the file - and no authentication or special non-default configuration is required beyond using an unpatched version. |
| Impact | This is a genuine priority within its context but not an internet-facing emergency. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H) describes a local, file-opening attack: there is no network vector and exploitation requires the victim to open a crafted .blend file (UI:P), which caps real-world urgency relative to a remote-unauthenticated flaw. Against that, the technical impact is high across confidentiality, integrity and availability because a heap out-of-bounds access in read_struct() enables field reads, writes and pointer dereferences past heap bounds - consistent with the RCE and Information Disclosure tags. No EPSS score was provided, so exploitation probability cannot be quantified; the CVE is not listed in CISA KEV and no public exploit was identified, so there is no confirmed active exploitation. The vuln.today decision label is 'this_week', and a vendor patch is available, which together point to prompt-but-scheduled remediation rather than an out-of-band emergency. Note the vector is AV:L with UI:P (passive interaction such as opening/importing a file) rather than a network vector - defenders should treat this as a client-side file-parsing risk, not a server exposure. |
| Exploit ScenarioDerived | An attacker distributes a malicious .blend file - for example via a shared asset pack, marketplace download, or project handoff - crafted with short data blocks whose SDNA struct layout compares equal so size validation is skipped. When a user opens or imports the file in a vulnerable Blender build, read_struct() reads, writes and dereferences past the allocated heap buffer, causing a crash or potentially arbitrary code execution in the user's context. No public exploit was identified at time of analysis, so this reflects the mechanism described in the advisory rather than a confirmed working exploit. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Heap out-of-bounds memory access in Blender's .blend file parsing path (read_struct()) can crash Blender or potentially enable code execution when a victim opens a crafted file whose SDNA struct layout compares equal to the expected layout, causing the parser to skip size validation and process deliberately short data blocks. Blender before 4.5.15 and 5.x before 5.2.3 are affected; exploitation is local and requires user interaction to load the file, no public exploit identified at time of analysis, and vendor patches are available. The issue is a this-week priority within its local, file-opening context rather than an internet-facing emergency.
RemediationAI
Vendor-released patch: upgrade Blender to 4.5.15 or later on the 4.5 branch, and to 5.2.3 or later on the 5.x branch; apply the fixes referenced by https://projects.blender.org/blender/blender/pulls/164279 and the associated commits https://projects.blender.org/blender/blender/commit/c5d6faf04bf3f17efb6c404896ef0e7427784da5 and https://projects.blender.org/blender/blender/commit/7de4986e74ed47f67e78eb4b76609bb6d1ae8a0e. No vendor-specified workaround is provided in the available references, and the exposure path is a user opening or importing a crafted .blend file, so patched builds are the complete fix.
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
Blender stores scene data in .blend files with an SDNA block describing structure layouts. In read_struct(), the code is supposed to validate block sizes before using the SDNA layout to read fields; the flaw occurs when a crafted file's SDNA layout compares equal to the expected layout, causing that validation to be skipped, and a short block then lets field reads, writes, and pointer dereferences overrun heap memory. This is CWE-125 (out-of-bounds read) at root, but the description confirms out-of-bounds writes and pointer dereferences as well, so the impact can extend to memory corruption. The affected CPE is cpe:2.3:a:blender_foundation:blender:*:*:*:*:*:*:*:*; the CVSS vector is local (AV:L), low complexity (AC:L), no privileges (PR:N), and user interaction (UI:R/UI:P), consistent with a victim opening or importing an attacker-supplied file in an unpatched Blender build.
Know when Blender 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:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
AV:L and UI:R because the victim must open a malicious local .blend file; PR:N as no privileges are needed, with high C/I/A from heap out-of-bounds read/write enabling disclosure or code execution.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Blender before 4.5.15 and 5.x before 5.2.3 contains a heap out-of-bounds access vulnerability in read_struct() that skips size validation when a .blend file's SDNA struct layout compares equal. Attackers can supply a crafted .blend file with short blocks so field reads, writes, and pointer dereferences overrun heap memory, causing crashes or code execution.
Executive ViewAI
Blender, a widely used 3D content creation tool, contains a high-severity memory corruption flaw that could crash the application or potentially enable code execution when a malicious .blend file is opened. The attack requires local user interaction, so the primary risk is to staff who exchange or download Blender project files, not to internet-facing services. Leadership should care because a successful exploit could compromise user workstations, but the local attack vector and lack of observed exploitation keep this below crisis level.
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
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Endless Infinite loop in Blender-thumnailing due to logical bugs. Rated high severity (CVSS 7.5), this vulnerability is
A flaw was found in Blender 3.3.0. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authen
A flaw was found in Blender 3.3.0. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authen
Heap-based buffer overflow in Blender's .blend thumbnail extractor (blender-thumbnailer and the Windows shell extension)
A heap buffer overflow in Blender's point cache loading path, driven by an integer overflow in ptcache_data_alloc(), aff
A missing bounds check in the image loader used in Blender 3.x and 2.93.8 leads to out-of-bounds heap access, allowing a
An integer overflow in the processing of loaded 2D images leads to a write-what-where vulnerability and an out-of-bounds
Out-of-bounds heap reads in Blender's .blend file loader let a crafted file crash the application or leak process memory
Out-of-bounds read in Blender 3.0.0 through 5.1.2 allows an attacker to crash the application or disclose heap memory co
Opening a crafted .blend file in a vulnerable Blender build causes a heap out-of-bounds read inside read_file_dna() and
An integer underflow in the DDS loader of Blender leads to an out-of-bounds read, possibly allowing an attacker to read
EUVD-2026-114127
GHSA-xrhr-77c8-rr8q
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB