CVE-2026-104437

Executive Summary

CVE-2026-104437 is a consensus divergence vulnerability in the Zebra Zcash node implementation prior to version 4.4.0. The flaw resides in V5 transparent signature verification, where the node computes a ZIP-244 digest for SIGHASH_SINGLE inputs that lack corresponding outputs instead of rejecting the transaction as invalid. An attacker can craft V5 transactions with more inputs than outputs that Zebra accepts and propagates through getblocktemplate, resulting in blocks that standard zcashd nodes reject — causing a network fork. With a CVSS score of 7.4 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:H), the vulnerability poses a high integrity risk to the Zcash consensus layer.

Technical Analysis

Zebra is an independent, Rust-based implementation of a Zcash node. Zcash V5 transactions (introduced in the NU5 upgrade) use the ZIP-244 transaction digest algorithm for signature hashing. The SIGHASH_SINGLE signature hash type, inherited from Bitcoin's semantics, commits the signature to a specific input and its corresponding output at the same index. If no output exists at that index, the signature digest should be computed in a manner that guarantees the transaction is invalid (in Bitcoin, this results in a "1" hash digest that makes the signature unspendable).

The vulnerability, tracked as CWE-347 (Improper Verification of Cryptographic Signature), arises because Zebra before 4.4.0 computes a ZIP-244 digest for SIGHASH_SINGLE inputs lacking a corresponding output rather than failing outright. This means Zebra does not enforce the rule that a SIGHASH_SINGLE input must reference a valid output index — specifically, an input index that is less than the total number of outputs. Consequently, a V5 transaction can be constructed with a number of inputs strictly greater than the number of outputs, where the excess inputs use SIGHASH_SINGLE, and Zebra will still accept the transaction as valid.

When such a transaction is accepted, Zebra's getblocktemplate RPC will include it in a block template. Miners running Zebra will then mine a block containing this transaction. However, zcashd — the reference implementation — correctly rejects the same transaction because it fails the signature verification. This divergence means that a block accepted by Zebra will be rejected by zcashd, splitting the network and potentially enabling double-spend or chain reorganization attacks. The vulnerability requires a moderately complex attack (AC:H) due to the need to craft a validly signed transaction that exploits the edge case, but no privileges or user interaction are required (PR:N, UI:N). The attack vector is network-based (AV:N).

No public proof-of-concept or exploit code is available. The technical details are derived from the NVD description provided.

Exploitation Scenarios

No public PoC available; attack chain is inferred from vulnerability class.

1) Reconnaissance/target identification: An attacker identifies Zebra nodes on the Zcash peer-to-peer network. This can be done passively by monitoring the network or actively by querying nodes for their version. Shodan dorks such as product:"Zebra" or port:8233 (Zcash mainnet P2P) can reveal internet-exposed nodes. The attacker does not need any special privileges.

2) Triggering the specific flaw class: The attacker constructs a V5 transaction with more inputs than outputs. At least one input uses the SIGHASH_SINGLE signature hash type. Because Zebra before 4.4.0 computes a ZIP-244 digest for such inputs without a corresponding output — instead of treating them as invalid — the transaction is accepted by vulnerable Zebra nodes. The attacker signs the transaction accordingly, exploiting the improper verification of the signature digest. This is a transaction-level validation bypass, not a remote code execution or injection flaw.

3) Payload/execution method: The attacker broadcasts the crafted V5 transaction to the Zcash network. Vulnerable Zebra nodes accept it and include it in their mempools. When a miner running Zebra calls getblocktemplate, the transaction is incorporated into a block template. If that miner mines a block containing the transaction, the block is propagated. Standard zcashd nodes will reject the block because they correctly invalidate the transaction, creating a consensus divergence.

4) Post-exploitation impact: The primary impact is a network fork or chain split. The attacker may leverage this to perform double-spends on the Zebra-accepted chain or to disrupt the Zcash network's integrity. Integrity impact is High (I:H) because consensus rules are violated. Availability impact is High (A:H) because the divergence can halt block acceptance on one side of the split. Confidentiality impact is None (C:N). No code execution or data exfiltration is possible through this vulnerability alone.

Impact Assessment

The vulnerability affects all Zebra nodes prior to version 4.4.0, particularly miners and mining pools that rely on Zebra's getblocktemplate to produce blocks. The blast radius includes the entire Zcash network if a sufficient number of miners run vulnerable Zebra nodes. A single malicious transaction can cause a consensus split, leading to:

• Integrity (I:H): Acceptance of transactions that violate consensus rules, enabling double-spending or other ledger inconsistencies.
• Availability (A:H): Network partition can halt transaction confirmation on one or both chains, disrupting services.
• Confidentiality (C:N): No direct data exposure. The CVSS vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:H) indicates a network-reachable attack with high complexity, requiring no authentication. The scope is unchanged (S:U), meaning the impact is confined to the vulnerable component's security authority. Business impact includes financial loss from double-spends, reputational damage for mining operations, and operational disruption for exchanges and payment processors relying on Zcash.

Detection Guidance

Sigma Rule

title: Zebra V5 SIGHASH_SINGLE Consensus Divergence Attempt
id: 8f5c9e2a-1b3d-4e7f-9a2c-6d8e0f1a2b3c
status: experimental
description: Detects transactions with more inputs than outputs and SIGHASH_SINGLE flags in Zebra logs or mempool events
author: Threat Intelligence
date: 2026-01-01
logsource:
    product: zebra
    service: node
detection:
    selection:
        event:
            - "mempool_accept"
            - "block_template"
        transaction_version: 5
        input_count|gt: output_count
        sighash_type: "SIGHASH_SINGLE"
    condition: selection
falsepositives:
    - Unlikely, as valid transactions should not have more inputs than outputs with SIGHASH_SINGLE
level: high

YARA Rule

rule CVE_2026_104437_Zebra_V5_SIGHASH_SINGLE
{
    meta:
        description = "Detects V5 transactions exploiting Zebra SIGHASH_SINGLE consensus divergence"
        author = "Threat Intelligence"
        date = "2026-01-01"
        cve = "CVE-2026-104437"
        severity = "high"
    strings:
        $v5_marker = { 05 00 00 80 } // V5 transaction version marker (little-endian)
        $sighash_single = { 03 } // SIGHASH_SINGLE flag byte
    condition:
        $v5_marker at 0 and #sighash_single > 0
}

Suricata IDS Rule

alert tcp any any -> any 8233 (msg:"CVE-2026-104437 Zebra V5 SIGHASH_SINGLE Consensus Divergence Attempt"; flow:to_server,established; content:"|05 00 00 80|"; depth:4; content:"|03|"; within:1000; classtype:attempted-dos; sid:1000001; rev:1;)

Elastic Detection

sequence by process.entity_id
  [process where event.type == "start" and process.name == "zebra"]
  [network where event.type == "connection" and destination.port == 8233 and network.transport == "tcp"]

Splunk SPL Query

index=zebra_logs sourcetype=zebra:node
| search "mempool_accept" OR "getblocktemplate"
| rex field=_raw "txid=(?<txid>\w+)"
| rex field=_raw "inputs=(?<inputs>\d+) outputs=(?<outputs>\d+)"
| where inputs > outputs
| table _time, host, txid, inputs, outputs
| sort - _time

Wazuh OSSEC Rule

<group name="zebra,">
  <rule id="100001" level="12">
    <decoded_as>json</decoded_as>
    <field name="event">mempool_accept|getblocktemplate</field>
    <field name="transaction_version">5</field>
    <field name="input_count">\.+</field>
    <field name="output_count">\.+</field>
    <description>CVE-2026-104437: Zebra V5 SIGHASH_SINGLE consensus divergence attempt detected</description>
    <options>alert_by_email</options>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source).

1. Immediate mitigations:

   • Upgrade Zebra to version 4.4.0 or later as soon as a release is available. Until then, consider using zcashd for mining and block template generation.
   • Monitor mempool and block templates for transactions with more inputs than outputs using the detection rules above.
   • If running a mining pool, validate all transactions against zcashd consensus rules before including them in blocks.
   • Restrict getblocktemplate RPC access to trusted miners only (via firewall or authentication).
   • Disable getblocktemplate if not strictly necessary.

2. Patch/upgrade steps:

   • No official patch is currently available. Track the Zebra project's repository for version 4.4.0 or a security advisory.
   • Once a patched version is released, upgrade all Zebra nodes immediately. Verify the fix by testing a crafted V5 transaction with SIGHASH_SINGLE and more inputs than outputs; ensure it is rejected.
   • After upgrading, restart nodes and confirm they are synced with the network.

3. Long-term hardening:

   • Implement strict validation of SIGHASH_SINGLE inputs to ensure the input index is within the range of outputs. This should be part of the transaction verification logic.
   • Conduct regular differential fuzzing between Zebra and zcashd to identify consensus divergences early.
   • Adopt a defense-in-depth approach: miners should run multiple node implementations or use a consensus-checking proxy.
   • Participate in the Zcash security community and apply security patches promptly.

References

1. NVD – CVE-2026-104437: https://nvd.nist.gov/vuln/detail/CVE-2026-104437
2. Zebra Project Repository: https://github.com/ZcashFoundation/zebra
3. Zcash ZIP-244 Specification: https://zips.z.cash/zip-0244
4. Zcash Consensus Rules: https://zips.z.cash/protocol/protocol.pdf
5. CISA KEV Catalog (not listed as of report date): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

No known threat actor campaigns or exploit-in-the-wild evidence have been observed for this CVE.