Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain low-privilege local account access
-
DeliveryCraft malicious LLVM IR with oversized symbol name
-
ExploitSubmit IR to LLVM tool (llc, opt, or Clang)
-
ExecutionTrigger stack buffer overflow in llvm::StringMap::insert
-
ImpactCrash LLVM process, disrupting compilation pipeline
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack 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 | Local, authenticated access with at least a low-privilege user account is required - confirmed by the CVSS 4.0 vector's AV:L and PR:L metrics. The attacker must have the ability to supply input to LLVM's IR or symbol-processing pipeline, for example by submitting a crafted LLVM IR or bitcode file to tools such as llc, opt, or a Clang-based compiler invocation, or by triggering symbol table operations via an LLVM API consumer. No special non-default configuration of LLVM is required to reach the vulnerable code path. Remote exploitation is not possible - the attack vector is explicitly local. Exploitation does not affect network services, default-configured servers, or environments where LLVM is not installed and executable by the attacker. The primary limiting factors are: (1) the requirement for local shell or equivalent access, (2) the availability-only impact ceiling indicated by the CVSS vector, and (3) the absence of a network-exposed attack surface. |
| Impact | The CVSS 4.0 base score of 1.9 (Very Low) accurately reflects a tightly scoped threat: local attack vector, low privileges required, no confidentiality or integrity impact, and only limited availability impact. The E:P environmental modifier embedded in the provided vector confirms publicly available exploit code, which is the primary risk amplifier for this CVE. EPSS data was not provided in the intelligence feed, so exploitation probability cannot be quantified. This vulnerability is not listed in the CISA KEV catalog, and no active exploitation is confirmed. The real-world risk is concentrated in developer workstations, CI/CD build pipelines, and environments that process untrusted or third-party LLVM IR or bitcode - not in production servers, network appliances, or typical enterprise infrastructure where LLVM is not directly invoked. The availability-only CVSS impact profile strongly suggests this is a crash/denial-of-service primitive rather than a code-execution path; achieving arbitrary code execution from a stack overflow in this context would require additional complexity not reflected in the CVSS metrics. Organizations running automated LLVM-based compilation of untrusted inputs should treat the public POC as a meaningful escalation signal despite the low base score. |
| Exploit ScenarioDerived | A local attacker holding a low-privilege account on a developer workstation or CI/CD build host crafts a malicious LLVM IR file engineered to overflow the stack buffer in llvm::StringMap::insert during symbol table processing. The attacker submits this file to an LLVM-based tool such as llc, opt, or a Clang pipeline, causing the LLVM process to crash and disrupting any ongoing or automated compilation workload. A publicly available POC archive (https://github.com/user-attachments/files/28141697/poc.zip) demonstrates this crash, confirming exploitability requires minimal skill once local access is established. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 29, 2026
Stack-based buffer overflow in LLVM's ValueSymbolTable module (llvm-project versions up to 22.1.6) allows a local, low-privileged attacker to crash the LLVM process by triggering a malformed invocation of llvm::StringMap::insert in /lib/IR/ValueSymbolTable.cpp, resulting in limited availability impact only - no confidentiality or integrity compromise is indicated by the CVSS 4.0 vector. A proof-of-concept exploit has been publicly released, lowering the barrier to triggering the crash in affected developer or CI/CD environments. No active exploitation has been confirmed by CISA KEV, and the LLVM project had not issued a patch or public response as of disclosure.
RemediationAI
No vendor-released patch has been identified at time of analysis - the LLVM project had not publicly responded to the GitHub disclosure at https://github.com/llvm/llvm-project/issues/199187 as of the reporting date. Upstream fix availability should be monitored at https://github.com/llvm/llvm-project/ and the VulDB entry at https://vuldb.com/cve/CVE-2026-13573. As compensating controls: restrict LLVM tool execution to trusted, internally generated LLVM IR and bitcode only, preventing any untrusted input from reaching the ValueSymbolTable codepath (trade-off: limits use of third-party or externally sourced LLVM modules); deploy process-level sandboxing such as seccomp profiles, Linux namespaces, or container isolation around LLVM-based compilation jobs to contain the blast radius of a process crash (trade-off: adds operational complexity to build pipelines); and instrument CI/CD environments to alert on unexpected LLVM process terminations, which can serve as an early indicator of exploitation attempts. These mitigations reduce impact but do not eliminate the underlying overflow condition.
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
LLVM is a modular, open-source compiler infrastructure that underpins Clang, Swift, Rust, and numerous vendor toolchains. The vulnerable component is the ValueSymbolTable module (cpe:2.3:a:llvm:llvm-project:*:*:*:*:*:*:*:*), which manages named-value mappings within LLVM Intermediate Representation (IR) modules during compilation. The function llvm::StringMap::insert, located in /lib/IR/ValueSymbolTable.cpp, inserts string-keyed entries into a hash-map structure backed by stack-allocated memory. CWE-121 (Stack-based Buffer Overflow) identifies the root cause as insufficient bounds enforcement on that stack buffer, allowing a write beyond the allocated stack region when processing a specially crafted symbol or value name. This can corrupt adjacent stack frames, reliably crashing the LLVM process and, under precise memory layout conditions, potentially enabling code execution - though the CVSS vector's VA:L impact rating suggests the realistic outcome is a crash.
Know when Llvm 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:N/PR:L/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N/E:P
Local-only vector with low-privilege access required to invoke LLVM tools; stack overflow produces a crash with no confidentiality or integrity impact.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
2DescriptionCVE.org
A vulnerability was found in llvm llvm-project up to 22.1.6. This affects the function llvm::StringMap::insert in the library /lib/IR/ValueSymbolTable.cpp of the component ValueSymbolTable Module. The manipulation results in stack-based buffer overflow. Attacking locally is a requirement. The exploit has been made public and could be used. The project was informed of the problem early through an issue report but has not responded yet.
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.
A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.
LLVM a0dab4950 has a segmentation fault in mlir::outlineSingleBlockRegion. Rated medium severity (CVSS 5.5), this vulner
Heap-based buffer overflow in LLVM llvm-project through version 22.1.6 allows a local low-privilege attacker to crash af
llvm-project commit a0138390 was discovered to contain a segmentation fault via the component mlir::Type::isa<mlir::LLVM
llvm-project commit a0138390 was discovered to contain a segmentation fault via the component matchAndRewriteSortOp<mlir
llvm-project commit a0138390 was discovered to contain a segmentation fault via the component mlir::spirv::TargetEnv::Ta
llvm-project commit a0138390 was discovered to contain an assertion failure at !replacements.count(op) && "operation was
llvm-project commit 6c01b5c was discovered to contain a segmentation fault via the component mlir::Type::getDialect(). R
llvm-project commit bd456297 was discovered to contain a segmentation fault via the component mlir::Block::getArgument.
llvm-project commit fdbc55a5 was discovered to contain a segmentation fault via the component mlir::IROperand<mlir::OpOp
The GetHTMLRunDir function in the scan-build utility in Clang 3.5 and earlier allows local users to obtain sensitive inf
EUVD-2026-40115
GHSA-p6v6-grg5-r9mw
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB