Skip to main content

HarfBuzz CVE-2026-113679

| EUVDEUVD-2026-105095 HIGH
Out-of-bounds Write (CWE-787)
2026-10-20 VulnCheck GHSA-hqgm-v7cx-mq25
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 font with embedded wasm module
  2. Delivery
    User renders font via Wasm shaper
  3. Exploit
    Wasm places output buffer at linear-memory edge
  4. Execution
    font_glyph_to_string writes past buffer bounds
  5. Impact
    Corrupt or crash host process

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 HarfBuzz to be built with the EXPERIMENTAL WebAssembly shaper enabled (compiled with Wasm/WAMR support, HAVE_WASM) - this feature is disabled in default builds, which is the primary limiting factor. The attacker must supply a crafted font that embeds a WebAssembly module, and that module must arrange its linear memory so the output buffer sits near the end of linear memory, so that font_glyph_to_string's glyph-name write (mis-declared via the wrong WAMR signature) overflows into host memory. A user or application must actually load and shape the malicious font (UI:P / passive interaction). No authentication is required to supply the font (PR:N), but the combination of a non-default experimental shaper plus the precise memory-layout requirement (AT:P) substantially narrows realistic exploitation.

Impact

This is a memory-corruption flaw (CWE-787, out-of-bounds write) that looks serious on paper but carries significant real-world limiting factors that lower its practical priority. The CVSS 4.0 vector (7.3) shows AV:L (local), AT:P (a specific attack requirement must be present), PR:N (no privileges), UI:P (passive user interaction), with high confidentiality/integrity/availability impact but no scope change (SC/SI/SA:N) - consistent with corrupting the host process that renders a font rather than breaking out to other systems. The decisive mitigating signal is in the description itself: the bug lives ONLY in the EXPERIMENTAL WebAssembly shaper, which is disabled in default HarfBuzz builds and requires the library to be compiled against a Wasm runtime (WAMR) with the WASM shaper explicitly enabled - so the vast majority of HarfBuzz deployments are NOT affected. No EPSS score, no KEV listing, and no public exploit were provided; exploitation status is therefore 'no public exploit identified at time of analysis.' There is no conflict between signals here, but note that the headline 'HarfBuzz is everywhere' intuition is misleading: the ubiquity of HarfBuzz does NOT translate to ubiquity of the vulnerable configuration. A vendor patch (PR 6414) is confirmed available. Net assessment: a legitimate bug worth patching, but low immediate exploitation urgency given the off-by-default experimental feature and absence of exploitation signals.

Exploit ScenarioDerived

An attacker crafts a font file embedding a malicious WebAssembly module and lures a user of an application built with HarfBuzz's experimental Wasm shaper into rendering it. The wasm module arranges its output buffer near the end of linear memory so that when font_glyph_to_string writes glyph-name bytes (using the wrong WAMR signature), the write spills past the buffer into adjacent host memory, crashing or corrupting the application. No public exploit code was identified at time of analysis, and the required memory-layout condition plus the experimental, non-default shaper make reliable exploitation non-trivial.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 20, 2026

An out-of-bounds write in HarfBuzz 8.0.0 through 14.6.0 allows a crafted font containing an embedded WebAssembly module to write glyph-name bytes past the end of the module's linear memory and into host process memory, crashing or potentially corrupting the consuming application. The flaw only manifests in builds where the experimental WebAssembly shaping backend is compiled in (HAVE_WASM/WAMR support), which is disabled by default; the attacker must also precisely arrange the module's memory layout so the output buffer sits at the end of linear memory, and a victim must load and shape the malicious font. Per the available data there is confirmed active exploitation is not indicated and no public exploit code was identified at time of analysis; upstream fix code exists as a pull request but a tagged patched release was not independently confirmed, and the non-default build requirement plus the precise layout precondition keep practical risk below what the raw memory-corruption classification suggests.

RemediationAI

