Skip to main content

LLVM EUVDEUVD-2026-40115

| CVE-2026-13573 LOW
Stack-based Buffer Overflow (CWE-121)
2026-06-29 VulDB GHSA-p6v6-grg5-r9mw
1.9
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Gain low-privilege local account access
  2. Delivery
    Craft malicious LLVM IR with oversized symbol name
  3. Exploit
    Submit IR to LLVM tool (llc, opt, or Clang)
  4. Execution
    Trigger stack buffer overflow in llvm::StringMap::insert
  5. Impact
    Crash 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

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

llvm-project 22.1.4
llvm-project 22.1.3
llvm-project 22.1.2
llvm-project 22.1.1
llvm-project 22.1.0
llvm-project 22.1.6
llvm-project 22.1.5

Affected Packages

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

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

Vendor (VulDB) PRIMARY 1.9 MEDIUM
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
vuln.today AI 3.3 LOW

Local-only vector with low-privilege access required to invoke LLVM tools; stack overflow produces a crash with no confidentiality or integrity impact.

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

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

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

Lifecycle Timeline

2
Severity Changed
Jun 29, 2026 - 15:22 NVD
MEDIUM LOW
CVSS changed
Jun 29, 2026 - 15:22 NVD
4.8 (MEDIUM) 1.9 (LOW)

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

EPSS Score
0.1%
Top 98% exploitable
Prevalence
High
core compiler infrastructure embedded in Clang, Xcode, Android NDK, Rust
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 LOW
CISA KEV No
Public POC Yes
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
High
Technical Impact
Partial

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
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.

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.

More in Llvm

View all
CVE-2023-26924 MEDIUM POC
5.5 Mar 27

LLVM a0dab4950 has a segmentation fault in mlir::outlineSingleBlockRegion. Rated medium severity (CVSS 5.5), this vulner

CVE-2026-13574 LOW POC
1.9 Jun 29

Heap-based buffer overflow in LLVM llvm-project through version 22.1.6 allows a local low-privilege attacker to crash af

CVE-2023-29942 MEDIUM
5.5 May 05

llvm-project commit a0138390 was discovered to contain a segmentation fault via the component mlir::Type::isa<mlir::LLVM

CVE-2023-29941 MEDIUM
5.5 May 05

llvm-project commit a0138390 was discovered to contain a segmentation fault via the component matchAndRewriteSortOp<mlir

CVE-2023-29939 MEDIUM
5.5 May 05

llvm-project commit a0138390 was discovered to contain a segmentation fault via the component mlir::spirv::TargetEnv::Ta

CVE-2023-29935 MEDIUM
5.5 May 05

llvm-project commit a0138390 was discovered to contain an assertion failure at !replacements.count(op) && "operation was

CVE-2023-29934 MEDIUM
5.5 May 05

llvm-project commit 6c01b5c was discovered to contain a segmentation fault via the component mlir::Type::getDialect(). R

CVE-2023-29933 MEDIUM
5.5 May 05

llvm-project commit bd456297 was discovered to contain a segmentation fault via the component mlir::Block::getArgument.

CVE-2023-29932 MEDIUM
5.5 May 05

llvm-project commit fdbc55a5 was discovered to contain a segmentation fault via the component mlir::IROperand<mlir::OpOp

CVE-2014-2893 LOW
1.9 Apr 23

The GetHTMLRunDir function in the scan-build utility in Clang 3.5 and earlier allows local users to obtain sensitive inf

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