Skip to main content

Llama Cpp EUVDEUVD-2026-17975

| CVE-2026-34159 CRITICAL
Buffer Overflow (CWE-119)
2026-04-01 GitHub_M
9.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Connect to unprotected RPC server port
  2. Delivery
    Send ALLOC_BUFFER/BUFFER_GET_BASE messages for pointer leaks
  3. Exploit
    Craft GRAPH_COMPUTE message with zero buffer field
  4. Execution
    Bypass bounds validation and read/write arbitrary memory
  5. Impact
    Achieve ASLR bypass and execute arbitrary code

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, buffer size validation
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

llama.cpp RPC backend must be exposed on network with TCP access. Attacker sends crafted GRAPH_COMPUTE messages with zero buffer field to bypass bounds validation in deserialize_tensor(). No authentication required. Affects versions prior to b8492. Default RPC configurations are vulnerable.

Impact

This vulnerability represents critical real-world risk across multiple threat intelligence signals. The CVSS 9.8 score accurately reflects severity: network attack vector (AV:N) enables remote exploitation, low complexity (AC:L) requires no special conditions, and no privileges or user interaction needed (PR:N/UI:N) maximizes attacker accessibility. The complete impact triad (C:H/I:H/A:H) confirms arbitrary code execution capability. While no public exploit identified at time of analysis and not listed in CISA KEV, the GitHub Security Advisory (GHSA-j8rj-fmpv-wcxw) provides detailed technical analysis including specific vulnerable functions and exploitation primitives (pointer leaks, ASLR bypass techniques). The RPC backend is network-exposed by design, and unauthenticated access means any attacker with TCP connectivity can exploit this. For organizations running llama.cpp RPC servers exposed to untrusted networks, this is an immediate patch priority. The combination of detailed public disclosure, network accessibility, and no authentication barrier significantly elevates exploitation probability despite absence of confirmed active exploitation. SSVC framework indicates immediate action required: exploitation technically feasible, automatable due to network protocol nature, and technical impact corresponds to total system compromise.

Exploit ScenarioDerived

An attacker identifies an internet-exposed llama.cpp RPC server port through network scanning. Without authentication, they establish a TCP connection and send specially crafted ALLOC_BUFFER and BUFFER_GET_BASE messages to leak process memory addresses, defeating ASLR protections. Subsequently, the attacker transmits malicious GRAPH_COMPUTE messages containing tensor data with buffer field set to 0, exploiting the missing bounds validation in deserialize_tensor() to write a ROP chain or shellcode into process memory. This achieves arbitrary code execution with the privileges of the llama.cpp server process, enabling lateral movement, data exfiltration of LLM models or training data, or deployment of persistence mechanisms on the compromised host.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 – Apr 01, 2026

Remote code execution in llama.cpp RPC backend allows unauthenticated attackers with TCP access to achieve arbitrary memory read/write and full ASLR bypass. The vulnerability stems from missing bounds validation in deserialize_tensor() when processing GRAPH_COMPUTE messages with zero-valued buffer fields. Attackers can leverage pointer leaks from ALLOC_BUFFER/BUFFER_GET_BASE operations to reliably exploit this flaw. Fixed in version b8492 (commit 39bf0d3c). CVSS 9.8 (Critical) with network attack vector, low complexity, and no authentication required. No public exploit identified at time of analysis, though the detailed advisory provides sufficient technical context for weaponization.

RemediationAI

Immediately upgrade llama.cpp to version b8492 or later, corresponding to commit 39bf0d3c6a95803e0f41aaba069ffbee26721042 or any subsequent release. The patch addresses the bounds validation gap in deserialize_tensor() as documented in pull request #20908 (https://github.com/ggml-org/llama.cpp/pull/20908). For environments unable to immediately patch, implement network-level access controls to restrict RPC server port access exclusively to trusted internal networks, eliminating exposure to untrusted sources. Consider disabling the RPC backend entirely if distributed compute functionality is not required for your deployment. Deploy intrusion detection signatures monitoring for anomalous GRAPH_COMPUTE message patterns or excessive ALLOC_BUFFER/BUFFER_GET_BASE requests that may indicate exploitation attempts. Verify patch application by confirming the deserialize_tensor() function includes buffer field validation logic. Review access logs for RPC endpoints to identify potential historical exploitation attempts prior to patching. Full remediation guidance available in the GitHub security advisory at https://github.com/ggml-org/llama.cpp/security/advisories/GHSA-j8rj-fmpv-wcxw.

Affected VersionsENISA

llama.cpp < b8492

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

llama.cpp is a C/C++ inference engine for Large Language Model execution, providing an RPC (Remote Procedure Call) backend for distributed compute operations. The vulnerability (CWE-119: Buffer Errors) exists in the RPC server's tensor deserialization logic, specifically in the deserialize_tensor() function. When processing incoming GRAPH_COMPUTE messages, the code fails to validate buffer boundaries if a tensor's buffer field is set to 0. This oversight creates an unchecked memory access condition where attacker-controlled data can directly manipulate process memory. The RPC protocol's ALLOC_BUFFER and BUFFER_GET_BASE operations inadvertently expose memory layout information, defeating Address Space Layout Randomization (ASLR). The affected component is cpe:2.3:a:ggml-org:llama.cpp, impacting all versions prior to commit 39bf0d3c. This is a classic buffer overflow scenario where input validation gaps in network-facing deserialization code create memory corruption primitives exploitable for arbitrary code execution.

Know when Llama Cpp 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 (GitHub_M) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
SUSE CRITICAL

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

llama.cpp is an inference of several LLM models in C/C++. Prior to version b8492, the RPC backend's deserialize_tensor() skips all bounds validation when a tensor's buffer field is 0. An unauthenticated attacker can read and write arbitrary process memory via crafted GRAPH_COMPUTE messages. Combined with pointer leaks from ALLOC_BUFFER/BUFFER_GET_BASE, this gives full ASLR bypass and remote code execution. No authentication required, just TCP access to the RPC server port. This issue has been patched in version b8492.

Executive ViewAI

Why It Matters

CVE-2026-34159 is a critical remote code execution vulnerability in llama.cpp's RPC backend that allows unauthenticated attackers with network access to execute arbitrary code and bypass memory protections. This affects any organization running llama.cpp RPC services exposed to untrusted networks, with no patch currently available from the vendor, creating immediate risk to AI inference infrastructure and any systems relying on this component.

Business Impact: Severe
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) Restrict network access to RPC service via firewall/network segmentation-limit to trusted internal IPs only; (2) Disable RPC backend entirely if not required for operations; (3) Deploy in isolated network segments with no external connectivity; (4) Monitor all RPC traffic for anomalous GRAPH_COMPUTE message patterns; (5) Implement endpoint detection and response (EDR) on systems hosting llama.cpp RPC to detect post-exploitation memory manipulation.

Threat Intelligence Overview

EPSS Score
0.1%
Top 68% exploitable
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor 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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

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

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

CVE-2024-42479 CRITICAL POC
10.0 Aug 12

Arbitrary memory write in llama.cpp's RPC server allows remote unauthenticated attackers to corrupt arbitrary memory add

CVE-2024-21802 HIGH POC
8.8 Feb 26

Remote code execution in llama.cpp (commit 18c2e17) is possible when a user opens a malicious .gguf model file, triggeri

CVE-2026-21869 HIGH POC
8.8 Jan 08

Llama.cpp server endpoints fail to validate the n_discard parameter from JSON input, allowing negative values that trigg

CVE-2024-21825 HIGH POC
8.8 Feb 26

Remote code execution in llama.cpp (commit 18c2e17) is possible when a victim loads a malicious .gguf model file, trigge

CVE-2024-23605 HIGH POC
8.8 Feb 26

Remote code execution in llama.cpp (GGUF library) allows attackers to achieve arbitrary code execution by tricking a use

CVE-2024-23496 HIGH POC
8.8 Feb 26

Remote code execution in llama.cpp (commit 18c2e17) occurs when the GGUF library's gguf_fread_str function parses a mali

CVE-2024-21836 HIGH POC
8.8 Feb 26

Heap-based buffer overflow in llama.cpp's GGUF library header parser (commit 18c2e17) enables code execution when a vict

CVE-2025-52566 HIGH POC
8.6 Jun 24

CVE-2025-52566 is a signed vs. unsigned integer overflow vulnerability in llama.cpp's tokenizer (llama_vocab::tokenize f

CVE-2024-42478 MEDIUM POC
5.3 Aug 12

llama.cpp provides LLM inference in C/C++. Rated medium severity (CVSS 5.3), this vulnerability is remotely exploitable,

CVE-2026-43629 CRITICAL
9.2 Aug 06

Heap buffer overflow in llama.cpp's server KV cache state-restore path (builds b4882 through b9058) lets an attacker who

CVE-2026-118375 CRITICAL
9.2 Oct 28

Stack-based out-of-bounds write in llama.cpp's ggml-rpc RDMA receive path (builds b8841 through b11865) lets unauthentic

CVE-2026-43631 CRITICAL
9.2 Aug 06

Remote code execution in llama.cpp's llama-server (builds b7492 through b9060) allows unauthenticated attackers to run a

Vendor StatusVendor

SUSE

Severity: Critical

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