Patch status: upstream fix available (PR/commit); released patched version not independently confirmed - apply the change in https://github.com/harfbuzz/harfbuzz/pull/6414 (commit 5e821de8256d01780566b5c8ab7886fae4c93da8), which corrects the font_glyph_to_string WAMR signature from "(ii$*)" to "(iiii)", adds ptr_d(char, s) with HB_ARRAY_PARAM bounds validation, and hardens adjacent wasm API entry points; downstream distributors should carry this commit until a tagged release containing it is published, and consumers should track the vendor advisory. The most effective compensating control is to build HarfBuzz with the experimental shaper disabled (meson -Dwasm=disabled / omit HAVE_WASM and WAMR linkage) - the trade-off is that fonts relying on wasm shaping fall back to the standard shapers, which is acceptable for almost all deployments since the feature is experimental. Where wasm support must be retained, do not point the shaper at untrusted module directories (leave HB_WASM_MODULE_DIR unset) and avoid shaping untrusted fonts in privileged or memory-sensitive processes; the trade-off is loss of wasm-based shaping for legitimate fonts. Additional containment with lower assurance includes running font shaping in a sandboxed or least-privileged subprocess and enabling allocator hardening / ASan-style canaries in staging, though these reduce rather than eliminate the overflow's impact.

Affected VersionsENISA

harfbuzz 8.0.0 ≤14.6.0

Affected Packages

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

HarfBuzz 8.0 added an experimental shaper that lets a font ship a WebAssembly module, executed through the WebAssembly Micro Runtime (WAMR), to compute glyph shaping in a sandboxed linear memory. Host functions are exposed to the module through a native symbol table defined in src/hb-wasm-api-list.hh, where each entry declares a WAMR signature string controlling how arguments are marshalled between the guest module and the host. The font_glyph_to_string import was registered with the signature "(ii$*)", which does not match the host function's actual prototype of (face, font, glyph, char *s, uint32_t size); the corrected upstream registration is "(iiii)" alongside a ptr_d(char, s) parameter type and an HB_ARRAY_PARAM validation macro in src/hb-wasm-api-font.hh and src/hb-wasm-api.h. Because the output pointer was not translated and bounds-checked as a guest-memory pointer, a module that places the destination buffer near the end of its linear memory can cause the host-side glyph-name write to spill beyond the memory region into host address space - the classic CWE-787 out-of-bounds write pattern. The same upstream fix hardens neighbouring entry points (buffer_set_contents, face_create, font_get_glyph_extents, font_set_coords, font_copy_glyph_outline null/n-contour checks), indicating a general audit of the WASM API marshalling layer. The affected product identifier is cpe:2.3:a:harfbuzz:harfbuzz:*:*:*:*:*:*:*:*, constrained in practice to builds configured with wasm support; scoring reflects local attack vector, high attack complexity/attack requirements, no privileges required, and user interaction (CVSS:4.0 AT:P/UI:P; the assessor's CVSS:3.1 equivalent is AV:L/AC:H/PR:N/UI:R with high confidentiality, integrity and availability impact).

Know when Harfbuzz 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.0 HIGH

Local font processing (AV:L); the required precise linear-memory layout maps to AC:H; no privileges to supply a font (PR:N) but the victim must render it (UI:R); host-process corruption gives high C/I/A with unchanged scope.

3.1 AV:L/AC:H/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
Red Hat 7.0 MEDIUM

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

HarfBuzz 8.0.0 through 14.6.0 contains an out-of-bounds write vulnerability in the experimental WebAssembly shaper because the font_glyph_to_string import has a wrong WAMR signature. Attackers can supply a crafted font whose wasm module places the output buffer near linear memory's end, writing glyph-name bytes into host memory to crash or corrupt applications.

Executive ViewAI

Why It Matters

HarfBuzz, a font-shaping library embedded in many applications, has a high-severity memory-corruption flaw that can crash or corrupt consuming software when a crafted font is processed. Exposure is narrow because it only affects non-default builds with the experimental WebAssembly shaping backend enabled and requires a victim to load a specifically arranged font; no public exploit code was identified at time of analysis. Leadership should care because affected builds may exist in product or internal applications that process untrusted fonts, and build-flag confirmation plus patch adoption will limit operational disruption.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
HarfBuzz is ubiquitous but the vulnerable Wasm shaper is experimental and off by default
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment MSRC Vendor GitHub

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 Yes
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
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
Medium
Technical Impact
Total

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.

Vendor StatusVendor

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