Skip to main content

cgltf CVE-2026-112018

| EUVDEUVD-2026-103471 HIGH
Out-of-bounds Write (CWE-787)
2026-10-18 VulnCheck GHSA-6vjv-6x7m-3wjx
7.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Deliver crafted glTF/GLB asset to victim
  2. Delivery
    Victim app loads file without cgltf_validate()
  3. Exploit
    Large sparse indices bypass bounds checks
  4. Execution
    cgltf_accessor_unpack_floats() writes past heap buffer
  5. Impact
    Heap 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

cgltf 0 ≤1.15

Affected Packages

euvd cgltf no fix

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

Vendor (VulnCheck) PRIMARY 7.3 HIGH
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
vuln.today AI 7.8 HIGH

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.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

Prevalence
Medium
popular single-header glTF loader embedded in many 3D/game tools, not ubiquitous
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy