Skip to main content

stb_truetype CVE-2026-18497

| EUVDEUVD-2026-54489 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-08-07 certcc GHSA-fhqp-xwqm-2m94
7.1
CVSS 3.1 · Vendor: certcc
View

Attack ChainAIDerived

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

  1. Access
    Craft malformed TTF with inflated endPtsOfContours and truncated glyph data
  2. Delivery
    Deliver file to target filesystem via download, asset package, or user upload
  3. Exploit
    User or application triggers font load
  4. Execution
    stbtt__GetGlyphShapeTT() reads past heap buffer boundary
  5. Impact
    Heap memory disclosure and/or application crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
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 three concurrent conditions: (1) the target application statically embeds stb_truetype.h at version 1.26 or earlier; (2) the application loads TTF font files from an attacker-controllable source - such as user-uploaded fonts, downloaded game assets, or file paths passed as arguments; and (3) a user or automated process actively triggers font loading (UI:R per CVSS vector - passive presence of the file is insufficient). The attack vector is local (AV:L), meaning the malicious TTF must be accessible on the local filesystem at load time. Exploitation is bounded to heap memory disclosure and application crash; there is no modeled write primitive or integrity impact. Applications that exclusively load fonts from a fixed, internally-bundled, vendor-controlled set are not exploitable, as the attacker cannot inject a malformed file into the load path.

Impact

The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:H) scores 7.1 and indicates a local attack requiring user interaction - the malicious TTF file must reach the local filesystem and be opened by the target application. High confidentiality impact reflects potential heap memory disclosure; high availability reflects application crash; no integrity impact is modeled. EPSS at 0.16% (5th percentile) strongly corroborates low current exploitation activity, and the absence of a CISA KEV entry confirms no confirmed in-the-wild exploitation. The primary real-world risk multiplier is the library's broad embedding footprint: because stb_truetype.h is copied directly into application source trees, each consuming application must be independently patched, and vendors may not be aware they are affected. However, the local attack vector and mandatory user interaction substantially limit opportunistic or wormable exploitation. No conflicting signals exist between CVSS, EPSS, and KEV data - the signals are consistent.

Exploit ScenarioDerived

An attacker crafts a malformed TTF file with an inflated endPtsOfContours value and deliberately truncated glyph data, then delivers it to a victim as a game asset, document resource, or downloadable font - any mechanism that causes the target application to call stbtt_GetGlyphShape() on the file. When the application processes the font, stbtt__GetGlyphShapeTT() reads beyond the heap-allocated glyph buffer, potentially exposing adjacent heap contents (memory disclosure) or crashing the process. No public proof-of-concept code has been identified, though the GitHub issue (https://github.com/nothings/stb/issues/1905) provides sufficient technical detail to facilitate independent reproduction.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 12, 2026

Heap buffer overflow in stb_truetype.h (nothings stb, up to version 1.26) allows a local attacker to trigger out-of-bounds heap reads by supplying a crafted TTF font file with an inflated endPtsOfContours value and truncated glyph data. Any application statically embedding this library - including game engines and graphics software - that loads attacker-controlled fonts via stbtt_GetGlyphShape() is exposed to potential heap memory disclosure and application crash. No public exploit code has been identified and EPSS at 0.16% (5th percentile) indicates low current exploitation probability; no CISA KEV listing confirms no confirmed active exploitation at time of analysis.

RemediationAI

The primary fix is to update the embedded stb_truetype.h to a version that addresses this overflow - monitor https://github.com/nothings/stb/issues/1905 for patch availability, as no independently confirmed patched tagged release version was present in the source data at time of analysis. CERT/CC advisory VU#987105 (https://kb.cert.org/vuls/id/987105) should also be consulted for vendor-specific guidance on downstream applications. As a compensating control, applications should restrict font loading strictly to trusted, internally-controlled TTF files and reject any externally-sourced or user-supplied font input before it reaches stbtt_GetGlyphShape(); this eliminates the attack surface without requiring a library update but may break legitimate user-driven font customization features. If input validation is impractical, process font parsing in a sandboxed subprocess or with memory-safe wrappers to contain the impact of a triggered overflow.

Affected VersionsENISA

nothings stb 1.26

Affected Packages

euvd nothings_stb 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

stb_truetype.h is a single-file, public-domain C library authored by Sean Barrett (nothings) that parses and rasterizes TrueType fonts; it is commonly statically embedded directly into application source trees rather than linked as a shared library. CWE-122 (Heap-based Buffer Overflow) identifies the root cause: the function stbtt__GetGlyphShapeTT() reads glyph contour point data from a TrueType 'glyf' table entry without validating that the endPtsOfContours field is consistent with the actual buffer length. By inflating endPtsOfContours and truncating the remaining glyph payload, an attacker causes the parser to walk off the end of the heap-allocated glyph buffer. The affected CPE is cpe:2.3:a:sean_barrett_(nothings):nothings_stb:*:*:*:*:*:*:*:*, covering all versions through 1.26 as confirmed by EUVD-2026-54489 and NVD.

Know when Nothings Stb 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 (certcc) PRIMARY 7.1 HIGH
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:H
vuln.today AI 7.1 HIGH

Malicious TTF must reach local filesystem (AV:L, UI:R); attacker needs no system privileges to craft or deliver the file (PR:N); overflow enables heap read (C:H) and crash (A:H) with no write primitive (I:N).

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

Primary rating from Vendor (certcc).

CVSS VectorVendor: certcc

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
High

Lifecycle Timeline

3
CVSS changed
Aug 12, 2026 - 14:22 NVD
7.1 (HIGH)
CVE Published
Aug 07, 2026 - 14:19 cve.org
UNKNOWN (no severity yet)
CVE Published
Aug 07, 2026 - 14:19 cve.org
HIGH 7.1

DescriptionCVE.org

A heap-buffer-overflow vulnerability exists in the nothings stb TrueType library, up to version 1.26, that is used for parsing TrueType font files. The vulnerability exists in the stbtt__GetGlyphShapeTT() function within the nothings stb_truetype.h library when parsing malformed TTF (TrueType Font) files. The vulnerability resides in the glyph data parsing path.

An attacker can craft a malformed TTF file with an inflated endPtsOfContours value and truncate the remaining glyph data. When an application utilizing stb_truetype.h (such as various game engines or graphics software) attempts to load, bake, or render this malformed font via stbtt_GetGlyphShape(), the parser will attempt to read past the end of the glyph data buffer, triggering the out-of-bounds read.

Executive ViewAI

Why It Matters

The stb_truetype library (versions 1.26 and earlier) contains a heap buffer overflow affecting statically-embedded applications including game engines, graphics software, and design tools that load untrusted TTF font files. No public exploit identified at time of analysis, with current exploitation probability at 0.2% EPSS; however, successful attacks could disclose sensitive heap memory or crash applications, impacting confidentiality and availability.

Business Impact: High
Compensating Controls

Restrict TTF font loading to pre-validated, trusted sources only. Implement strict TTF file structure validation with explicit bounds checking on endPtsOfContours values. Disable or restrict font uploads and rendering from external or user-supplied sources. Monitor the nothings stb repository for security updates and patch availability.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Medium
popular single-header font library widely embedded in game and graphics projects
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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

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.

A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

Vendor StatusVendor

SUSE

Severity: Important

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