github ZcashFoundation/zebra v7.1.0
Zebra 7.1.0

one hour ago

Zebra 7.1.0 is a security release. It fixes ten security advisories, most of them ways a single peer could stop a node's initial sync or make it restart its sync rounds, and ways to run a node out of memory. Chain forks now share their indexes instead of copying them, and those indexes have a memory limit. There are no consensus changes, and 7.1.0 keeps 7.0.0's state format, so upgrading needs no migration or resync. 7.1.0 is supported until around 10 December 2026, so plan to upgrade to the next release before then.

Upgrade every node. Most of these issues can be triggered by any peer, one by any client of a public RPC or lightwalletd service, and one by anyone who can get blocks dense in transparent outputs mined.

Update Priority

User Type Priority Reason
All node operators High A single peer could stop initial sync or make a node restart its sync rounds, and blocks dense in transparent outputs could run it out of memory
Operators of public RPC, lightwalletd, or wallet services High Concurrent address balance requests could run the node out of memory
Mining pools and miners High A stalled or crashed node stops serving block templates
Users of the Zebra library crates Upgrade with the node New major versions with breaking API changes; see Library crates

Highlights

Security fixes

Initial sync and sync rounds:

  • High: a peer could halt initial sync with forged blocks at the switch from checkpoint sync to full validation (GHSA-m44m-9r8r-r64j).
  • High: a peer could stop initial sync by serving blocks whose transactions don't match their header, such as a rewritten coinbase height (GHSA-g9rc-89v4-hhvf, and the related Moderate GHSA-hvw5-x88g-2q8w).
  • High: a peer's sync discovery reply that included blocks Zebra already had made it restart the whole sync round (GHSA-vw2c-5w35-x5q6).
  • High: blocks waiting for checkpoint verification or for their parent block were kept without a memory limit (GHSA-8qxv-5f2c-452c).
  • Moderate: a peer that sent a forged block body first could get the honest peer that followed it banned (GHSA-7jvw-68q7-xfh4).

Memory:

  • High: blocks dense in transparent outputs made every chain fork copy the recent indexes, so a node could run out of memory and be killed again on every restart (GHSA-j8gf-c4rj-6jv5).
  • High: concurrent transparent address balance requests, through getaddressbalance or lightwalletd, could run the node out of memory (GHSA-hj54-2mfv-4xg8).

Mempool verification:

  • Moderate: the mempool verified the scripts of transactions with more than 4,000 signature operations before rejecting them as non-standard (GHSA-423j-2vj4-j5x4).
  • Moderate: transactions that failed the anchor or nullifier checks still added work to the proof batches shared with block verification (GHSA-2wx4-g5cf-32pf).

None of the ten advisories is a consensus fault or puts funds at risk. The Security section below credits the reporters.

