/

CVE-2026-34202

Severity:

HIGH RISK

(7.5)

Denial of Service via Logic Error in Zebra Zcash Node

CVE-2026-34202

Analyzed

Vulnerability type

Category:

Denial of Service via Logic Error

CWE:

CWE-94, CWE-1336, CWE-502

Impact:

Denial of Service (Node Crash)

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A flaw in Zebra's transaction processing logic allows a specially crafted V5 transaction to cause a node panic after it passes initial deserialization but fails during transaction ID calculation.

A remote, unauthenticated peer on the Zcash network can exploit this condition to repeatedly crash affected Zebra nodes, leading to denial of service.

Affected context

This vulnerability arises in Zebra nodes participating in the Zcash network that accept and process V5 transactions.

It manifests during transaction handling after the transaction has been deserialized but before all internal validation and ID computation steps complete.

Nodes configured to accept peer connections from the public network, without additional filtering or rate limiting, are most exposed because they will parse transactions from untrusted, potentially malicious peers.

Exploit preconditions

  • Attack surface: Network-exposed Zebra node that processes V5 transactions.
  • Required access: Network-level access as a peer; no authentication or prior trust relationship is required.
  • Trigger point: Submission or relay of a specially crafted V5 transaction that:
  • Is structurally valid enough to pass deserialization, but
  • Contains internal inconsistencies that cause an error during transaction ID calculation.
  • Why exploitation is possible: The transaction processing logic does not fully treat certain invariant violations as recoverable errors; instead, it allows an internal failure to propagate into a panic, terminating the node process.

Why this happens

The underlying issue is a logic and error-handling flaw in the transaction processing pipeline, corresponding most closely to CWE-1336: Improper Neutralization of Special Elements Used in a Control Flow Decision ('Logic Error').

The code path that computes transaction IDs for V5 transactions assumes that any transaction that passes the initial deserialization phase is structurally well-formed for subsequent processing.

When a maliciously crafted transaction violates these assumptions, the code encounters a state it does not gracefully handle and triggers a panic instead of treating the condition as a regular validation error.

Conceptually, this reflects a broader pattern where untrusted protocol inputs progress too far into internal logic without robust invariants and error recovery, allowing attacker-controlled data to influence control flow and stability of the node.

Potential impact

  • Remote crash of the affected Zebra node, causing denial of service.
  • Repeated crashes that can keep a node offline or unstable, impacting availability of services relying on that node.
  • Potential degradation of network resilience if many nodes are similarly affected and targeted.
  • Operational disruption for wallets, services, or infrastructure that depend on continuous node connectivity and consensus participation.

General mitigation guidance

Mitigation centers on making transaction processing paths robust against malformed inputs and ensuring that no untrusted data can cause a panic:

  • Treat all peer-supplied transactions as untrusted and enforce strict, layered validation at each processing stage (deserialization, structural checks, invariant checks, and ID calculation).
  • Replace assumptions in transaction ID calculation and related logic with explicit checks; handle unexpected conditions as recoverable validation failures rather than panics.
  • Encapsulate protocol parsing and validation in components that return explicit error types, allowing the node to reject invalid transactions while remaining stable.
  • Use defensive programming practices such as bounds checks, invariant assertions that log rather than panic, and clear separation between "invalid but expected" input and truly unrecoverable internal errors.
  • Apply network hardening and rate-limiting where possible so that a single peer cannot flood a node with problematic transactions.

How teams detect issues like this

Detection and prevention can leverage a combination of code-centric and operational approaches:

  • Static analysis and code review:
  • Search for panic, unwrap, expect, or similar constructs inside network-facing or transaction-processing code paths, and verify they cannot be influenced by untrusted protocol data.
  • Review transaction parsing and ID computation logic to ensure every fallible operation returns errors instead of terminating the process.
  • Enforce internal coding guidelines that prohibit panics in consensus or network-handling paths, except for clearly justified, non-input-dependent cases.
  • Dynamic and fuzz testing:
  • Use structured fuzzers against transaction deserialization and ID calculation routines to discover malformed inputs that cause crashes or panics.
  • Integrate these fuzzers into CI pipelines to catch regressions where new logic introduces crash conditions.
  • Runtime monitoring:
  • Monitor Zebra node logs and uptime metrics for recurring panics or unexpected restarts correlated with incoming transaction traffic.
  • Use automated tooling to trigger alerts when nodes terminate due to panic, prompting investigation of malformed inputs or attack activity.

Sources

SourceLink
github.comgithub.com/ZcashFoundation/zebra/releases/tag/v4.3.0
github.comgithub.com/ZcashFoundation/zebra/security/advisories/GHSA-qp6f-w4r3-h8wg
zfnd.orgzfnd.org/zebra-4-3-0-critical-security-fixes-zip-235-support-and-performance-improvements

Frequently asked

questions

Exploitation is straightforward for an attacker who can connect as a peer: they only need to send a specifically malformed V5 transaction that passes initial parsing but breaks assumptions during ID calculation, which can be repeated to keep a node unstable.

No. The vulnerability can be triggered by any remote, unauthenticated peer that can relay or submit transactions to the targeted Zebra node over the Zcash network.

The most robust fix pattern is to ensure that all fallible operations in transaction processing treat unexpected conditions as explicit errors, never as reasons to panic.

Transaction ID computation and similar routines should validate all preconditions and reject malformed or inconsistent transactions without affecting node stability.

Preventive measures include adopting a "no panics on untrusted input" policy, subjecting protocol handlers to fuzz testing, performing focused reviews on consensus-critical and network-facing code, and using static analysis to flag risky constructs (such as unchecked unwraps) in input-handling paths.

Find out what's already
exploitable in your codebase.