Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malformed .gltf/.glb with overflow accessor count
-
DeliveryDeliver file to cgltf-processing application
-
ExploitInteger overflow in stride × count multiplication
-
ExecutionBounds check bypass in cgltf_validate()
-
PersistHeap OOB read in cgltf_accessor_read_float()
-
ImpactMemory disclosure or process crash
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK
1 technique across 1 tactic: Execution 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 the target application calls cgltf_validate() followed by cgltf_accessor_read_float() on attacker-controlled .gltf or .glb input, and specifically that the non-sparse accessor code path is exercised during validation. The attacker must be able to supply or influence the 3D asset file processed by the application - for example, via file upload, email attachment, network-hosted asset, or embedded content in a shared repository. The vulnerability does not affect the sparse accessor path, and applications that never invoke cgltf_accessor_read_float() after validation avoid the out-of-bounds read phase, though the bounds check bypass still occurs. The confidentiality impact (heap memory disclosure) is non-deterministic and depends on heap layout at runtime; the availability impact (process crash) is reliable and repeatable given the integer wraparound behavior. |
| Impact | The official CVSS 4.0 score of 6.9 reflects moderate severity, characterized by no required privileges (PR:N), passive user interaction (UI:P), high availability impact (VA:H), and low confidentiality exposure (VC:L). A minor vector tension exists: the CVE description attributes the attack to 'remote attackers,' while the CVSS 4.0 AV:L metric reflects that exploitation occurs locally when the vulnerable application processes the malicious file - this interpretation is internally consistent but should be verified against the vendor advisory, as some deployment scenarios (web-based asset processors) would warrant AV:N. No EPSS score was provided in the available data, preventing probabilistic exploitation probability forecasting; however, the existence of a publicly referenced proof-of-concept meaningfully elevates real-world risk above what the raw score alone conveys, and even a mid-sized design studio or game development team in leszno running automated content pipelines built on cgltf-linked tooling should treat patching as a near-term priority rather than a deferred maintenance item. The absence of a CISA KEV listing indicates that widespread, observed exploitation has not yet occurred, but the low attack complexity and available PoC substantially reduce the skill threshold for exploitation. |
| Exploit ScenarioDerived | An attacker crafts a malformed .gltf or .glb file containing an accessor entry with a count value engineered to overflow when multiplied by the accessor stride, then delivers it to a user or automated pipeline that processes 3D assets through a cgltf-linked application. When cgltf_validate() processes the file, the integer overflow causes the bounds check to pass, and the subsequent call to cgltf_accessor_read_float() performs an out-of-bounds heap read, either crashing the host process or leaking adjacent heap contents - a publicly available proof-of-concept for this technique exists per the GitHub issue reference. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 19, 2026
Integer overflow in cgltf through version 1.15 allows remote attackers to bypass the library's accessor bounds validation, triggering a heap out-of-bounds read that produces both partial heap memory disclosure and reliable application crashes. Any software embedding cgltf - including game engines, 3D editors, and automated asset pipeline tools - that processes externally sourced .gltf or .glb files is exposed to this dual-impact flaw affecting the cgltf_validate() and cgltf_accessor_read_float() call chain. A publicly available proof-of-concept has been confirmed via a GitHub issue report; no active exploitation has been recorded in CISA KEV at time of analysis.
RemediationAI
No specific patched release version has been identified in the available data; the upstream fix is referenced via GitHub issue #301 at https://github.com/jkuhlmann/cgltf/issues/301, but a tagged, released patched version has not been independently confirmed - consumers should monitor the upstream repository directly and not assume a fix is available without verifying a formal release. As an immediate compensating control, applications should independently validate that accessor count values fall within safe bounds before passing any externally sourced data to cgltf_validate(), treating all accessor metadata from third-party files as untrusted input. Processing .gltf and .glb files within a sandboxed subprocess limits the blast radius of a successful heap out-of-bounds read to the sandboxed context, preventing heap content from leaking into privileged memory regions. Where the use case permits, disabling ingestion of third-party or user-supplied 3D asset files entirely eliminates the attack surface. The VulnCheck advisory at https://www.vulncheck.com/advisories/cgltf-integer-overflow-via-cgltf-validate-accessor-bounds-check should be monitored for patch status updates.
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 (CPE: cpe:2.3:a:jkuhlmann:cgltf:*:*:*:*:*:*:*:*) is a widely used single-header C library for parsing GL Transmission Format (glTF) 2.0 assets, a JSON-based open standard for 3D models and scenes. The root cause is CWE-190 (Integer Overflow or Wraparound): within the non-sparse accessor code path of cgltf_validate(), the bounds check computes accessor stride multiplied by element count as an unsigned integer. When an attacker supplies a crafted accessor count value, this multiplication silently wraps to a small value, causing the bounds check to succeed on a malformed accessor. When the caller subsequently invokes cgltf_accessor_read_float() on the now-validated-but-malformed accessor, a heap read beyond the allocated buffer boundary occurs. Because the vulnerability lives in the validation path itself, any application that trusts cgltf_validate()'s return value as a safety guarantee before reading accessor data is fully exposed.
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:N/PR:N/UI:P/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N
Malicious file delivered remotely; no privileges required; user interaction triggers local parsing; heap OOB read yields reliable crash (A:H) and limited memory disclosure (C:L).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
cgltf through 1.15 contains an integer overflow vulnerability in the non-sparse accessor bounds check within cgltf_validate() that allows remote attackers to cause memory disclosure and denial of service by supplying crafted accessor count values. Attackers can provide malformed .gltf or .glb input with a specially crafted accessor count to overflow the unsigned integer multiplication of accessor stride and element count, causing the bounds check to pass and triggering a heap out-of-bounds read when cgltf_accessor_read_float() is subsequently called on the validated malformed accessor.
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.
Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-62431
GHSA-5hg3-rg59-9qg4
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB