Description

llama.cpp builds b1283 through b9058 contain an integer overflow vulnerability in the llama_batch_init() function where unchecked multiplications in malloc() calls can wrap past INT32_MAX when computing allocation sizes. Attackers can pass specially crafted parameters to trigger integer overflow, causing heap corruption and potentially achieving arbitrary code execution through subsequent batch operations that write past allocated buffer boundaries.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "7.8",
  "pubDate": "2026-08-06T22:17:05.633Z",
  "pubdate": "2026-08-06T22:17:05.633Z",
  "executiveSummary": "An integer overflow vulnerability exists in the llama_batch_init() function within llama.cpp builds b1283 through b9058.\nThe flaw arises due to unchecked multiplications within dynamic memory allocation routines, specifically malloc() calls, which can wrap past INT32_MAX when calculating required buffer sizes.\nSuccessful exploitation of this vulnerability allows an attacker to cause heap corruption by passing specially crafted parameters.\nThis condition can potentially lead to arbitrary code execution through subsequent batch operations that write past allocated buffer boundaries.\nThe vulnerability impacts systems utilizing vulnerable versions of the llama.cpp library.\nRisk implications include loss of integrity and potential system compromise if an attacker successfully triggers the integer overflow via untrusted inputs.\nAttackers require the ability to pass malicious parameters to the batch initialization routine to facilitate exploitation.",
  "technicalDetails": "The root cause of the vulnerability resides in the llama_batch_init() function within the llama.cpp codebase, specifically affecting builds b1283 through b9058.\nDuring the execution of llama_batch_init(), the application computes memory allocation sizes by performing multiplication operations to determine the required buffer dimensions for batch processing.\nThese arithmetic calculations lack proper bounds checking and validation before being passed into standard memory allocation functions such as malloc().\nWhen an attacker supplies specially crafted parameters, the resulting multiplication operation exceeds the maximum integer capacity of INT32_MAX, causing an integer overflow and wrapping around to a smaller numerical value.\nConsequently, the malloc() function allocates a heap buffer that is significantly smaller than what is logically required by the subsequent operations.\nIn the attack flow, once the undersized heap buffer is allocated, subsequent batch operations attempt to write data based on the original, un-wrapped sizing parameters.\nThis mismatch results in a severe heap-based buffer overflow, corrupting adjacent heap metadata and memory structures.\nDepending on the heap layout and subsequent operations, this memory corruption can be leveraged by an adversary to achieve arbitrary code execution within the context of the running process.\nThe vulnerable component is the batch initialization logic within the library.\nExploitation does not inherently require authentication or specific privilege levels if the application exposes the vulnerable batch initialization interface to untrusted input sources or network exposure."
}