Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-112019 Overview
CVE-2026-112019 is a heap out-of-bounds read vulnerability in the cgltf library through version 1.15. The flaw resides in cgltf_accessor_unpack_floats(), which advances the sparse values cursor using the base bufferViewbyteStride instead of the sparse accessor stride. Attackers can craft a glTF or GLB file that passes cgltf_validate() and still triggers reads beyond allocated heap memory. The out-of-bounds data may be copied into vertex buffers consumed by downstream rendering code, or it may crash the host application. The issue is tracked as CWE-125 Out-of-bounds Read.
Critical Impact
A malicious glTF or GLB asset can leak adjacent heap memory into application vertex data or crash any process that parses untrusted 3D models with cgltf.
Affected Products
- cgltf single-file glTF 2.0 parser, all versions through 1.15
- Applications and game engines that embed cgltf.h for glTF/GLB asset loading
- Any pipeline that calls cgltf_accessor_unpack_floats() on attacker-controlled sparse accessors
Discovery Timeline
- 2026-10-18 - CVE-2026-112019 published to NVD
- 2026-10-20 - Last updated in NVD database
Technical Details for CVE-2026-112019
Vulnerability Analysis
The cgltf library parses glTF 2.0 scene descriptions and binary GLB containers. glTF accessors support a sparse encoding that overrides a subset of values stored in a base bufferView. During unpacking, cgltf_accessor_unpack_floats() iterates over sparse indices and copies replacement float values from the sparse values buffer into the output array.
The function advances the sparse values cursor using the byteStride associated with the base accessor's bufferView. The sparse values buffer, however, is a separate bufferView with its own layout and may be packed tightly or use a different stride. When the base stride exceeds the sparse buffer's bounds, each iteration reads past the end of the sparse values allocation on the heap.
The parsed data is then written into vertex attribute arrays that applications hand to GPU drivers or physics engines, meaning leaked heap contents can propagate into rendered geometry or further processing.
Root Cause
The root cause is incorrect pointer arithmetic in the sparse accessor unpack path. The loop uses the base bufferViewbyteStride rather than the stride of the sparse values bufferView. Because cgltf_validate() does not reconcile the two stride values against the sparse values buffer length, a crafted file that is structurally valid still drives the cursor past the allocation boundary.
Attack Vector
Exploitation requires an attacker to deliver a crafted glTF or GLB file to a victim application and have that file parsed. The attack vector is local and requires user interaction, such as opening a model in a viewer, importing an asset into an editor, or loading a downloaded game mod. No authentication or privilege is required on the target process. See the HackMD analysis and the VulnCheck advisory for a full walkthrough of the sparse accessor layout that triggers the condition.
The vulnerable arithmetic is visible in the upstream source at the cgltf.h sparse unpack path and the related validation at cgltf.h validation path.
Detection Methods for CVE-2026-112019
Indicators of Compromise
- Application crashes or segmentation faults in processes that load .gltf or .glb files sourced from untrusted origins
- AddressSanitizer or similar runtime reports flagging heap-buffer-overflow reads inside cgltf_accessor_unpack_floats
- glTF assets whose sparse accessor valuesbufferView is shorter than indices.count * base.byteStride
Detection Strategies
- Build affected applications with AddressSanitizer and replay suspicious glTF/GLB samples through the parser to confirm out-of-bounds reads.
- Add a pre-parse validator that enforces sparse.values.offset + sparse.count * sparse_values_stride <= bufferView.length before calling cgltf_accessor_unpack_floats().
- Hash third-party model assets at ingest and compare against known-good baselines to flag newly introduced files for inspection.
Monitoring Recommendations
- Monitor endpoint telemetry for repeated crashes in processes that embed cgltf, including game engines, 3D viewers, and CAD tools.
- Log and review inbound glTF and GLB files from email, chat, mod portals, and asset marketplaces.
- Alert on child-process creation or memory anomalies tied to viewer executables immediately after a model file is opened.
How to Mitigate CVE-2026-112019
Immediate Actions Required
- Inventory all first-party and third-party software that bundles cgltf.h and record the pinned version in use.
- Treat all externally sourced glTF and GLB files as untrusted and sandbox any parsing workflow that handles them.
- Disable automatic preview or thumbnail generation for glTF/GLB attachments in file managers, chat clients, and asset portals until a patched build is deployed.
Patch Information
At the time of publication, no fixed release of cgltf is referenced in the advisory. Track the cgltf GitHub repository for a release that supersedes 1.15 and corrects the sparse values stride calculation. Vendors shipping applications that embed cgltf.h should rebuild and redistribute once the upstream patch lands.
Workarounds
- Apply a local source patch that computes the sparse values stride from sparse.values.bufferView.byteStride or the sparse component size, rather than the base bufferView.byteStride.
- Add bounds enforcement in cgltf_validate() that rejects accessors whose sparse values buffer cannot accommodate sparse.count elements at the computed stride.
- Route glTF and GLB parsing through an isolated low-privilege process so that out-of-bounds reads cannot leak sensitive memory from the host application.
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

