Pseudo slashing fixes

consensus/spos/bls/export_test.go

@@ -298,7 +298,7 @@ func (sr *subroundEndRound) IsOutOfTime() bool {
 }
 
 func (sr *subroundEndRound) VerifyNodesOnAggSigVerificationFail() ([]string, error) {
-	return sr.verifyNodesOnAggSigVerificationFail()
+	return sr.verifyNodesOnAggSigFail()
 }
 
 func (sr *subroundEndRound) ComputeAggSigOnValidNodes() ([]byte, []byte, error) {
@@ -317,3 +317,7 @@ func (sr *subroundEndRound) VerifyInvalidSigners(invalidSigners []byte) error {
 func GetStringValue(messageType consensus.MessageType) string {
 	return getStringValue(messageType)
 }
+
+func (sr *subroundEndRound) CreateAndBroadcastInvalidSigners(invalidSigners []byte) {
+	sr.createAndBroadcastInvalidSigners(invalidSigners)
+}

consensus/spos/bls/subroundEndRound.go

@@ -299,45 +299,12 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 	}
 
 	// Aggregate sig and add it to the block
-	sig, err := sr.SignatureHandler().AggregateSigs(bitmap, sr.Header.GetEpoch())
-	if err != nil {
-		log.Debug("doEndRoundJobByLeader.AggregateSigs", "error", err.Error())
-		return false
-	}
-
-	err = sr.SignatureHandler().SetAggregatedSig(sig)
+	bitmap, sig, err := sr.aggregateSigsAndHandleInvalidSigners(bitmap)
 	if err != nil {
-		log.Debug("doEndRoundJobByLeader.SetAggregatedSig", "error", err.Error())
+		log.Debug("doEndRoundJobByLeader.aggregateSigsAndHandleInvalidSigners", "error", err.Error())
 		return false
 	}
 
-	err = sr.SignatureHandler().Verify(sr.GetData(), bitmap, sr.Header.GetEpoch())
-	if err != nil {
-		log.Debug("doEndRoundJobByLeader.Verify", "error", err.Error())
-
-		invalidPubKeys, err := sr.verifyNodesOnAggSigVerificationFail()
-		if err != nil {
-			log.Debug("doEndRoundJobByLeader.verifyNodesOnAggSigVerificationFail", "error", err.Error())
-			return false
-		}
-
-		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())
-			return false
-		}
-	}
-
 	err = sr.Header.SetPubKeysBitmap(bitmap)
 	if err != nil {
 		log.Debug("doEndRoundJobByLeader.SetPubKeysBitmap", "error", err.Error())
@@ -422,10 +389,31 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool {
 	return true
 }
 
-// TODO:
-//	- slashing for invalid sig shares
-//	- handle sig share verifications concurrently
-func (sr *subroundEndRound) verifyNodesOnAggSigVerificationFail() ([]string, error) {
+func (sr *subroundEndRound) aggregateSigsAndHandleInvalidSigners(bitmap []byte) ([]byte, []byte, error) {
+	sig, err := sr.SignatureHandler().AggregateSigs(bitmap, sr.Header.GetEpoch())
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.AggregateSigs", "error", err.Error())
+
+		return sr.handleInvalidSignersOnAggSigFail()
+	}
+
+	err = sr.SignatureHandler().SetAggregatedSig(sig)
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.SetAggregatedSig", "error", err.Error())
+		return nil, nil, err
+	}
+
+	err = sr.SignatureHandler().Verify(sr.GetData(), bitmap, sr.Header.GetEpoch())
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.Verify", "error", err.Error())
+
+		return sr.handleInvalidSignersOnAggSigFail()
+	}
+
+	return bitmap, sig, nil
+}
+
+func (sr *subroundEndRound) verifyNodesOnAggSigFail() ([]string, error) {
 	invalidPubKeys := make([]string, 0)
 	pubKeys := sr.ConsensusGroup()
 
@@ -491,6 +479,32 @@ func (sr *subroundEndRound) getFullMessagesForInvalidSigners(invalidPubKeys []st
 	return invalidSigners, nil
 }
 
+func (sr *subroundEndRound) handleInvalidSignersOnAggSigFail() ([]byte, []byte, error) {
+	invalidPubKeys, err := sr.verifyNodesOnAggSigFail()
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.verifyNodesOnAggSigFail", "error", err.Error())
+		return nil, nil, err
+	}
+
+	invalidSigners, err := sr.getFullMessagesForInvalidSigners(invalidPubKeys)
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.getFullMessagesForInvalidSigners", "error", err.Error())
+		return nil, nil, err
+	}
+
+	if len(invalidSigners) > 0 {
+		sr.createAndBroadcastInvalidSigners(invalidSigners)
+	}
+
+	bitmap, sig, err := sr.computeAggSigOnValidNodes()
+	if err != nil {
+		log.Debug("doEndRoundJobByLeader.computeAggSigOnValidNodes", "error", err.Error())
+		return nil, nil, err
+	}
+
+	return bitmap, sig, nil
+}
+
 func (sr *subroundEndRound) computeAggSigOnValidNodes() ([]byte, []byte, error) {
 	threshold := sr.Threshold(sr.Current())
 	numValidSigShares := sr.ComputeSize(SrSignature)

consensus/spos/bls/subroundEndRound_test.go

@@ -2,6 +2,7 @@ package bls_test
 
 import (
 	"errors"
+	"sync"
 	"testing"
 	"time"
 
@@ -1470,3 +1471,31 @@ func TestVerifyInvalidSigners(t *testing.T) {
 		require.Nil(t, err)
 	})
 }
+
+func TestSubroundEndRound_CreateAndBroadcastInvalidSigners(t *testing.T) {
+	t.Parallel()
+
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	expectedInvalidSigners := []byte("invalid signers")
+
+	wasCalled := false
+	container := mock.InitConsensusCore()
+	messenger := &mock.BroadcastMessengerMock{
+		BroadcastConsensusMessageCalled: func(message *consensus.Message) error {
+			wg.Done()
+			assert.Equal(t, expectedInvalidSigners, message.InvalidSigners)
+			wasCalled = true
+			return nil
+		},
+	}
+	container.SetBroadcastMessenger(messenger)
+	sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{})
+
+	sr.CreateAndBroadcastInvalidSigners(expectedInvalidSigners)
+
+	wg.Wait()
+
+	require.True(t, wasCalled)
+}

integrationTests/consensus/consensusSigning_test.go

@@ -1,6 +1,7 @@
 package consensus
 
 import (
+	"bytes"
 	"encoding/hex"
 	"fmt"
 	"sync"
@@ -44,7 +45,16 @@ func initNodesWithTestSigner(
 					fmt.Println("invalid sig share from ",
 						getPkEncoded(nodes[shardID][iCopy].NodeKeys.Pk),
 					)
-					invalidSigShare, _ := hex.DecodeString("2ee350b9a821e20df97ba487a80b0d0ffffca7da663185cf6a562edc7c2c71e3ca46ed71b31bccaf53c626b87f2b6e08")
+
+					var invalidSigShare []byte
+					if i%2 == 0 {
+						// invalid sig share but with valid format
+						invalidSigShare, _ = hex.DecodeString("2ee350b9a821e20df97ba487a80b0d0ffffca7da663185cf6a562edc7c2c71e3ca46ed71b31bccaf53c626b87f2b6e08")
+					} else {
+						// sig share with invalid size
+						invalidSigShare = bytes.Repeat([]byte("a"), 3)
+					}
+
 					return invalidSigShare, nil
 				}
 			}