Skip to main content

Apache Kafka CVE-2026-111108

| EUVDEUVD-2026-112169 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-28 apache GHSA-ppj6-m59w-vr92
View

Attack ChainAIDerived

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

  1. Access
    Connect to broker listener
  2. Exploit
    Send request declaring oversized array length
  3. Execution
    Reader pre-allocates amplified heap collection
  4. Impact
    Broker exhausts heap (OutOfMemoryError)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Reachability is gated by listener authentication posture, because request parsing (where the over-allocation occurs) runs before any authorization check. On a listener configured without authentication - for example a PLAINTEXT listener - an unauthenticated attacker can trigger the flaw directly. On listeners that require authentication, the attacker needs valid credentials but no specific ACL. The flaw affects all Kafka API types that contain an array field, so no particular API or feature toggle is required beyond network reachability to a broker listener. Limiting factors: network access to a broker listener is needed, authenticated listeners require credentials, and the interim mitigation of lowering socket.request.max.bytes plus restricting network access to broker listeners reduces (but does not eliminate) exposure; the only complete fix is upgrading to 4.2.2, 4.3.2, or 4.4.0.

Impact

No CVSS vector, EPSS score, or KEV entry is provided in the input, so quantitative exploitation signals are absent and cannot be compared. The qualitative signals that ARE present point to a credible denial-of-service priority: the flaw is memory-allocation-without-limits (CWE-770) reachable during request parsing, which occurs before any authorization check, and the Apache advisory describes a working reporter demonstration (three concurrent ~90 MB ProduceRequest v3 connections exhausting a 1 GB heap at roughly 8x amplification). The vuln.today decision label is 'this_week', indicating prompt but not emergency remediation. Because parsing precedes authorization, exposure depends heavily on listener configuration: a listener that does not require authentication (e.g. PLAINTEXT) is reachable by a fully unauthenticated attacker, whereas authenticated listeners require valid credentials (but no specific ACL). This is a genuine availability risk for brokers exposing unauthenticated or internet-reachable listeners, but impact is confined to availability - there is no confidentiality or integrity component - so it is a real DoS priority rather than a critical compromise. EPSS and KEV data are missing, not low; absence of those signals should not be read as low real-world risk, and conversely no active exploitation is claimed.

Exploit ScenarioDerived

An attacker opens a few concurrent connections to a broker listener and sends requests whose declared array element count is far larger than the bytes actually present, exploiting that the count is validated only against remaining buffer bytes (~1 byte per element) while real elements and the keyed-array ImplicitLinkedHashCollection capacity (2*count+1) consume multiples of that. The Apache reporter demonstrated three concurrent ~90 MB ProduceRequest (v3) connections exhausting a 1 GB broker heap at about 8x amplification, crashing the broker with an OutOfMemoryError. No public exploit code is referenced, only this vendor demonstration.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet

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

Alert me

AnalysisAIv1 – Oct 28, 2026

Heap exhaustion in Apache Kafka allows remote attackers to crash brokers by sending requests that declare an array element count far exceeding the actual buffer contents, causing generated protocol readers to pre-allocate an ImplicitLinkedHashCollection with capacity 2*count+1 before reading any elements. Because parsing happens before authorization, listeners without authentication such as PLAINTEXT are exposed to unauthenticated attackers, while authenticated listeners require valid credentials but no specific ACL; the reporter demonstrated three concurrent ~90 MB ProduceRequest v3 connections exhausting a 1 GB heap (~8x amplification). Affected releases are prior to 4.2.2, 4.3.2, and 4.4.0, and no public exploit code has been identified at time of analysis.

RemediationAI

Vendor-released patch: Apache Kafka 4.2.2, 4.3.2, and 4.4.0. These releases 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). Upgrade to the fixed release for your branch. Until then, the vendor states that lowering socket.request.max.bytes and restricting network access to broker listeners reduces but does not remove exposure; the only complete fix is upgrading. Advisory: https://kafka.apache.org/cve-list.

Affected VersionsENISA

Apache Kafka 4.3.0 ≤4.3.1
Apache Kafka 4.2.0 ≤4.2.1
Apache Kafka 3.3.0 ≤4.1.2

Affected Packages

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

Apache Kafka's code-generated protocol readers pre-size collections from the element count declared by the sender, validating that count only against remaining request bytes under an assumption of roughly one byte per element. Most elements require several bytes, so a request can declare a much larger count than the buffer supports and still pass validation; for keyed arrays the reader allocates an ImplicitLinkedHashCollection of capacity (2 * count + 1), producing heap amplification several times the wire size before any element is read. The pattern is emitted into every generated reader, so all Kafka API types containing an array field are affected, and parsing occurs before authorization checks. This is CWE-770 (Allocation of Resources Without Limits or Throttling); the independently assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, availability-only impact. Fixed versions cap initial pre-allocation at MessageUtil.MAX_PREALLOCATED_ARRAY_CAPACITY (1000) and reject declared lengths above MessageUtil.MAX_ARRAY_LENGTH (1,000,000).

Know when Apache Kafka 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 (apache) PRIMARY HIGH
vuln.today AI 7.5 HIGH

Remotely reachable before auth on unauthenticated (e.g. PLAINTEXT) listeners so AV:N/AC:L/PR:N/UI:N; availability-only impact (A:H, C/I:N); PR would rise to L on authenticated listeners.

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

Primary rating from Vendor (apache).

DescriptionCVE.org

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

Executive ViewAI

Why It Matters

A high-severity heap exhaustion vulnerability in Apache Kafka (CVE-2026-111108) allows any unauthenticated attacker to crash brokers on listeners without authentication, such as PLAINTEXT, by sending malicious ProduceRequest messages. This puts organizations relying on unauthenticated Kafka listeners at risk of service outages, impacting downstream applications and business operations. Leadership should prioritize patching and restricting listener access to prevent denial-of-service attacks.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
High
widely deployed enterprise event-streaming platform
Data Quality
1 sources
Confidence: Low

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 HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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.

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

CVE-2026-33557 CRITICAL
9.1 Apr 20

Apache Kafka 4.1.0 and 4.1.1 accept forged JWT tokens without signature validation, allowing remote unauthenticated atta

CVE-2026-33558 MEDIUM
5.3 Apr 20

Apache Kafka's NetworkClient component logs entire request and response payloads at DEBUG level, exposing sensitive auth

CVE-2026-41115 MEDIUM
4.3 Jun 02

Improper authorization in Apache Kafka 4.0.0-4.3.0 arises from a discrepancy between the documented ACL requirement and

CVE-2026-114349 HIGH
Oct 28

Memory exhaustion in the Apache Kafka broker lets an authenticated principal holding Write permission on a topic submit

CVE-2026-112375 HIGH
Oct 28

Apache Kafka brokers that have an authorizer enabled will read a file or environment variable from the broker host and r

CVE-2026-116593 MEDIUM
Oct 28

Kafka Connect workers leak plaintext secrets through the REST API's /connector-plugins/{connector-type}/config/validate

CVE-2026-115644 LOW
Oct 28

Authentication bypass in Apache Kafka Connect's isolated admin REST API allows unauthenticated network attackers to read

CVE-2026-111551 HIGH
Oct 28

Network-reachable, unauthenticated deserialization flaws in Apache Kafka’s clients library and Kafka Streams can force m

CVE-2026-111496 LOW
Oct 28

Kafka Streams can be stalled indefinitely by a single record whose timestamp is at or near Long.MAX_VALUE, causing an in

CVE-2026-111115 HIGH
Oct 28

Unauthenticated remote attackers can exhaust broker heap and trigger process-wide GC stalls on Apache Kafka by declaring

CVE-2026-111073 MEDIUM
Oct 28

Apache Kafka brokers can be driven into heap exhaustion by any authenticated client because the PushTelemetry (KIP-714)

CVE-2026-110985 HIGH
Oct 28

Apache Kafka brokers that run SASL/OAUTHBEARER with the default DefaultJwtValidator and leave sasl.oauthbearer.jwks.endp

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