Pseudo slashing for invalid signers

consensus/mock/consensusDataContainerMock.go

@@ -188,7 +188,7 @@ func (ccm *ConsensusCoreMock) PrivateKey() crypto.PrivateKey {
 	return ccm.blsPrivateKey
 }
 
-// SingleSigner returns the bls single signer stored in the ConsensusStore
+// SingleSigner returns the bls single signer stored in the ConsensusCore
 func (ccm *ConsensusCoreMock) SingleSigner() crypto.SingleSigner {
 	return ccm.blsSingleSigner
 }

consensus/spos/bls/subroundEndRound.go

@@ -158,35 +158,48 @@ func (sr *subroundEndRound) isBlockHeaderFinalInfoValid(cnsDta *consensus.Messag
 
 // receivedInvalidSignersInfo method is called when a message with invalid signers has been received
 func (sr *subroundEndRound) receivedInvalidSignersInfo(_ context.Context, cnsDta *consensus.Message) bool {
-	node := string(cnsDta.PubKey)
+	messageSender := string(cnsDta.PubKey)
 
 	if !sr.IsConsensusDataSet() {
 		return false
 	}
 
-	if !sr.IsNodeLeaderInCurrentRound(node) { // is NOT this node leader in current round?
+	if !sr.IsNodeLeaderInCurrentRound(messageSender) { // is NOT this node leader in current round?
 		sr.PeerHonestyHandler().ChangeScore(
-			node,
+			messageSender,
 			spos.GetConsensusTopicID(sr.ShardCoordinator()),
 			spos.LeaderPeerHonestyDecreaseFactor,
 		)
 
 		return false
 	}
 
+	if sr.IsSelfLeaderInCurrentRound() {
+		return false
+	}
+
+	if !sr.IsConsensusDataEqual(cnsDta.BlockHeaderHash) {
+		return false
+	}
+
+	if !sr.CanProcessReceivedMessage(cnsDta, sr.RoundHandler().Index(), sr.Current()) {
+		return false
+	}
+
 	if len(cnsDta.InvalidSigners) == 0 {
 		return false
 	}
 
 	err := sr.verifyInvalidSigners(cnsDta.InvalidSigners)
 	if err != nil {
+		log.Trace("receivedInvalidSignersInfo.verifyInvalidSigners", "error", err.Error())
 		return false
 	}
 
 	log.Debug("step 3: invalid signers info has been evaluated")
 
 	sr.PeerHonestyHandler().ChangeScore(
-		node,
+		messageSender,
 		spos.GetConsensusTopicID(sr.ShardCoordinator()),
 		spos.LeaderPeerHonestyIncreaseFactor,
 	)
@@ -298,7 +311,6 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 	}
 
 	invalidSigners := make([]byte, 0)
-	shouldSendInvalidSigners := false
 
 	err = sr.SignatureHandler().Verify(sr.GetData(), bitmap, sr.Header.GetEpoch())
 	if err != nil {
@@ -310,12 +322,16 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 			return false
 		}
 
-		invalidSigners, shouldSendInvalidSigners, err = sr.getFullMessagesForInvalidSigners(invalidPubKeys)
+		invalidSigners, err = sr.getFullMessagesForInvalidSigners(invalidPubKeys)
 		if err != nil {
 			log.Debug("doEndRoundJobByLeader.getFullMessagesForInvalidSigners", "error", err.Error())
 			return false
 		}
 
+		if len(invalidSigners) > 0 {
+			sr.createAndBroadcastInvalidSigners(invalidSigners)
+		}
+
 		bitmap, sig, err = sr.computeAggSigOnValidNodes()
 		if err != nil {
 			log.Debug("doEndRoundJobByLeader.computeAggSigOnValidNodes", "error", err.Error())
@@ -362,9 +378,7 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 		return false
 	}
 
-	if shouldSendInvalidSigners {
-		sr.createAndBroadcastInvalidSigners(invalidSigners)
-	}
+	// broadcast header and final info section
 
 	// create and broadcast header final info
 	sr.createAndBroadcastHeaderFinalInfo()
@@ -442,7 +456,7 @@ func (sr *subroundEndRound) verifyNodesOnAggSigVerificationFail() ([]string, err
 			}
 
 			// use increase factor since it was added optimistically, and it proved to be wrong
-			decreaseFactor := -spos.ValidatorPeerHonestyIncreaseFactor
+			decreaseFactor := -spos.ValidatorPeerHonestyIncreaseFactor + spos.ValidatorPeerHonestyDecreaseFactor
 			sr.PeerHonestyHandler().ChangeScore(
 				pk,
 				spos.GetConsensusTopicID(sr.ShardCoordinator()),
@@ -458,8 +472,7 @@ func (sr *subroundEndRound) verifyNodesOnAggSigVerificationFail() ([]string, err
 	return invalidPubKeys, nil
 }
 
-func (sr *subroundEndRound) getFullMessagesForInvalidSigners(invalidPubKeys []string) ([]byte, bool, error) {
-	shouldSend := false
+func (sr *subroundEndRound) getFullMessagesForInvalidSigners(invalidPubKeys []string) ([]byte, error) {
 	p2pMessages := make([]p2p.MessageP2P, 0)
 
 	for _, pk := range invalidPubKeys {
@@ -469,15 +482,14 @@ func (sr *subroundEndRound) getFullMessagesForInvalidSigners(invalidPubKeys []st
 		}
 
 		p2pMessages = append(p2pMessages, p2pMsg)
-		shouldSend = true
 	}
 
 	invalidSigners, err := sr.MessageSigningHandler().Serialize(p2pMessages)
 	if err != nil {
-		return nil, false, err
+		return nil, err
 	}
 
-	return invalidSigners, shouldSend, nil
+	return invalidSigners, nil
 }
 
 func (sr *subroundEndRound) computeAggSigOnValidNodes() ([]byte, []byte, error) {

consensus/spos/bls/subroundEndRound_test.go

@@ -1230,23 +1230,6 @@ func TestSubroundEndRound_ReceivedInvalidSignersInfo(t *testing.T) {
 		assert.False(t, res)
 	})
 
-	t.Run("cannot process message", func(t *testing.T) {
-		t.Parallel()
-
-		container := mock.InitConsensusCore()
-
-		sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
-		sr.SetSelfPubKey("A")
-
-		cnsData := consensus.Message{
-			BlockHeaderHash: []byte("X"),
-			PubKey:          []byte("A"),
-		}
-
-		res := sr.ReceivedInvalidSignersInfo(&cnsData)
-		assert.False(t, res)
-	})
-
 	t.Run("empty invalid signers", func(t *testing.T) {
 		t.Parallel()
 

consensus/spos/consensusCore.go

@@ -180,17 +180,17 @@ func (cc *ConsensusCore) EpochStartRegistrationHandler() epochStart.Registration
 	return cc.epochStartRegistrationHandler
 }
 
-// PrivateKey returns the BLS private key stored in the ConsensusStore
+// PrivateKey returns the BLS private key stored in the ConsensusCore
 func (cc *ConsensusCore) PrivateKey() crypto.PrivateKey {
 	return cc.blsPrivateKey
 }
 
-// SingleSigner returns the bls single signer stored in the ConsensusStore
+// SingleSigner returns the bls single signer stored in the ConsensusCore
 func (cc *ConsensusCore) SingleSigner() crypto.SingleSigner {
 	return cc.blsSingleSigner
 }
 
-// KeyGenerator returns the bls key generator stored in the ConsensusStore
+// KeyGenerator returns the bls key generator stored in the ConsensusCore
 func (cc *ConsensusCore) KeyGenerator() crypto.KeyGenerator {
 	return cc.keyGenerator
 }

consensus/spos/interface.go

@@ -49,11 +49,11 @@ type ConsensusCoreHandler interface {
 	NodesCoordinator() nodesCoordinator.NodesCoordinator
 	// EpochStartRegistrationHandler gets the RegistrationHandler stored in the ConsensusCore
 	EpochStartRegistrationHandler() epochStart.RegistrationHandler
-	// PrivateKey returns the private key stored in the ConsensusStore used for randomness and leader's signature generation
+	// PrivateKey returns the private key stored in the ConsensusCore used for randomness and leader's signature generation
 	PrivateKey() crypto.PrivateKey
-	// SingleSigner returns the single signer stored in the ConsensusStore used for randomness and leader's signature generation
+	// SingleSigner returns the single signer stored in the ConsensusCore used for randomness and leader's signature generation
 	SingleSigner() crypto.SingleSigner
-	// KeyGenerator returns the key generator stored in the ConsensusStore
+	// KeyGenerator returns the key generator stored in the ConsensusCore
 	KeyGenerator() crypto.KeyGenerator
 	// PeerHonestyHandler returns the peer honesty handler which will be used in subrounds
 	PeerHonestyHandler() consensus.PeerHonestyHandler
@@ -65,7 +65,7 @@ type ConsensusCoreHandler interface {
 	NodeRedundancyHandler() consensus.NodeRedundancyHandler
 	// ScheduledProcessor returns the scheduled txs processor
 	ScheduledProcessor() consensus.ScheduledProcessor
-	// MessageSignerHandler
+	// MessageSignerHandler return the p2p signing handler
 	MessageSigningHandler() consensus.P2PSigningHandler
 	// SignatureHandler returns the signature handler component
 	SignatureHandler() consensus.SignatureHandler