What changes for operators

  • Configs that no longer load. The elasticsearch feature is removed: delete any elasticsearch_url, elasticsearch_username, or elasticsearch_password field from [state]. On a custom Testnet or Regtest, zebrad also stops at config load if you set an activation height for a network upgrade that has no consensus branch ID in this build.
  • A shorter support window. 7.1.0 is supported for 24 days instead of 8 weeks. It warns from about 3 December 2026 (block 3,638,752) and stops around 10 December 2026, near block 3,662,944. Upgrade to the next release before then.
  • A memory limit on recent blocks, with a shorter reorganization window when it applies. Zebra keeps up to 1,000 recent blocks in memory, so it can follow a chain reorganization that deep. Their indexes now have a limit of 6,200,000 entries on Mainnet and 2,000,000 on Testnet and Regtest. Ordinary Mainnet blocks don't reach it. If a run of unusually dense blocks does, Zebra first drops the lowest-work forks, and if the chains are still too large, it finalizes the best chain's oldest blocks early, but always keeps at least 100, which is deeper than zcashd reorganizes. Until the dense blocks are finalized, the node can't follow a reorganization deeper than the blocks it kept. The worst-case non-finalized state is about 5 to 7 GB, so we recommend 16 GB of RAM, as in Zebra's system requirements. Watch the new state.memory.index.entries and state.memory.fork.evicted.count metrics. During initial sync, blocks waiting for checkpoint verification can also use up to about 4 GB.
  • Health endpoint limits. If you enable the health endpoint ([health] listen_addr), it now serves one request per connection, closes a connection that doesn't send its request headers within 5 seconds, and drops new connections while 32 are open. Standard probes from Kubernetes, Docker, or load balancers open a connection per check and work unchanged.
  • RPC authentication errors. Requests without valid cookie credentials now get an HTTP 401 response with a JSON-RPC error body instead of an empty reply.
  • Sync logs and alerts. A sync round that ends with an error without advancing the tip now logs at WARN instead of INFO, and the INFO lines temporary error obtaining tips and temporary error extending tips are gone: update alerts that match them. Sync restarts log their reason, and the new sync.restart.count, sync.block.error.count, and sync.downloads.oldest_age_seconds metrics show why a node is stalling.
  • Metric labels. mempool.failed.verify.tasks.total, zebra.net.in.errors, and handshake protocol-version labels now use a fixed set of values. Update dashboards or alerts that match full error messages or unknown protocol versions. The reason label of mempool.failed.verify.tasks.total also gains a non_standard value, for transactions rejected for non-standard outputs before verification.
  • Sentry. If you set SENTRY_DSN, error events now carry stack traces and Sentry groups them by trace, so existing issues may reappear as new ones.
  • Peer recovery. A node with no outbound peers and no addresses to try now resolves its DNS seeders and retries its configured and cached peers, at most every 5 minutes, instead of waiting for a restart. If DNS fails at startup, Zebra starts with its cached peers.

Breaking Changes

  • Remove the experimental elasticsearch feature, which exported finalized blocks to Elasticsearch and slowed down syncing. A config that still has elasticsearch_url, elasticsearch_username, or elasticsearch_password in the [state] section now fails to load: delete those fields.

Added

  • Added stack traces to Sentry error events, with Zebra's frames marked in-app, so Sentry can show suspect commits. Sentry now groups logged errors by stack trace, so existing issues may reappear as new ones (#11855).
  • Added the zcash.chain.tip.block_delay_seconds histogram, which measures how long after its header time each new tip block is accepted, and sent it to Sentry as a distribution, with the block's height, when SENTRY_DSN is set. Metrics sent to Sentry also carry the network upgrade at the tip and the process uptime.
  • Added sync stall diagnosis. Sync restarts now log why they happened, block download and verify errors include a kind, and the "chain updates have stalled" warning includes the latest restart reason and the age of the oldest in-flight block. The new sync.restart.count, sync.block.error.count, and sync.downloads.oldest_age_seconds metrics are exported to Prometheus, and sent to Sentry once a minute when Sentry is enabled.
  • Added the verified block counts, the mempool size, and the database disk size to the metrics sent to Sentry once a minute when SENTRY_DSN is set, to help compare nodes.
  • Added memory metrics: the process's memory use and its share of available memory, the size of the non-finalized state, forks evicted, and the non-finalized backup restore. Official release builds send them to Sentry once a minute when SENTRY_DSN is set.

