Skip to main content

Apache Kafka EUVDEUVD-2026-112170

| CVE-2026-111115 HIGH
2026-10-28 apache GHSA-7xcv-9qfj-9q57
View

Attack ChainAIDerived

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

  1. Access
    Reach broker listener over network
  2. Delivery
    Craft flexible request header
  3. Exploit
    Declare ~20M tagged fields
  4. Execution
    Broker allocates RawTaggedField per field pre-auth
  5. Persist
    Heap exhaustion / GC stalls
  6. Impact
    Broker denial of service

Vulnerability Assessment

Exploitation Conditions

No special conditions - remote unauthenticated exploitation against default configurations of Apache Kafka brokers, because the flexible request header is parsed on the network thread before authentication, request dispatch, and quota accounting, and flexible APIs such as ApiVersions v3 use header version 2 by default; no Kafka resource ACL or quota is required. Limiting factors: the attacker needs network reachability to a broker listener, and the amplification is bounded by socket.request.max.bytes (lowering it reduces, but does not remove, exposure). Affected versions per EUVD are 2.4.0 through 4.1.2, 4.2.0 through 4.2.1, and 4.3.0 through 4.3.1; fixed in 4.2.2, 4.3.2, and 4.4.0, which bounds-check the tagged-field count (rejecting negative counts, counts exceeding remaining buffer bytes, or counts over a fixed maximum of 10,000) before any per-field allocation.

Impact

This is a pre-authentication, network-reachable denial-of-service in Apache Kafka brokers, and the signals point to a credible but not emergency priority. No CVSS vector was supplied by the source (CVSS: N/A), so severity must be assessed independently; based on the description this maps to a network/low-complexity/no-privilege availability impact (assessed 7.5). There is no CISA KEV listing and no EPSS score in the input, and no PoC or exploit reference is provided - so exploitation status is 'no public exploit identified at time of analysis.' The vuln.today decision label is 'this_week' rather than act_now/emergency, which is consistent with a vendor-reported, patch-available issue that is serious but not under observed active exploitation. The real-world concern is amplified by the fact that the malicious count is parsed in the flexible request header BEFORE authentication, dispatch, and quota accounting, so no ACL or credentials are required and quotas cannot throttle it; however, the impact is confined to availability (heap exhaustion / GC stalls / broker outage) with no stated confidentiality or integrity loss. Note a data conflict: the input Tags label this 'Information Disclosure,' which contradicts the description - the actual impact is denial of service, so that tag should not drive risk interpretation.

Exploit ScenarioDerived

An unauthenticated client with network access to a broker listener sends a request of a few tens of megabytes whose flexible request header (e.g. ApiVersions v3) declares roughly 20 million tagged fields, each encodable in as little as two bytes. The broker's network thread allocates one RawTaggedField object per declared field before any authentication, exhausting heap or inducing process-wide GC stalls and denying service. No public exploit or PoC is identified in the available sources.

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

Unauthenticated remote attackers can exhaust broker heap and trigger process-wide GC stalls on Apache Kafka by declaring an enormous tagged-field count in the flexible request header, which generated readers accept without checking it against the remaining buffer. The affected lines are 2.4.0 through 4.1.2, 4.2.0 through 4.2.1, and 4.3.0 through 4.3.1; because each declared field costs one RawTaggedField allocation and can be encoded in as little as two bytes, a request of a few tens of megabytes can force roughly 20 million allocations, and this happens on the network thread before authentication, request dispatch and request-time quota accounting, so APIs such as ApiVersions v3 are reachable pre-authentication. The outcome is availability-only denial of service; no public exploit identified at time of analysis, and vendor fixes are available in 4.2.2, 4.3.2 and 4.4.0, making this a this-week priority rather than an emergency.

RemediationAI

Upgrade to Apache Kafka 4.2.2, 4.3.2 or 4.4.0, which bound-check the tagged-field count for flexible-versioned messages - rejecting negative counts, counts exceeding the remaining buffer bytes, and counts above a fixed maximum of 10,000 - before any per-field allocation; choose the release matching the branch already deployed, and consult https://kafka.apache.org/cve-list for the vendor advisory. If upgrading cannot be completed immediately, the vendor states that lowering socket.request.max.bytes and restricting network access to broker listeners reduces, but does not remove, exposure: shrinking socket.request.max.bytes caps the frame size an attacker can use to smuggle the declared count and therefore the amplification factor, at the cost of rejecting legitimately large produce/fetch requests and increasing client-side errors for big payloads. Network-level restriction of broker listeners to trusted client subnets and load balancers (plus keeping inter-broker and controller listeners off untrusted networks) shrinks the pre-authentication attack surface but does not fix the parsing flaw, and because the header is parsed before authorization and quota accounting, Kafka ACLs and client quotas provide no mitigation here.

Affected VersionsENISA

Apache Kafka 4.3.0 ≤4.3.1
Apache Kafka 4.2.0 ≤4.2.1
Apache Kafka 2.4.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 wire protocol supports "flexible" versions (introduced via KIP-482) that replace many fixed fields with a trailing tagged-field section. On the wire, a flexible message or header begins with a tagged-field count encoded as an unsigned varint, followed by that many entries, each an unknown tag plus a size plus the field bytes; an entry can therefore be as small as two bytes. The generated deserializers in Kafka's message/header classes read the sender-declared count and, for every entry, retain a RawTaggedField object - the code bounded that count only by the outer request frame limit (socket.request.max.bytes) and never compared it against the bytes actually remaining in the buffer, nor against any absolute cap. Flexible request headers (header version 2) are parsed this way, and flexible APIs such as ApiVersions v3 use header version 2, so the amplification applies to the request header itself, which is decoded on the network thread before authorization, request dispatch and request-time quota accounting. The root cause class is an attacker-controlled length driving unbounded resource consumption; no CWE identifier or CVSS vector was supplied in the source data, and the independent assessment rates it CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (availability-only). The trigger is a single crafted request with a very large declared tagged-field count; no protocol-level precondition beyond network reachability to a broker listener is described. The supplied fix bounds-checks the tagged-field count in generated readers for flexible-versioned messages, rejecting negative counts, counts exceeding the remaining buffer bytes, and counts above a fixed maximum of 10,000, before any per-field allocation occurs.

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

Header is parsed pre-authentication over the network with a simple oversized count, so AV:N/AC:L/PR:N/UI:N; impact is broker availability only, so C:N/I:N/A:H.

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 readers for flexible protocol versions read a tagged-field count declared by the sender and retain a RawTaggedField object for each unknown field. That count was bounded only by the outer request frame size (socket.request.max.bytes); it was not checked against the remaining buffer bytes or capped. Because each entry can be encoded in as little as two bytes (unknown tag 0, size 0), a modest request can declare tens of millions of tagged fields and force one object allocation per declared field. Flexible request headers (header version 2, used by flexible APIs such as ApiVersions v3) are parsed this way, so the amplification applies to the request header itself.

Impact: The flexible request header is parsed on the network thread before authorization, request dispatch, and request-time quota accounting. A client can send a request of a few tens of megabytes whose header declares about 20 million tagged fields, forcing roughly that many RawTaggedField allocations and exhausting broker heap or inducing process-wide GC stalls, denying broker service. Because the header is parsed for pre-authentication APIs such as ApiVersions (v3), the allocation can occur before authentication; no Kafka resource ACL or quota is required.

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 bounds-check the tagged-field count for flexible-versioned messages, rejecting a negative count, a count exceeding the remaining buffer bytes, or a count exceeding a fixed maximum (10,000), before any per-field allocation.

Executive ViewAI

Why It Matters

A high-severity availability flaw in Apache Kafka versions 2.4.0 through 4.3.1 allows unauthenticated network attackers to trigger memory exhaustion and process-wide garbage collection stalls, potentially taking down Kafka brokers. This puts critical data pipelines and downstream applications at risk of outages, though no active exploitation has been observed and vendor patches are now available.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
High
Apache Kafka is widely deployed enterprise streaming/messaging infrastructure
Data Quality
2 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-111108 HIGH
Oct 28

Heap exhaustion in Apache Kafka allows remote attackers to crash brokers by sending requests that declare an array eleme

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