Skip to main content

LLVM EUVDEUVD-2026-40118

| CVE-2026-13574 LOW
Heap-based Buffer Overflow (CWE-122)
2026-06-29 VulDB GHSA-pf97-7r98-qpj7
1.9
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Obtain local low-privilege access
  2. Delivery
    Craft malformed LLVM bitcode file
  3. Exploit
    Supply file to LLVM bitcode handler
  4. Execution
    Trigger heap overflow in GCRelocateInst::getBasePtr
  5. Impact
    LLVM tool process crashes

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 the attacker to have an active local session on the target system with at least low-privilege user credentials, confirmed by CVSS AV:L and PR:L. The attacker must be able to supply a crafted bitcode (.bc) file as input to an LLVM tool that invokes the Bitcode File Handler, specifically triggering the GCRelocateInst::getBasePtr code path associated with GC relocation intrinsics. Systems where LLVM tools process only trusted, internally authored bitcode - such as locked-down CI runners with no external input ingestion - are not realistically exploitable without prior local compromise. Exploitation is further bounded by impact: the heap overflow results in a crash of the LLVM process (Availability: Low) with no confirmed confidentiality or integrity impact, limiting the attacker's gain to denial-of-service of the affected tool. Remote exploitation is not feasible given the local attack vector.

Impact

The CVSS 4.0 base score of 1.9 is consistent with the constrained attack surface: AV:L requires the attacker to already have local system access, PR:L requires low-privilege credentials, and the only confirmed impact is VA:L (low availability - a process crash). The supplemental E:P modifier confirms a POC exists, which marginally increases practical reproducibility but does not elevate the exploitability beyond local crash scenarios. No EPSS data was provided; given the local-only vector and narrow impact, exploitation probability in the wild is expected to be low. The vulnerability is absent from CISA KEV, confirming no observed active exploitation at time of analysis. Despite CWE-122 being a class historically associated with code execution primitives, the CVSS scoring assigns zero confidentiality and integrity impact, indicating the overflow results in a crash rather than controlled memory corruption. The primary real-world risk is a denial-of-service against LLVM-based build pipelines where externally sourced bitcode is processed. The absence of a vendor patch and the presence of a public POC are the two signals that warrant tracking, but overall priority is low given the local-only vector.

Exploit ScenarioDerived

A local attacker with a standard unprivileged account on a developer workstation or CI build server crafts a malformed LLVM bitcode file that causes an out-of-bounds write when GCRelocateInst::getBasePtr processes an invalid GC relocation intrinsic operand. The attacker invokes an LLVM tool such as opt or llc against the crafted file, triggering a heap corruption that crashes the tool process. A proof-of-concept archive has been publicly released (https://github.com/user-attachments/files/28142619/poc.zip), lowering the barrier to reproduction.

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

Heap-based buffer overflow in LLVM llvm-project through version 22.1.6 allows a local low-privilege attacker to crash affected LLVM tooling by supplying a crafted bitcode file that triggers an out-of-bounds heap write in the GCRelocateInst::getBasePtr function within the Bitcode File Handler component. The LLVM project was notified via a GitHub issue report but has not yet responded or released a patch. A proof-of-concept exploit has been publicly disclosed, and no active exploitation is confirmed in CISA KEV.

RemediationAI

No vendor-released patch has been identified at time of analysis, as the LLVM project has not yet responded to the coordinated disclosure reported via GitHub issue https://github.com/llvm/llvm-project/issues/199191. Organizations should monitor this issue tracker and upgrade as soon as a patched release is available. As a compensating control, restrict build pipelines so that only trusted, internally generated bitcode files are processed by LLVM tools such as llc or opt - do not allow externally sourced or user-submitted .bc files to be fed to the bitcode handler without prior sandboxing. Run LLVM build tools inside isolated containers or with syscall filtering (e.g., seccomp) so that a heap crash cannot cascade to other processes; the trade-off is added operational complexity in CI/CD environments. Restricting which local users can invoke LLVM bitcode processing tools reduces the pool of potential attackers, though this may impact developer workflows.

Affected VersionsENISA

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

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 bitcode is a compact binary serialization of LLVM Intermediate Representation (IR), used extensively in link-time optimization (LTO), cross-platform compilation, and JIT frameworks. The affected function GCRelocateInst::getBasePtr resides in llvm/lib/IR/IntrinsicInst.cpp and handles GC (garbage collector) relocation intrinsics embedded in bitcode files. CWE-122 (Heap-based Buffer Overflow) describes the root cause: when parsing a specially crafted bitcode file, the function writes past the boundary of a heap-allocated buffer, potentially corrupting adjacent heap metadata or data. The CPE cpe:2.3:a:llvm:llvm-project:*:*:*:*:*:*:*:* confirms the affected software is the upstream llvm-project repository across all platforms, through version 22.1.6.

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 low-privilege access required to pass crafted bitcode; scope unchanged and impact limited to process crash with no confidentiality or integrity effect.

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 determined in llvm llvm-project up to 22.1.6. This impacts the function GCRelocateInst::getBasePtr in the library llvm/lib/IR/IntrinsicInst.cpp of the component Bitcode File Handler. This manipulation causes heap-based buffer overflow. It is possible to launch the attack on the local host. The exploit has been publicly disclosed and may be utilized. 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 used across Apple, Rust, Android, and FreeBSD toolchains
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 heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

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-13573 LOW POC
1.9 Jun 29

Stack-based buffer overflow in LLVM's ValueSymbolTable module (llvm-project versions up to 22.1.6) allows a local, low-p

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