Pseudo slashing for invalid signers

consensus/interface.go

@@ -148,6 +148,14 @@ type ScheduledProcessor interface {
 	IsInterfaceNil() bool
 }
 
+// P2PSigningHandler defines the behaviour of a component able to verify p2p message signature
+type P2PSigningHandler interface {
+	Verify(message p2p.MessageP2P) error
+	Serialize(messages []p2p.MessageP2P) ([]byte, error)
+	Deserialize(messagesBytes []byte) ([]p2p.MessageP2P, error)
+	IsInterfaceNil() bool
+}
+
 // SignatureHandler defines the behaviour of a component that handles signatures in consensus
 type SignatureHandler interface {
 	Reset(pubKeys []string) error

consensus/message.go

@@ -21,6 +21,7 @@ func NewConsensusMessage(
 	aggregateSignature []byte,
 	leaderSignature []byte,
 	currentPid core.PeerID,
+	invalidSigners []byte,
 ) *Message {
 	return &Message{
 		BlockHeaderHash:    blHeaderHash,
@@ -36,5 +37,6 @@ func NewConsensusMessage(
 		AggregateSignature: aggregateSignature,
 		LeaderSignature:    leaderSignature,
 		OriginatorPid:      currentPid.Bytes(),
+		InvalidSigners:     invalidSigners,
 	}
 }

consensus/message.proto

@@ -22,4 +22,5 @@ message Message {
 	bytes    AggregateSignature = 11;
 	bytes    LeaderSignature    = 12;
 	bytes    OriginatorPid      = 13;
+    bytes    InvalidSigners     = 14;
 }

consensus/message_test.go

@@ -24,6 +24,7 @@ func TestConsensusMessage_NewConsensusMessageShouldWork(t *testing.T) {
 		nil,
 		nil,
 		"pid",
+		nil,
 	)
 
 	assert.NotNil(t, cnsMsg)

consensus/mock/consensusDataContainerMock.go

@@ -26,6 +26,7 @@ type ConsensusCoreMock struct {
 	marshalizer             marshal.Marshalizer
 	blsPrivateKey           crypto.PrivateKey
 	blsSingleSigner         crypto.SingleSigner
+	keyGenerator            crypto.KeyGenerator
 	multiSignerContainer    cryptoCommon.MultiSignerContainer
 	roundHandler            consensus.RoundHandler
 	shardCoordinator        sharding.Coordinator
@@ -38,6 +39,7 @@ type ConsensusCoreMock struct {
 	fallbackHeaderValidator consensus.FallbackHeaderValidator
 	nodeRedundancyHandler   consensus.NodeRedundancyHandler
 	scheduledProcessor      consensus.ScheduledProcessor
+	messageSigningHandler   consensus.P2PSigningHandler
 	signatureHandler        consensus.SignatureHandler
 }
 
@@ -186,11 +188,16 @@ 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
 }
 
+// KeyGenerator -
+func (ccm *ConsensusCoreMock) KeyGenerator() crypto.KeyGenerator {
+	return ccm.keyGenerator
+}
+
 // PeerHonestyHandler -
 func (ccm *ConsensusCoreMock) PeerHonestyHandler() consensus.PeerHonestyHandler {
 	return ccm.peerHonestyHandler
@@ -231,6 +238,21 @@ func (ccm *ConsensusCoreMock) SetNodeRedundancyHandler(nodeRedundancyHandler con
 	ccm.nodeRedundancyHandler = nodeRedundancyHandler
 }
 
+// MessageSigningHandler -
+func (ccm *ConsensusCoreMock) MessageSigningHandler() consensus.P2PSigningHandler {
+	return ccm.messageSigningHandler
+}
+
+// SetMessageSigningHandler -
+func (ccm *ConsensusCoreMock) SetMessageSigningHandler(messageSigningHandler consensus.P2PSigningHandler) {
+	ccm.messageSigningHandler = messageSigningHandler
+}
+
+// SetKeyGenerator -
+func (ccm *ConsensusCoreMock) SetKeyGenerator(keyGenerator crypto.KeyGenerator) {
+	ccm.keyGenerator = keyGenerator
+}
+
 // SignatureHandler -
 func (ccm *ConsensusCoreMock) SignatureHandler() consensus.SignatureHandler {
 	return ccm.signatureHandler

consensus/mock/keyGenMock.go

@@ -1,7 +1,7 @@
 package mock
 
 import (
-	"github.com/ElrondNetwork/elrond-go-crypto"
+	crypto "github.com/ElrondNetwork/elrond-go-crypto"
 )
 
 // PrivateKeyMock mocks a private key implementation
@@ -84,12 +84,20 @@ func (keyGen *KeyGenMock) GeneratePair() (crypto.PrivateKey, crypto.PublicKey) {
 
 // PrivateKeyFromByteArray generates the private key from it's byte array representation
 func (keyGen *KeyGenMock) PrivateKeyFromByteArray(b []byte) (crypto.PrivateKey, error) {
-	return keyGen.PrivateKeyFromByteArrayMock(b)
+	if keyGen.PrivateKeyFromByteArrayMock != nil {
+		return keyGen.PrivateKeyFromByteArrayMock(b)
+	}
+
+	return &PrivateKeyMock{}, nil
 }
 
 // PublicKeyFromByteArray generates a public key from it's byte array representation
 func (keyGen *KeyGenMock) PublicKeyFromByteArray(b []byte) (crypto.PublicKey, error) {
-	return keyGen.PublicKeyFromByteArrayMock(b)
+	if keyGen.PublicKeyFromByteArrayMock != nil {
+		return keyGen.PublicKeyFromByteArrayMock(b)
+	}
+
+	return &PublicKeyMock{}, nil
 }
 
 // CheckPublicKeyValid verifies the validity of the public key

consensus/mock/messageSigningHandlerMock.go

@@ -0,0 +1,48 @@
+package mock
+
+import (
+	"encoding/json"
+
+	"github.com/ElrondNetwork/elrond-go/p2p"
+	"github.com/ElrondNetwork/elrond-go/p2p/message"
+)
+
+// MessageSignerMock implements P2PSigningHandler interface but it does nothing as it is disabled
+type MessageSignerMock struct {
+}
+
+// Verify does nothing
+func (ms *MessageSignerMock) Verify(message p2p.MessageP2P) error {
+	return nil
+}
+
+// Serialize will serialize the list of p2p messages
+func (ms *MessageSignerMock) Serialize(messages []p2p.MessageP2P) ([]byte, error) {
+	messagesBytes, err := json.Marshal(messages)
+	if err != nil {
+		return nil, err
+	}
+
+	return messagesBytes, nil
+}
+
+// Deserialize will unmarshal into a list of p2p messages
+func (ms *MessageSignerMock) Deserialize(messagesBytes []byte) ([]p2p.MessageP2P, error) {
+	var messages []*message.Message
+	err := json.Unmarshal(messagesBytes, &messages)
+	if err != nil {
+		return nil, err
+	}
+
+	messages2 := make([]p2p.MessageP2P, 0)
+	for _, msg := range messages {
+		messages2 = append(messages2, msg)
+	}
+
+	return messages2, nil
+}
+
+// IsInterfaceNil returns true if there is no value under the interface
+func (ms *MessageSignerMock) IsInterfaceNil() bool {
+	return ms == nil
+}