Merge pull request #7888 from multiversx/merge-master-into-rc/supernova-2026.06.23

Merge master into rc/supernova 2026.06.23

Author: sstanculeanu

consensus/spos/bls/proxy/subroundsHandler_test.go

@@ -11,6 +11,7 @@ import (
 
 	mock2 "github.com/multiversx/mx-chain-go/consensus/mock"
 	"github.com/multiversx/mx-chain-go/consensus/spos"
+	"github.com/multiversx/mx-chain-go/consensus/spos/bls"
 	"github.com/multiversx/mx-chain-go/testscommon"
 	"github.com/multiversx/mx-chain-go/testscommon/bootstrapperStubs"
 	"github.com/multiversx/mx-chain-go/testscommon/common"
@@ -87,6 +88,10 @@ func getDefaultArgumentsSubroundHandler() (*SubroundsHandlerArgs, *spos.Consensu
 	consensusCore.SetEquivalentProofsPool(&dataRetriever.ProofsPoolMock{})
 	consensusCore.SetEpochNotifier(epochNotifier)
 	consensusCore.SetInvalidSignersCache(&consensus.InvalidSignersCacheMock{})
+
+	messagesHandler, _ := bls.NewConsensusService()
+	consensusCore.SetMessagesHandler(messagesHandler)
+
 	handlerArgs.ConsensusCoreHandler = consensusCore
 
 	return handlerArgs, consensusCore

consensus/spos/bls/v1/subroundEndRound.go

@@ -479,9 +479,10 @@ func (sr *subroundEndRound) verifyNodesOnAggSigFail() ([]string, error) {
 
 func (sr *subroundEndRound) getFullMessagesForInvalidSigners(invalidPubKeys []string) ([]byte, error) {
 	p2pMessages := make([]p2p.MessageP2P, 0)
+	headerHash := sr.GetData()
 
 	for _, pk := range invalidPubKeys {
-		p2pMsg, ok := sr.GetMessageWithSignature(pk)
+		p2pMsg, ok := sr.GetMessageWithSignature(spos.SignatureMessageKey(headerHash, pk))
 		if !ok {
 			log.Trace("message not found in state for invalid signer", "pubkey", pk)
 			continue

consensus/spos/bls/v1/subroundEndRound_test.go

@@ -1720,8 +1720,9 @@ func TestGetFullMessagesForInvalidSigners(t *testing.T) {
 		container.SetMessageSigningHandler(messageSigningHandler)
 
 		sr := initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
-		sr.AddMessageWithSignature("B", &p2pmocks.P2PMessageMock{})
-		sr.AddMessageWithSignature("C", &p2pmocks.P2PMessageMock{})
+		headerHash := sr.GetData()
+		sr.AddMessageWithSignature(spos.SignatureMessageKey(headerHash, "B"), &p2pmocks.P2PMessageMock{})
+		sr.AddMessageWithSignature(spos.SignatureMessageKey(headerHash, "C"), &p2pmocks.P2PMessageMock{})
 
 		invalidSigners := []string{"B", "C"}
 

consensus/spos/bls/v2/benchmark_send_proof_test.go

@@ -120,7 +120,7 @@ func benchmarkSendProof(b *testing.B, numberOfKeys int) {
 	// Initialize consensus state with real keys
 	consensusState := initializers.InitConsensusStateWithArgsVerifySignature(keysHandlerMock, keys)
 	dataToBeSigned := []byte("block_header_hash_for_benchmark")
-	consensusState.Data = dataToBeSigned
+	consensusState.SetData(dataToBeSigned)
 
 	ch := make(chan bool, 1)
 

consensus/spos/bls/v2/benchmark_verify_signatures_test.go

@@ -110,7 +110,7 @@ func BenchmarkSubroundEndRound_VerifyNodesOnAggSigFailTime(b *testing.B) {
 	container.SetSigningHandler(signingHandler)
 	consensusState := initializers.InitConsensusStateWithArgsVerifySignature(keysHandlerMock, keys)
 	dataToBeSigned := []byte("message")
-	consensusState.Data = dataToBeSigned
+	consensusState.SetData(dataToBeSigned)
 
 	sr := initSubroundEndRoundWithContainerAndConsensusState(container, &statusHandler.AppStatusHandlerStub{}, consensusState)
 	for i := 0; i < len(sr.ConsensusGroup()); i++ {

consensus/spos/bls/v2/errors.go

@@ -11,11 +11,14 @@ var ErrTimeOut = errors.New("time is out")
 // ErrProofAlreadyPropagated signals that the proof was already propagated
 var ErrProofAlreadyPropagated = errors.New("proof already propagated")
 
+// ErrValidSignatureFromInvalidSigner signals that a valid signature was received on invalid signers message
+var ErrValidSignatureFromInvalidSigner = errors.New("valid signature from invalid sender")
+
+// ErrHeaderHashMismatch signals that header hash does not match
+var ErrHeaderHashMismatch = errors.New("header hash does not match")
+
 // ErrNilRoundSyncController signals that a nil round sync controller has been provided
 var ErrNilRoundSyncController = errors.New("nil round sync controller")
 
 // ErrTooManyInvalidSigners signals that too many invalid signers were received
 var ErrTooManyInvalidSigners = errors.New("too many invalid signers")
-
-// ErrValidSignatureFromInvalidSigner signals that a valid signature was received on invalid signers message
-var ErrValidSignatureFromInvalidSigner = errors.New("valid signature from invalid sender")

consensus/spos/bls/v2/export_test.go

@@ -302,8 +302,8 @@ func (sr *subroundEndRound) ReceivedInvalidSignersInfo(cnsDta *consensus.Message
 }
 
 // VerifyInvalidSigners calls the unexported verifyInvalidSigners function
-func (sr *subroundEndRound) VerifyInvalidSigners(invalidSigners []byte) ([]string, error) {
-	return sr.verifyInvalidSigners(invalidSigners)
+func (sr *subroundEndRound) VerifyInvalidSigners(headerHash []byte, invalidSigners []byte) ([]string, error) {
+	return sr.verifyInvalidSigners(headerHash, invalidSigners)
 }
 
 // GetMinConsensusGroupIndexOfManagedKeys calls the unexported getMinConsensusGroupIndexOfManagedKeys function

consensus/spos/bls/v2/subroundEndRound.go

@@ -156,9 +156,15 @@ func (sr *subroundEndRound) receivedInvalidSignersInfo(_ context.Context, cnsDta
 		return false
 	}
 
-	invalidSignersPubKeys, err := sr.verifyInvalidSigners(cnsDta.InvalidSigners)
+	invalidSignersPubKeys, err := sr.verifyInvalidSigners(cnsDta.BlockHeaderHash, cnsDta.InvalidSigners)
 	if err != nil {
 		log.Trace("receivedInvalidSignersInfo.verifyInvalidSigners", "error", err.Error())
+
+		if errors.Is(err, ErrValidSignatureFromInvalidSigner) {
+			originatorPeer := core.PeerID(cnsDta.OriginatorPid)
+			sr.applyBlacklistOnNode(originatorPeer)
+		}
+
 		return false
 	}
 
@@ -175,7 +181,10 @@ func (sr *subroundEndRound) receivedInvalidSignersInfo(_ context.Context, cnsDta
 	return true
 }
 
-func (sr *subroundEndRound) verifyInvalidSigners(invalidSigners []byte) ([]string, error) {
+func (sr *subroundEndRound) verifyInvalidSigners(
+	headerHash []byte,
+	invalidSigners []byte,
+) ([]string, error) {
 	messages, err := sr.MessageSigningHandler().Deserialize(invalidSigners)
 	if err != nil {
 		return nil, err
@@ -187,7 +196,7 @@ func (sr *subroundEndRound) verifyInvalidSigners(invalidSigners []byte) ([]strin
 
 	pubKeys := make([]string, 0, len(messages))
 	for _, msg := range messages {
-		pubKey, errVerify := sr.verifyInvalidSigner(msg)
+		pubKey, errVerify := sr.verifyInvalidSigner(headerHash, msg)
 		if errVerify != nil {
 			return nil, errVerify
 		}
@@ -200,18 +209,30 @@ func (sr *subroundEndRound) verifyInvalidSigners(invalidSigners []byte) ([]strin
 	return pubKeys, nil
 }
 
-func (sr *subroundEndRound) verifyInvalidSigner(msg p2p.MessageP2P) (string, error) {
-	err := sr.MessageSigningHandler().Verify(msg)
+func (sr *subroundEndRound) verifyInvalidSigner(
+	headerHash []byte,
+	msg p2p.MessageP2P,
+) (string, error) {
+	cnsMsg := &consensus.Message{}
+	err := sr.Marshalizer().Unmarshal(cnsMsg, msg.Data())
 	if err != nil {
 		return "", err
 	}
 
-	cnsMsg := &consensus.Message{}
-	err = sr.Marshalizer().Unmarshal(cnsMsg, msg.Data())
+	msgType := consensus.MessageType(cnsMsg.MsgType)
+	if !sr.MessagesHandler().IsMessageWithSignature(msgType) {
+		return "", spos.ErrInvalidMessageType
+	}
+
+	err = sr.MessageSigningHandler().Verify(msg)
 	if err != nil {
 		return "", err
 	}
 
+	if !bytes.Equal(headerHash, cnsMsg.BlockHeaderHash) {
+		return "", ErrHeaderHashMismatch
+	}
+
 	err = sr.SigningHandler().VerifySingleSignature(cnsMsg.PubKey, cnsMsg.BlockHeaderHash, cnsMsg.SignatureShare)
 	if err != nil {
 		log.Debug("verifyInvalidSigner: confirmed that node provided invalid signature",
@@ -575,9 +596,10 @@ func (sr *subroundEndRound) clearJobDoneForUnVerifiedSignatures(pubKeys []string
 
 func (sr *subroundEndRound) getFullMessagesForInvalidSigners(invalidPubKeys []string) ([]byte, error) {
 	p2pMessages := make([]p2p.MessageP2P, 0)
+	headerHash := sr.GetData()
 
 	for _, pk := range invalidPubKeys {
-		p2pMsg, ok := sr.GetMessageWithSignature(pk)
+		p2pMsg, ok := sr.GetMessageWithSignature(spos.SignatureMessageKey(headerHash, pk))
 		if !ok {
 			log.Trace("message not found in state for invalid signer", "pubkey", pk)
 			continue