Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted glTF/GLB asset to victim
-
DeliveryVictim app loads file without cgltf_validate()
-
ExploitLarge sparse indices bypass bounds checks
-
Executioncgltf_accessor_unpack_floats() writes past heap buffer
-
ImpactHeap corruption and crash or potential code execution
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that an application using cgltf (jkuhlmann/cgltf, versions through 1.15) parse an attacker-supplied glTF or GLB file AND NOT call cgltf_validate() before unpacking accessor data - validation is the explicit mitigating control that would reject the out-of-bounds sparse indices. The specific trigger is a sparse accessor whose indices exceed the output buffer, reached through cgltf_accessor_unpack_floats(). Limiting factors: the attack is local (the crafted file must be delivered to and opened/loaded by the victim, hence user interaction per UI:P), and any integration that invokes cgltf_validate() on untrusted input is not vulnerable. No network service exposure or authentication is involved; risk is confined to toolchains, engines, viewers, or importers that ingest untrusted 3D assets without validation. |
| Impact | This is a genuine memory-corruption flaw (CWE-787 heap out-of-bounds write) in cgltf, a widely-used single-header C glTF/GLB loader, but the real-world risk is moderate and heavily conditional rather than critical. The provided CVSS 4.0 vector (AV:L/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H) scores 7.3 and tells a consistent story: exploitation is LOCAL (the attacker must get a crafted asset to the victim), requires passive user interaction (UI:P - loading/opening a model file), and carries an attack requirement (AT:P) because the condition 'cgltf_validate() not called' must hold. High impact to confidentiality/integrity/availability (VC/VI/VA:H) reflects the potential for code execution via heap corruption, but 'potentially execute code' is the vendor/researcher framing - reliable RCE from a heap OOB write is not demonstrated in the supplied data. No EPSS score, no CISA KEV listing, and no weaponized exploit are present in the input; the referenced HackMD writeup is a technical root-cause analysis rather than confirmed exploit code. Exploitation status is therefore: no public exploit identified at time of analysis. Net: a legitimate issue to patch for anyone embedding cgltf in a pipeline that ingests untrusted models, but not a drop-everything, mass-exploitation priority - the local vector, required user interaction, and the strong mitigating factor that calling cgltf_validate() prevents the condition all cap the realistic risk. |
| Exploit ScenarioDerived | An attacker crafts a malicious glTF or GLB 3D model file containing a sparse accessor with oversized/unchecked indices and delivers it to a victim (e.g., via a model-sharing site, game mod, asset marketplace, or email). When a victim application built on cgltf loads the file without first calling cgltf_validate(), cgltf_accessor_unpack_floats() writes past the end of the output heap buffer, corrupting memory and crashing the process, with potential for code execution. No public, weaponized exploit was identified in the provided intelligence; only a technical root-cause writeup is referenced. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 18, 2026
Heap out-of-bounds write in cgltf through 1.15 lets a crafted glTF or GLB file with oversized sparse accessor indices push writes past the end of the output buffer inside cgltf_accessor_unpack_floats(), corrupting heap memory and crashing or potentially achieving code execution in the loading process. The flaw is only reachable when an application parses an untrusted asset and skips cgltf_validate(), the explicit check that would reject the malformed indices; attacks are local with user interaction (the victim must open the file), and no public exploit code was identified at time of analysis. Impact is confined to engines, viewers, converters, and import toolchains that ingest third-party 3D assets without validation, so real-world risk is moderate and highly conditional despite the 7.3 score.
RemediationAI
No vendor-released patch or fixed version was identified at time of analysis in the available intelligence, so the primary defense is the library's own mitigating control: call cgltf_validate() on every parsed asset before touching accessor data, and never call cgltf_accessor_unpack_floats() on unvalidated input - the trade-off is added parse-time CPU cost and possible rejection of files that are technically non-conformant but benign, which should be accepted for untrusted asset ingestion. Where cgltf source is vendored, add an explicit bounds check that each sparse index is less than the destination element count inside the unpack path (the code referenced at https://github.com/jkuhlmann/cgltf/blob/360db1a95480fe102ae9c69b27c5d101167ff5ba/cgltf.h#L2436-L2441) and track upstream commits at https://github.com/jkuhlmann/cgltf for a released fix. Because exploitation requires the victim to open a crafted file, route asset conversion and thumbnail/preview generation through a sandboxed, low-privilege worker (container, seccomp, or OS sandbox) so a heap corruption cannot escalate to host compromise - this limits blast radius but does not fix the bug and adds isolation overhead. Organizations that cannot patch or validate should block untrusted glTF/GLB uploads at the ingestion boundary or only process assets from vetted sources, accepting the loss of functionality for third-party content.
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
cgltf is a single-header C library (jkuhlmann/cgltf) for parsing glTF/GLB 3D asset files, widely embedded in engines, viewers, and asset pipelines. The bug is CWE-787 (out-of-bounds write): glTF sparse accessors carry an indices buffer whose values select which elements of the base accessor are overridden; cgltf_accessor_unpack_floats() trusts those index values when writing into the caller-supplied output array (see cgltf.h lines ~2436-2441) without checking them against the destination element count, so a sparse index larger than the buffer length causes writes past the heap allocation. The root cause is missing bounds validation on attacker-controlled indices rather than a parsing/type-confusion issue, and the library ships an explicit validation routine, cgltf_validate(), whose absence in the ingestion path is the precondition for exploitation. The CVSS 4.0 vector (AV:L/AC:L/AT:P/PR:N/UI:P) and the independent CVSS 3.1 assessment (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) both describe a local, unauthenticated-but-user-assisted trigger, not a remotely reachable service vulnerability.
Know when Cgltf 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:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Local because a crafted file must be parsed (AV:L), user must load it (UI:R), no auth needed (PR:N), and heap OOB write can yield code execution giving high C/I/A.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
cgltf through 1.15 contains a heap out-of-bounds write vulnerability in cgltf_accessor_unpack_floats() that allows attackers to write outside the output buffer via unchecked sparse accessor indices. Attackers can supply a crafted glTF or GLB file with large sparse indices to corrupt heap memory, crash applications, and potentially execute code when cgltf_validate() is not called.
Executive ViewAI
cgltf, the open-source glTF/GLB parsing library embedded in many 3D engines, viewers, converters and asset import toolchains, contains a heap out-of-bounds write (CVE-2026-112018) affecting versions through 1.15 that can crash or potentially allow code execution in the process loading a malicious asset. Leadership should care because teams that ingest third-party or customer-supplied 3D content without validation are exposed, although exploitation requires a user to open a crafted file locally and no public exploit code was identified at time of analysis. No vendor patch is available, so exposure must be managed through validation, isolation and supplier controls until an upstream fix ships.
No vendor-released patch identified at time of analysis. Interim mitigations: enforce cgltf_validate() before any accessor unpacking, reject glTF/GLB files with sparse accessor indices exceeding declared bounds, parse untrusted assets in a sandboxed low-privilege process or container with memory limits, restrict or manually review third-party asset sources, and monitor parser processes for crashes or abnormal memory behavior.
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.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Integer overflow in cgltf through version 1.15 allows remote attackers to bypass the library's accessor bounds validatio
cgltf versions 1.15 and earlier are vulnerable to integer overflow in sparse accessor validation that enables local atta
Heap out-of-bounds read in cgltf through 1.15 can be triggered when an application parses an attacker-supplied glTF or G
EUVD-2026-103471
GHSA-6vjv-6x7m-3wjx
NVD
CVE.org
Exploit-DB