CVE-2026-33471

@@ -18,7 +18,7 @@ use nimiq_transaction::{
 };
 use thiserror::Error;
 
-use crate::{MacroHeader, MicroHeader};
+use crate::{multisig::checked_signer_slots, MacroHeader, MicroHeader};
 
 /// An equivocation proof proves that a validator misbehaved.
 ///
@@ -527,6 +527,11 @@ impl DoubleVoteProof {
         validators: &Validators,
         validator_slots: Range<u16>,
     ) -> Result<(), EquivocationProofError> {
+        let checked_signers1 = checked_signer_slots(&self.signers1)
+            .ok_or(EquivocationProofError::InvalidJustification)?;
+        let checked_signers2 = checked_signer_slots(&self.signers2)
+            .ok_or(EquivocationProofError::InvalidJustification)?;
+
         // Check that the proposals are not equal and in the right order:
         match self.proposal_hash1.cmp(&self.proposal_hash2) {
             Ordering::Less => {}
@@ -538,24 +543,27 @@ impl DoubleVoteProof {
         #[allow(clippy::redundant_clone)]
         if !validator_slots
             .clone()
-            .any(|s| self.signers1.contains(s as usize) && self.signers2.contains(s as usize))
+            .any(|s| checked_signers1.contains(&s) && checked_signers2.contains(&s))
         {
             return Err(EquivocationProofError::NoOverlap);
         }
 
         let verify =
-            |proposal_hash, signers: &BitSet, signature| -> Result<(), EquivocationProofError> {
+            |proposal_hash, signers: &[u16], signature| -> Result<(), EquivocationProofError> {
                 // Calculate the message that was actually signed by the validators.
                 let message = TendermintVote {
                     proposal_hash,
                     id: self.tendermint_id.clone(),
                 };
                 // Verify the signatures.
                 let mut agg_pk = AggregatePublicKey::new();
-                for (i, pk) in validators.voting_keys().iter().enumerate() {
-                    if signers.contains(i) {
-                        agg_pk.aggregate(pk);
-                    }
+                for slot in signers {
+                    let pk = validators
+                        .get_validator_by_slot_number(*slot)
+                        .voting_key
+                        .uncompress()
+                        .expect("Failed to uncompress CompressedPublicKey");
+                    agg_pk.aggregate(pk);
                 }
                 if !agg_pk.verify(&message, signature) {
                     return Err(EquivocationProofError::InvalidJustification);
@@ -565,12 +573,12 @@ impl DoubleVoteProof {
 
         verify(
             self.proposal_hash1.clone(),
-            &self.signers1,
+            &checked_signers1,
             &self.signature1,
         )?;
         verify(
             self.proposal_hash2.clone(),
-            &self.signers2,
+            &checked_signers2,
             &self.signature2,
         )?;
         Ok(())

@@ -37,3 +37,14 @@ impl MultiSignature {
         }
     }
 }
+
+pub(crate) fn checked_signer_slots(signers: &BitSet) -> Option<Vec<u16>> {
+    let mut slots = Vec::with_capacity(signers.len());
+    for slot in signers.iter() {
+        if slot >= Policy::SLOTS as usize || slot > u16::MAX as usize {
+            return None;
+        }
+        slots.push(slot as u16);
+    }
+    Some(slots)
+}

@@ -9,7 +9,7 @@ use nimiq_primitives::{
 use nimiq_serde::{Deserialize, Serialize, SerializedMaxSize};
 use nimiq_vrf::VrfEntropy;
 
-use crate::{MicroBlock, MultiSignature};
+use crate::{multisig::checked_signer_slots, MicroBlock, MultiSignature};
 
 pub type SignedSkipBlockInfo = SignedMessage<SkipBlockInfo>;
 
@@ -59,8 +59,18 @@ impl SkipBlockProof {
     /// Verifies the proof. This only checks that the proof is valid for this skip block, not that
     /// the skip block itself is valid.
     pub fn verify(&self, skip_block: &SkipBlockInfo, validators: &Validators) -> bool {
+        let signer_slots = match checked_signer_slots(&self.sig.signers) {
+            Some(slots) => slots,
+            None => {
+                error!(
+                    "SkipBlockProof verification failed: signer set contains out-of-range slots."
+                );
+                return false;
+            }
+        };
+
         // Check if there are enough votes.
-        if self.sig.signers.len() < Policy::TWO_F_PLUS_ONE as usize {
+        if signer_slots.len() < Policy::TWO_F_PLUS_ONE as usize {
             error!(
                 "SkipBlockProof verification failed: Not enough slots signed the skip block message."
             );
@@ -70,12 +80,11 @@ impl SkipBlockProof {
         // Get the public key for each SLOT present in the signature and add them together to get
         // the aggregated public key.
         let agg_pk =
-            self.sig
-                .signers
-                .iter()
+            signer_slots
+                .into_iter()
                 .fold(AggregatePublicKey::new(), |mut aggregate, slot| {
                     let pk = validators
-                        .get_validator_by_slot_number(slot as u16)
+                        .get_validator_by_slot_number(slot)
                         .voting_key
                         .uncompress()
                         .expect("Failed to uncompress CompressedPublicKey");

@@ -6,7 +6,7 @@ use nimiq_primitives::{
 };
 use nimiq_serde::{Deserialize, Serialize, SerializedMaxSize};
 
-use crate::{MacroBlock, MultiSignature};
+use crate::{multisig::checked_signer_slots, MacroBlock, MultiSignature};
 
 /// The proof for a block produced by Tendermint.
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, SerializedMaxSize)]
@@ -35,8 +35,16 @@ impl TendermintProof {
             Some(x) => x,
         };
 
+        let signer_slots = match checked_signer_slots(&justification.sig.signers) {
+            Some(slots) => slots,
+            None => {
+                error!("Invalid justification - signer set contains out-of-range slots!");
+                return false;
+            }
+        };
+
         // Check if there are enough votes.
-        if justification.votes() < Policy::TWO_F_PLUS_ONE {
+        if signer_slots.len() < Policy::TWO_F_PLUS_ONE as usize {
             error!("Invalid justification - not enough votes!");
             return false;
         }
@@ -59,10 +67,13 @@ impl TendermintProof {
         // (if they are part of the Multisignature Bitset).
         let mut agg_pk = AggregatePublicKey::new();
 
-        for (i, pk) in current_validators.voting_keys().iter().enumerate() {
-            if justification.sig.signers.contains(i) {
-                agg_pk.aggregate(pk);
-            }
+        for slot in signer_slots {
+            let pk = current_validators
+                .get_validator_by_slot_number(slot)
+                .voting_key
+                .uncompress()
+                .expect("Failed to uncompress CompressedPublicKey");
+            agg_pk.aggregate(pk);
         }
 
         // Verify the aggregated signature against our aggregated public key.