CVE-2026-111108

Apache Kafka: Broker OutOfMemoryError via array allocation amplification in code-generated protocol readers

Published Oct 28, 2026 CVSS 3.1 · 9.1 Critical EPSS < 1% KEV · Not listed
Description
Apache Kafka's code-generated protocol readers pre-size an array's collection from the element count declared by the sender. That count is checked only against the bytes remaining in the request buffer, which assumes about one byte per element; because most elements need several bytes, a request can declare far more elements than the buffer holds and still pass. For a keyed array the reader then allocates an ImplicitLinkedHashCollection of capacity (2 * count +1), so a request of a few tens of megabytes can force a heap allocation several times larger before any element is read. The pattern is emitted into every generated reader, so it affects all Kafka API types with an array field. 


Impact:

Request parsing happens before any authorization check. On a listener that does not require authentication (for example PLAINTEXT), an unauthenticated attacker can send a few concurrent requests that each declare a very large=

array length and allocate many times their wire size in broker heap, crashing the broker with an OutOfMemoryError. The reporter demonstrated three concurrent ~90 MB ProduceRequest (v3) connections exhausting a 1 GB heap (~8x amplification). On listeners that require authentication, the attacker needs valid credentials but no specific ACL, since parsing precedes authorization..


Mitigation:

Upgrade to Apache Kafka 4.2.2, 4.3.2, or 4.4.0. Until then, lowering socket.request.max.bytes and restricting network access to broker listeners reduces, but does not remove, exposure.


Resolution:

From Apache Kafka 4.2.2, 4.3.2, and 4.4.0: generated readers cap the initial array pre-allocation at MessageUtil.MAX_PREALLOCATED_ARRAY_CAPACITY (1000) and grow it on demand, and reject a declared array length above MessageUtil.MAX_ARRAY_LENGTH (1,000,000).

Analysis

AI-generated

Technical impact

Apache Kafka’s code‑generated protocol readers pre‑allocate array space based solely on the element count declared by a sender, assuming one byte per element. Because most elements require more bytes, a request can declare many more elements than actually exist in the request buffer. For keyed arrays, the reader allocates a linked hash collection with capacity (2*count+1), which can provoke a heap allocation far larger than the request size, before any element is read. If an attacker sends such a request, the broker can exhaust its heap and throw an OutOfMemoryError, terminating the process and rendering the service unavailable. The vulnerability is a classic case of insufficient input validation and unchecked resource allocation.

Affected Systems

The flaw affects all versions of Apache Kafka released by the Apache Software Foundation. The problem is present in every protocol reader generated for Kafka API types that contain an array field. Affected versions include all releases prior to 4.2.2, 4.3.2, and 4.4.0. The specific versions that contain the fix are 4.2.2, 4.3.2, and 4.4.0, which limit the pre‑allocation to 1,000 items and reject any declared array length above 1,000,000.

Risk and Exploitability

The CVSS score is 9.1, but the vulnerability can be leveraged by an unauthenticated attacker against any listener that does not require authentication (e.g., PLAINTEXT), or by an authenticated attacker against any listener that does require credentials, because request parsing occurs before authorization checks. The attacker may send several concurrent requests that each declare a large array length, causing the broker to allocate large temporal structures and crash. The EPSS score is < 1% and the weakness is not listed in the CISA KEV catalog, yet the impact is a remote denial of service with high potential impact on availability. The exploit requires only the ability to send crafted requests to an open broker listener; no special privileges or target‑specific configuration are needed beyond network access to the broker endpoint.

Remediation

No solution or workaround provided in the CVE record.

OpenCVE Recommended Actions

  • Upgrade Apache Kafka to version 4.2.2, 4.3.2, or 4.4.0, where generated readers cap the initial array pre‑allocation at 1,000 and reject any declared array length above 1,000,000.
  • Reduce the socket.request.max.bytes setting to lower the maximum size a request can request.
  • Restrict network access to broker listeners so that only trusted hosts can contact the broker.

Generated by OpenCVE AI on November 5, 2026 at 21:28 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories available
History
Type Values Removed Values Added
Metrics ssvc

{'options': {'Automatable': 'yes', 'Exploitation': 'none', 'Technical Impact': 'partial'}, 'version': '2.0.3'}

Type Values Removed Values Added
Metrics cvssV3_1

{'score': 7.5, 'vector': 'CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H'}

cvssV3_1

{'score': 9.1, 'vector': 'CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H'}

Type Values Removed Values Added
References
Metrics threat_severity

None

cvssV3_1

{'score': 7.5, 'vector': 'CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H'}

threat_severity

Important

Type Values Removed Values Added
First Time appeared Apache
Apache kafka
Vendors & Products Apache
Apache kafka
Type Values Removed Values Added
Description Apache Kafka's code-generated protocol readers pre-size an array's collection from the element count declared by the sender. That count is checked only against the bytes remaining in the request buffer, which assumes about one byte per element; because most elements need several bytes, a request can declare far more elements than the buffer holds and still pass. For a keyed array the reader then allocates an ImplicitLinkedHashCollection of capacity (2 * count +1), so a request of a few tens of megabytes can force a heap allocation several times larger before any element is read. The pattern is emitted into every generated reader, so it affects all Kafka API types with an array field.  Impact: Request parsing happens before any authorization check. On a listener that does not require authentication (for example PLAINTEXT), an unauthenticated attacker can send a few concurrent requests that each declare a very large= array length and allocate many times their wire size in broker heap, crashing the broker with an OutOfMemoryError. The reporter demonstrated three concurrent ~90 MB ProduceRequest (v3) connections exhausting a 1 GB heap (~8x amplification). On listeners that require authentication, the attacker needs valid credentials but no specific ACL, since parsing precedes authorization.. Mitigation: Upgrade to Apache Kafka 4.2.2, 4.3.2, or 4.4.0. Until then, lowering socket.request.max.bytes and restricting network access to broker listeners reduces, but does not remove, exposure. Resolution: From Apache Kafka 4.2.2, 4.3.2, and 4.4.0: generated readers cap the initial array pre-allocation at MessageUtil.MAX_PREALLOCATED_ARRAY_CAPACITY (1000) and grow it on demand, and reject a declared array length above MessageUtil.MAX_ARRAY_LENGTH (1,000,000).
Title Apache Kafka: Broker OutOfMemoryError via array allocation amplification in code-generated protocol readers
Weaknesses CWE-400
CWE-770
CWE-789
References
Weaknesses
  • CWE-400

    Uncontrolled Resource Consumption

  • CWE-770

    Allocation of Resources Without Limits or Throttling

  • CWE-789

    Memory Allocation with Excessive Size Value

Sources

Status
PUBLISHED
Assigner
apache
Published
Updated
Nov 5, 2026, 7:16 PM
Reserved
Oct 15, 2026, 3:57 PM
Status
Awaiting Analysis
Published
Oct 28, 2026, 5:17 PM
Modified
Nov 5, 2026, 8:17 PM
Severity
Important
Public date
Oct 28, 2026, 4:38 PM