May 8, 2026·6 min read·48 visits
Unauthenticated attackers can permanently halt block discovery in Zebra nodes prior to v4.4.0 by saturating the P2P gossip queue and providing unpenalized empty responses to synchronization requests.
CVE-2026-44499 is a composite Denial of Service (DoS) vulnerability affecting Zebra, the Rust implementation of a Zcash full node. By exploiting architectural flaws in the peer-to-peer (P2P) communication stack, an unauthenticated attacker can saturate internal message queues and poison the chain discovery process, permanently isolating the target node from the network.
CVE-2026-44499 is a composite Denial of Service (DoS) vulnerability affecting the block discovery pipeline of Zebra, a Zcash full node implementation written in Rust. The flaw exists in versions prior to 4.4.0. It leverages three distinct architectural weaknesses in the peer-to-peer (P2P) stack to isolate a target node from the legitimate Zcash network.
The vulnerability allows an unauthenticated remote attacker to completely and permanently halt a node's ability to discover or download new blocks. This results in a high availability impact, as block synchronization is the primary function of a blockchain full node. The issue requires no user interaction and can be triggered via a single persistent TCP connection.
The core of the vulnerability lies in the improper handling of network resource exhaustion and the lack of a robust penalization mechanism for unhelpful network peers. This maps to CWE-770 (Allocation of Resources Without Limits or Throttling) and CWE-400 (Uncontrolled Resource Consumption).
The vulnerability emerges from the convergence of three primary vectors: gossip queue saturation, syncer poisoning, and permanent connection persistence. Zebra's gossip subsystem processes inv (inventory) announcements for new blocks. Prior to version 4.4.0, this subsystem lacked per-connection rate limiting for incoming messages.
An attacker exploiting the lack of rate limits could flood the node with thousands of fabricated block hashes in under a millisecond. This flood immediately pushes the internal gossip download queue to its maximum capacity. Zebra silently ignored the FullQueue error returned by the underlying buffer, discarding legitimate block announcements from honest peers without any recovery mechanism or peer penalization.
Concurrently, the Zebra Syncer component proactively discovers the blockchain via FindBlocks and FindHeaders requests. The Syncer treated empty responses from peers as valid protocol-level events. An attacker responding to these queries with empty inventory lists or NotFound statuses successfully occupied a sync slot indefinitely.
Because the attacker technically adhered to the wire protocol specifications by returning valid but empty responses, Zebra never terminated the connection. The absence of a misbehavior scoring system for these specific interactions ensured the attacker remained permanently connected. This created a perpetual block deficit that the node could not self-heal.
The remediation logic introduced in Zebra 4.4.0 highlights the missing state tracking in earlier versions. The patch implements a FindResponseStallTracker within the PeerSet component. This tracker explicitly classifies connection quality based on response utility rather than mere protocol compliance.
// Patched logic introduced in zebra-network/src/peer_set/set.rs
fn classify_find_response<E>(result: &Result<Response, E>) -> Option<StallOutcome> {
match result {
Ok(Response::BlockHashes(hashes)) if hashes.is_empty() => Some(StallOutcome::Stall),
Ok(Response::BlockHeaders(headers)) if headers.is_empty() => Some(StallOutcome::Stall),
Err(_) => Some(StallOutcome::Stall),
_ => Some(StallOutcome::Clear),
}
}The function above demonstrates the shift in handling P2P responses. Empty BlockHashes or BlockHeaders responses are now explicitly mapped to a StallOutcome::Stall state. If a peer accumulates three consecutive stalls, the connection is forcefully terminated, preventing the syncer poisoning vector.
In addition to the logic flaw, CVE-2026-44499 was compounded by memory allocation vulnerabilities documented under GHSA-438q-jx8f-cccv. The Equihash solution field and variable-length coinbase scripts relied on CompactSize prefixes provided by network peers. The node allocated memory based on this untrusted prefix before validating the underlying data size against consensus limits.
The deserializer was subsequently hardened. Functions like read_headers now enforce a strict 160-entry protocol limit before parsing. Memory allocation for Equihash solutions and coinbase data is now deferred until the declared size is validated against strict consensus bounds.
Exploitation of CVE-2026-44499 requires a single malicious peer connecting to the target Zebra node over the standard Zcash P2P port. The attack requires no authentication or specific network positioning beyond the ability to establish a TCP connection with the target.
The sequence begins with the attacker initiating a flood of inv announcements to saturate the target's gossip queue. The attacker immediately responds to all subsequent FindBlocks and FindHeaders queries from the target with empty lists.
This behavior satisfies the protocol handshake without delivering any useful blockchain state. The attacker maintains the open TCP connection, continuously serving empty payloads whenever polled. The target node enters a permanently stalled state, incapable of receiving new block information from the attacker or the wider network.
The successful exploitation of this vulnerability results in a total denial of service for the block discovery mechanism. The affected Zebra node becomes permanently isolated from the Zcash network state. It will not append new blocks to its local ledger, meaning any downstream services relying on the node for transaction verification or balance queries will receive stale data.
The CVSS v4.0 score of 8.7 reflects the high availability impact (VA:H). Because block synchronization is the fundamental operational requirement of a full node, halting this process functionally disables the node's primary utility.
The concurrent allocation amplification vectors also pose a significant risk of Out-Of-Memory (OOM) crashes. By supplying manipulated CompactSize prefixes in block headers or coinbase data, an attacker forces the node to attempt multi-gigabyte memory allocations. This combination of logical stalling and resource exhaustion creates a highly effective denial-of-service condition.
The Zcash Foundation addressed these vulnerabilities comprehensively in Zebra version 4.4.0. Upgrading to this version is the only permanent mitigation. The patch introduces fundamental changes to the network protocol handler and deserialization logic.
The most critical architectural change is the implementation of the FindResponseStallTracker. Connections are actively monitored for response quality. Peers that provide three consecutive empty or failed responses to synchronization queries are systematically disconnected. This prevents malicious peers from acting as persistent black holes.
Network resource management was also hardened. The implementation introduces MAX_INBOUND_CONCURRENCY_PER_IP, enforcing a strict limit of one concurrent block download task per IP address. Additional queries from the same source IP are rejected with a TooManyFromPeer status until the initial request completes. Deserialization functions now enforce maximum size limits on arrays and scripts prior to any memory allocation.
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| Product | Affected Versions | Fixed Version |
|---|---|---|
Zebra Zcash Foundation | < 4.4.0 | 4.4.0 |
| Attribute | Detail |
|---|---|
| CVSS Score | 8.7 |
| CWE ID | CWE-770 |
| Attack Vector | Network |
| Exploit Status | None |
| KEV Status | Not Listed |
| Authentication | None Required |
Allocation of Resources Without Limits or Throttling
SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.
A Regular Expression Denial of Service (ReDoS) vulnerability exists in SpamScope mail-parser versions 4.2.0 prior to 4.6.1. Two separate regular expressions evaluated during standard email header parsing exhibit quadratic to cubic backtracking complexity when processing headers padded with whitespace or angle brackets. An unauthenticated remote attacker can exploit this flaw by sending a small, RFC-compliant email message, causing parsing worker threads or processes to stall at 100% CPU utilization for extended periods.
CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.
CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.
CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.
Kubeshark versions 53.1.0 prior to 53.4.0 contain an arbitrary file write and path traversal vulnerability (CWE-22) alongside an argument injection vulnerability (CWE-88) in the Model Context Protocol (MCP) server implementation (cmd/mcpRunner.go). The download_file tool fails to validate caller-supplied path and dest arguments, allowing an attacker who influences an AI agent driving kubeshark mcp to write Kubeshark Hub API responses to arbitrary locations writable by the local user. Additionally, the start_kubeshark tool appends the pod_regex argument without flag delimiters, allowing argument injection into the kubeshark tap subcommand.