Changed

  • Disabled Nagle's algorithm (TCP_NODELAY) on peer connections, like zcashd does. This removes delays of 40ms or more when Zebra sends several small messages in a row, for example when it relays mempool transactions to zcashd peers.
  • RPC requests without valid cookie credentials now get an HTTP 401 response with a JSON-RPC error body instead of an empty reply (#9190).
  • Block queue and commit spans no longer include whole verified-block payloads; compact height and hash context remains.
  • Routine state-service spans now use DEBUG, and per-input, per-transaction, and chain-tip getter spans use TRACE. INFO events and their fields are unchanged.
  • A node with no outbound peers and no peer addresses to try now resolves its DNS seeders, reloads its configured and cached peers, and retries peers that failed, at most once every 5 minutes, instead of staying without peers until it is restarted. It logs a warning each time (#11807).
  • Zebra now starts with its cached peers when DNS resolution of the initial peers fails, instead of waiting for DNS to succeed (#11807).
  • The mempool no longer scores V4 transactions that fail transparent script verification within the branch ID grace period around a network upgrade activation, because they may have been signed for the adjacent upgrade. Outside that window, script failures keep their misbehavior score.
  • Bound metric labels: mempool.failed.verify.tasks.total uses error kinds for reason (retaining timeout), zebra.net.in.errors uses error kinds for error, and handshake protocol-version labels use known versions or other. Update custom selectors that match full error messages or unknown protocol versions.
  • Stop sending requests to a peer that was banned, or made obsolete by a network upgrade, after Zebra selected it, including while waiting for its connection to become writable.
  • With ephemeral = true, zebrad no longer leaves empty directories in the temporary directory each time it starts.
  • Read-write nodes now report incomplete stored block bodies through block RPC and peer requests instead of serving empty or partial blocks.
  • Updated the pulldown-cmark build dependency to 0.13.6, clearing RUSTSEC-2026-0414 and RUSTSEC-2026-0433. Zebra isn't affected; it only runs the crate at build time, on the doc comments of its own protobuf files.
  • zebrad now stops at config load when a configured network upgrade height has no consensus branch ID in this build, instead of panicking at that upgrade's activation block. This only affects custom Testnet and Regtest configs (#11482).
  • Updated the libz-sys build dependency to 1.1.31, clearing RUSTSEC-2026-0418. Zebra isn't affected: the leak needs cc 1.6.0 or later, and Zebra's lockfile uses cc 1.2.61.
  • Changed the log for a sync round that ends with an error without advancing the chain tip from INFO to WARN, so it reaches Sentry Logs and WARN-level alerts. The separate INFO temporary error obtaining tips and temporary error extending tips lines are gone, because the warning includes their error.
  • Zebra no longer gossips peer addresses as full nodes (NODE_NETWORK) when it never learned their services, and gossips an inbound peer's listener address with the services that peer advertised.
  • Unsolicited transactions from peers no longer interrupt block and transaction downloads, and Zebra only treats a peer as missing a block or transaction when the peer says so. A request for an exact transaction also matches its authorizing data, so a peer that serves a differently signed copy is treated as not having it.
  • Checkpoint sync commits blocks with transparent outputs faster.
  • Reduce CPU work when updating mempool rejection metrics.
  • Reduce build dependencies without changing node behavior.
  • This release is supported for 24 days instead of 8 weeks, so it stops around 10 December 2026, near block 3,662,944, and warns from about 3 December (block 3,638,752). Upgrade to the next release before then.

Fixed

  • Misbehavior score increments are no longer lost while earlier scores are being applied under load (#10601).
  • Failed client connections to the tracing filter endpoint (built with the filter-reload feature) are now logged as warnings instead of errors, so they no longer create Sentry issues when Sentry is enabled.
  • Fixed the startup panic when the state database cannot be opened: it now shows the underlying error, and only blames another running zebrad process when the database lock is actually held. Other I/O errors, such as an unmounted, unwritable, or full cache directory, get their own message.
  • Fixed zebrad tip-height and zebrad copy-state leaving a zebra-secondary_state-* directory in the system temporary directory each time they ran. These directories are now removed on exit. Existing ones can be deleted safely when no zebrad command is running.
  • Improved how the non-finalized state tracks blocks from chain forks it no longer keeps.

Security

  • Keep a sync round going when a peer's reply to a sync discovery request includes blocks Zebra already has, and skip downloading those blocks (GHSA-vw2c-5w35-x5q6). Thanks to @AnticsDecoded for reporting the issue.
  • Check mempool transactions for unknown anchors and spent nullifiers before verifying their proofs, so transactions rejected by those checks no longer add work to the proof batches shared with block verification (GHSA-2wx4-g5cf-32pf). Thanks to @Nathanbyarugaba and @SphereDonout for reporting these issues.
  • Stopped transparent address balance requests, including getaddressbalance RPCs and lightwalletd GetTaddressBalance calls, from copying the whole non-finalized chain. A recent block with many transparent outputs made each copy large, so concurrent balance requests could run the node out of memory (GHSA-hj54-2mfv-4xg8). Thanks to @saxenism for reporting the issue.
  • Stopped getaddressutxos and getaddresstxids requests from copying every recent UTXO and transaction of the requested addresses on each request (GHSA-hj54-2mfv-4xg8).
  • Update ctutils to 0.4.5 to fix RUSTSEC-2026-0385, non-constant-time mask generation and u128 comparisons. Zebra holds no keys and uses the affected hashing and signature code on public data.
  • Update tokio to 1.54.1 to fix RUSTSEC-2026-0386, safe AsyncFd constructors that violate I/O safety. Zebra doesn't use AsyncFd.
  • The health endpoint serves one request per connection, closes connections that don't send their request headers within 5 seconds, and keeps at most 32 connections open, so slow or idle clients can't use up its connections.
  • Limit the memory a peer's block request can use: Zebra keeps at most 16 distinct block hashes from it before handling the request.
  • Prevent forged queued blocks from causing honest replacement peers to be penalized (GHSA-7jvw-68q7-xfh4). Thanks to @x15-eth for reporting the issue.
  • Release completed block downloads between sync rounds, and retry missing ancestors a limited number of times, including in rounds with no new tips or only one advertised hash.
  • Bound block downloads by the remaining sync lookahead capacity, reserving space for retries and the final checkpoint. Block hashes from different peers are interleaved, so one peer's response can't fill the download batch.
  • Keep unrelated block verification running when a peer serves an invalid block or a download fails, and retry blocks whose bodies fail validation. A sync round where the chain tip doesn't advance for 8 minutes now backs off without cancelling downloads. It counts under the sync_step_timeout reason of sync.restart.count and logs no chain progress before the sync deadline at INFO, not the WARN for a failed sync round. Tip progress during a pending request restarts the 8 minutes.
  • Time out stalled block-verifier readiness so downloaded blocks cannot remain pending indefinitely between sync rounds.
  • Ban peers that serve a requested block whose transactions don't match its header, such as a block with a rewritten coinbase height, and request the block again from another peer, so a peer can't stall initial sync by making Zebra drop a block it still needs (GHSA-g9rc-89v4-hhvf, GHSA-hvw5-x88g-2q8w). Thanks to @x15-eth and @SphereDonout for reporting these issues.
  • Reject mempool transactions with more than 4,000 signature operations before verifying their scripts. Previously, a peer could keep the verification thread pool busy with transactions that Zebra verified in full before rejecting them as non-standard (GHSA-423j-2vj4-j5x4). Thanks to @janneh2000 for reporting the issue.
  • Limit the memory of blocks waiting for checkpoint verification and of blocks waiting for their parent blocks, including blocks kept alive after their requests were cancelled or their commits failed. The syncer requests a block dropped from a full queue again without cancelling other downloads, and restarts the round if those downloads run out of retries. The sync.block.error.count metric counts these errors with the queue_full kind (GHSA-8qxv-5f2c-452c). Thanks to @Maakai123, @DanielDerefaka, and @SphereDonout for reporting the issue.
  • Fix an initial sync halt where a peer could send forged blocks during the switch from checkpoint sync to full validation, so later blocks were never committed. Zebra now rejects those blocks and bans the peer that sent them (GHSA-m44m-9r8r-r64j). Thanks to @unusualbyte for reporting the issue.
  • Limit the combined size of the non-finalized chain indexes to about 5–7 GB, so a long run of blocks filled with transparent outputs can't exhaust the node's memory. 16 GB of RAM is recommended. Past the limit, which ordinary Mainnet blocks don't reach, Zebra drops the lowest-work forks, and if the chains are still too large, it finalizes the best chain's oldest blocks early, keeping at least 100. While it does, Zebra can't follow a chain reorganization deeper than the blocks it kept. Test networks have a lower limit (GHSA-j8gf-c4rj-6jv5).
  • Fix a denial of service where blocks with many transparent outputs made every non-finalized fork, and every finalized block, copy the created-output and address indexes of the whole non-finalized window, so a node ran out of memory and was killed again on every restart. Chain forks now share each block's outputs and address changes instead of copying them (GHSA-j8gf-c4rj-6jv5). Thanks to Foundry Digital for reporting the issue.
  • Chain forks in the non-finalized state share their transaction, spend, and nullifier indexes instead of copying them, so blocks with many transactions or spends no longer multiply memory use by the number of forks (GHSA-j8gf-c4rj-6jv5).
  • Reject mempool transactions with non-standard outputs, such as dust or oversized OP_RETURN data, before verifying their scripts and proofs.

How to Upgrade

Upgrading from 7.0.0 needs no state migration or resync, because both use the v29 state. Fix your config first (see What changes for operators), or zebrad won't start. If you are upgrading from Zebra 6.x, also read the 7.0.0 release notes, because 7.0.0 migrates the state from v28 to v29.

7.0.0 can open a 7.1.0 state, so you can switch back without resyncing, but 7.0.0 is affected by every advisory above.

Docker

docker pull zfnd/zebra:7.1.0
# or update your compose file and:
docker compose pull && docker compose up -d

Binaries

  1. Download the zebrad archive for x86-64 or ARM64 Linux from the assets below, and check it against SHA256SUMS.
  2. Stop zebrad (systemctl stop zebrad or Ctrl+C) and wait for it to exit.
  3. Replace the binary and start zebrad again.

From source

git fetch --tags && git checkout v7.1.0
cargo build --release --locked -p zebrad

Source builds need Rust 1.91 or newer, protoc, a C++ compiler, and libclang.

Library crates

Every Zebra library crate gets a new version, and all but tower-batch-control and tower-fallback get a new major version. The breaking changes are in zebra-chain, zebra-consensus, zebra-state, zebra-test, zebra-node-services, and zebra-utils; the other crates get a major version because they expose those crates' types.

  • The non-finalized state shares its indexes between chains. This changes the value balance methods in zebra-chain, and removes Chain::partial_transparent_indexes, TransparentTransfers, and public access to Chain::tx_loc_by_hash in zebra-state.
  • Exhaustive matches need the new TransactionError::NonStandardSigops and CommitBlockError::OrphanQueueFull variants.
  • Finalized block reads return Result<Option<_>, BlockReadError>, which separates incomplete stored data from unknown blocks.
  • ParametersBuilder::with_activation_heights returns the new ParametersBuilderError::MissingBranchId.

zebra-chain types appear in the other crates' public APIs, so upgrade the crates together. Each crate's CHANGELOG.md lists its changes.

Crate Version Crate Version
zebra-chain 16.0.0 zebra-rpc 20.0.0
zebra-consensus 19.0.0 zebra-script 15.0.0
zebra-network 16.0.0 zebra-state 17.0.0
zebra-node-services 14.0.0 zebra-test 6.0.0
zebra-utils 11.0.0 tower-batch-control 1.2.0
tower-fallback 0.2.44

Compatibility

Component Supported
Zcash network upgrades All through NU7
Network protocol version 170190, the same as 7.0.0
State format v29, the same as 7.0.0
Release binaries Linux x86-64 and ARM64
Minimum Rust (source builds) 1.91
End of support Around 10 December 2026, near block 3,662,944 (24 days after release)

Contributors

Thank you to everyone who contributed to this release:
@alchemydc, @andres-pcg, @Anirudh-712, @arcayne, @arya2, @conradoplg, @gustavovalverde, @jvff, @kriss39, @oxarbitrage, @Ravan002, @robustfengbin, @upbqdn, and @zacheryasc

Don't miss a new zebra release

NewReleases is sending notifications on new releases.