Skip to main content

cgltf EUVDEUVD-2026-62431

| CVE-2026-75148 MEDIUM
Integer Overflow or Wraparound (CWE-190)
2026-08-19 VulnCheck GHSA-5hg3-rg59-9qg4
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft malformed .gltf/.glb with overflow accessor count
  2. Delivery
    Deliver file to cgltf-processing application
  3. Exploit
    Integer overflow in stride × count multiplication
  4. Execution
    Bounds check bypass in cgltf_validate()
  5. Persist
    Heap OOB read in cgltf_accessor_read_float()
  6. Impact
    Memory 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

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

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 (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

Vendor (VulnCheck) PRIMARY 6.9 MEDIUM
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
vuln.today AI 7.1 HIGH

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).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

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

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Medium
popular single-header C library for glTF parsing in game engines and 3D tooling
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High

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 MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

54
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
PoC: +20
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.

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.

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