Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted font with embedded wasm module
-
DeliveryUser renders font via Wasm shaper
-
ExploitWasm places output buffer at linear-memory edge
-
Executionfont_glyph_to_string writes past buffer bounds
-
ImpactCorrupt 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
An integer overflow in the component hb-ot-shape-fallback.cc of Harfbuzz v4.3.0 allows attackers to cause a Denial of Se
HarfBuzz is a text shaping engine. Rated critical severity (CVSS 9.3), this vulnerability is remotely exploitable, no au
HarfBuzz text shaping engine versions prior to 12.3.0 crash when the SubtableUnicodesCache::create function attempts to
hb-ot-layout-gpos-table.hh in HarfBuzz before 1.0.5 allows remote attackers to cause a denial of service (buffer over-re
Multiple unspecified vulnerabilities in HarfBuzz before 1.0.6, as used in Google Chrome before 48.0.2564.82, allow attac
HarfBuzz::Shaper for Perl versions before 0.032 contain a null pointer dereference in the bundled HarfBuzz library that
hb-ot-layout-gsubgpos.hh in HarfBuzz through 6.0.0 allows attackers to trigger O(n^2) growth via consecutive marks durin
NULL pointer dereference in HarfBuzz 8.0.0 through 14.6.0 lets a crafted font crash any application that shapes text wit
EUVD-2026-105095
GHSA-hqgm-v7cx-mq25
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB