Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition as malicious or impersonated broker
-
DeliveryVictim client opens Kafka connection
-
ExploitSend response frame with oversized 4-byte length prefix
-
Executionreceive_bytes() skips bounds check
-
PersistMulti-GB allocation or uncaught ValueError
-
ImpactConsumer process OOM or heartbeat stalls
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Attacker must be able to deliver bytes to the kafka-python client's TCP socket as if they were a Kafka broker response - either by operating a broker the victim bootstraps against, compromising a legitimate broker, or sitting on the network path of a non-TLS Kafka connection. No victim-side authentication, user interaction, or configuration changes are required; the vulnerable receive_bytes() path runs on every connection by default in all of KafkaConsumer, KafkaProducer, and KafkaAdminClient. Limiting factors: the attacker needs broker-position or MITM-position (not arbitrary internet reach), and impact is confined to availability of the kafka-python process - no code execution or data disclosure. |
| Impact | CVSS 4.0 8.7 is driven entirely by VA:H with VC:N/VI:N - this is a pure availability bug, not RCE or data exposure. AV:N/AC:L/AT:N/PR:N/UI:N is technically correct but materially misleading: exploitation requires the attacker to control or impersonate a Kafka broker the victim client connects to, which is not the same threat surface as a generic internet-exposed service. Realistic threat actors are malicious or compromised brokers in shared/multi-tenant Kafka deployments, or network-position attackers on unencrypted (non-TLS) Kafka traffic. No CISA KEV listing, no EPSS score provided, no public exploit identified at time of analysis. Priority should be moderate-to-high for shops running kafka-python consumers against untrusted or cross-tenant brokers (e.g., SaaS data pipelines), and lower for fully internal deployments with TLS and trusted broker fleets. |
| Exploit ScenarioDerived | An attacker who controls a Kafka broker the victim client connects to (e.g., a malicious tenant in a shared cluster, a rogue insider, or a network attacker on plaintext Kafka traffic) sends a response frame whose 4-byte length prefix declares ~2 GB. The kafka-python parser attempts to allocate that buffer, exhausting victim process memory and triggering OOM-kill, or alternatively raises an uncaught ValueError that leaves the consumer's connection state broken and stops group heartbeats until the process is restarted. No public exploit identified at time of analysis, but the trigger is a one-packet condition trivially reproducible from any custom Kafka server stub. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv3 – Jun 10, 2026
Denial of service in the kafka-python client library (versions prior to 2.3.2) allows a malicious Kafka broker or man-in-the-middle attacker to exhaust client memory or wedge connections by sending a crafted 4-byte frame length header. The protocol parser's receive_bytes() function performs no bounds check on the declared frame size, leading to multi-gigabyte allocations or uncaught ValueError exceptions that stop consumer heartbeats. No public exploit identified at time of analysis; reported by VulnCheck with an upstream patch already merged.
Earlier versions of this analysis (2)
Denial of service in kafka-python prior to 2.3.2 allows a malicious broker or man-in-the-middle attacker to exhaust client memory or hang consumer connections by sending an unvalidated 4-byte frame length value to the protocol parser. The receive_bytes() function in kafka/protocol/parser.py accepted attacker-controlled frame sizes without bounds checking, enabling multi-gigabyte allocations or uncaught ValueErrors that leave consumers unable to heartbeat until restart. No public exploit identified at time of analysis, but the upstream fix is confirmed via merged GitHub PRs #3019 and #3026.
Denial of service in kafka-python before 2.3.2 lets a malicious Kafka broker or machine-in-the-middle attacker hang client connections and exhaust memory by sending a crafted 4-byte frame length, causing consumers to stop heartbeating and producers to stall until restart. The flaw sits in the protocol parser's receive_bytes() path, which accepts attacker-controlled frame sizes without bounds checking, and no public exploit identified at time of analysis though the upstream fix is available.
RemediationAI
Vendor-released patch: upgrade kafka-python to 2.3.2 or later, which adds bounds checking in KafkaProtocol.receive_bytes() via _validate_frame_size() and exposes a configurable receive_message_max_bytes ceiling (default 1 MB at the connection layer). The fix commit is https://github.com/dpkp/kafka-python/commit/6e4831444f972d169cdd11f5c8d50333cea3f19b. If immediate upgrade is not possible, compensating controls are limited because the parser code path is reached on every inbound frame: enforce TLS with broker certificate verification on all client connections to remove the man-in-the-middle vector (trade-off: requires PKI setup and slight CPU overhead), restrict clients to connect only to brokers in trusted network segments via egress firewalling (trade-off: breaks multi-region/SaaS Kafka topologies), and add process-level memory limits (cgroups, ulimit -v, Kubernetes resource limits) so that a runaway allocation kills and restarts the consumer rather than starving the host (trade-off: still causes a DoS, just a contained one). Once on 2.3.2, consider lowering receive_message_max_bytes below the 1 MB default if your workload's legitimate message sizes are smaller.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
kafka-python is the pure-Python client library for Apache Kafka maintained by Dana Powers (dpkp/kafka-python). The root cause is CWE-789 (Memory Allocation with Excessive Size Value): KafkaProtocol.receive_bytes() in kafka/protocol/parser.py reads the first 4 bytes of each wire frame as a big-endian length prefix and then attempts to buffer that many bytes without validating the value against any ceiling. A hostile peer can therefore declare any value up to 2^31 bytes (~2 GB), triggering either a runaway allocation or, when the negative/oversized path is hit, a bare ValueError that the connection state machine does not recover from - leaving in-flight requests dangling and consumer group heartbeats blocked. The fix introduces an InvalidReceiveError class and a _validate_frame_size() helper gated by a new receive_message_max_bytes configuration knob (default 1 MB at the connection layer, 100 MB at the parser).
Know when Python 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Triggered by a single unauthenticated network frame from a broker-positioned attacker; pure availability impact (OOM or hung connection), no confidentiality or integrity loss, no scope change.
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
3DescriptionCVE.org
kafka-python prior to 2.3.2 contains a denial-of-service vulnerability in the protocol parser that allows a malicious broker or machine-in-the-middle attacker to exhaust memory or hang connections by sending a crafted 4-byte frame length value without bounds validation. Attackers can send a specially crafted frame length through the receive_bytes() function to trigger either a multi-gigabyte memory allocation or an uncaught ValueError that leaves the connection in a broken state, causing requests to hang and consumers to stop heartbeating until restart.
Blast Radius
ecosystem impact- 2 pypi packages depend on kafka-python (2 direct, 0 indirect)
Ecosystem-wide dependent count for version 2.3.2.
Articles & Coverage 2
Executive ViewAI
The kafka-python client library vulnerability (CVE-2026-10142, CVSS 8.7) enables denial-of-service attacks against organizations running Kafka-based data pipelines, allowing network-adjacent attackers to crash consumer applications through memory exhaustion. Organizations using kafka-python for event streaming, real-time analytics, or message consumption face potential service disruptions that could cascade to dependent systems and delay critical data processing. Upgrading to version 2.3.2 or later is required to eliminate this availability risk.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t
BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser
pgAdmin 4 contains critical remote code execution vulnerabilities in the Query Tool download and Cloud Deployment endpoi
The renderLocalView function in render/views.py in graphite-web in Graphite 0.9.5 through 0.9.10 uses the pickle Python
BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica
OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph
pyLoad download manager version prior to 0.5.0b3.dev77 exposes the Flask SECRET_KEY through an unauthenticated endpoint.
Langflow (a visual LLM pipeline builder) contains a critical unauthenticated code execution vulnerability (CVE-2026-3301
In Mercurial before 4.1.3, "hg serve --stdio" allows remote authenticated users to launch the Python debugger, and conse
Unauthenticated remote code execution affects Kestra OSS (the open-source event-driven orchestration platform) prior to
Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/
pyLoad is the free and open-source Download Manager written in pure Python. Rated medium severity (CVSS 5.3), this vulne
Same technique Information Disclosure
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-36123
GHSA-m3px-q5gj-j9x7
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB