Signature handler component for consensus

consensus/interface.go

@@ -147,3 +147,17 @@ type ScheduledProcessor interface {
 	IsProcessedOKWithTimeout() bool
 	IsInterfaceNil() bool
 }
+
+// SignatureHandler defines the behaviour of a component that handles signatures in consensus
+type SignatureHandler interface {
+	Reset(pubKeys []string) error
+	SetMultiSignerByEpoch(epoch uint32) error
+	CreateSignatureShare(msg []byte, index uint16) ([]byte, error)
+	StoreSignatureShare(index uint16, sig []byte) error
+	SignatureShare(index uint16) ([]byte, error)
+	VerifySignatureShare(index uint16, sig []byte, msg []byte) error
+	AggregateSigs(bitmap []byte) ([]byte, error)
+	SetAggregatedSig([]byte) error
+	Verify(msg []byte, bitmap []byte) error
+	IsInterfaceNil() bool
+}

consensus/mock/consensusDataContainerMock.go

@@ -38,6 +38,7 @@ type ConsensusCoreMock struct {
 	fallbackHeaderValidator consensus.FallbackHeaderValidator
 	nodeRedundancyHandler   consensus.NodeRedundancyHandler
 	scheduledProcessor      consensus.ScheduledProcessor
+	signatureHandler        consensus.SignatureHandler
 }
 
 // GetAntiFloodHandler -
@@ -230,6 +231,16 @@ func (ccm *ConsensusCoreMock) SetNodeRedundancyHandler(nodeRedundancyHandler con
 	ccm.nodeRedundancyHandler = nodeRedundancyHandler
 }
 
+// SignatureHandler -
+func (ccm *ConsensusCoreMock) SignatureHandler() consensus.SignatureHandler {
+	return ccm.signatureHandler
+}
+
+// SetSignatureHandler -
+func (ccm *ConsensusCoreMock) SetSignatureHandler(signatureHandler consensus.SignatureHandler) {
+	ccm.signatureHandler = signatureHandler
+}
+
 // IsInterfaceNil returns true if there is no value under the interface
 func (ccm *ConsensusCoreMock) IsInterfaceNil() bool {
 	return ccm == nil

consensus/mock/mockTestInitializer.go

@@ -205,6 +205,7 @@ func InitConsensusCoreWithMultiSigner(multiSigner crypto.MultiSigner) *Consensus
 	nodeRedundancyHandler := &NodeRedundancyHandlerStub{}
 	scheduledProcessor := &consensusMocks.ScheduledProcessorStub{}
 	multiSignerContainer := cryptoMocks.NewMultiSignerContainerMock(multiSigner)
+	signatureHandler := &SignatureHandlerStub{}
 
 	container := &ConsensusCoreMock{
 		blockChain:              blockChain,
@@ -229,6 +230,7 @@ func InitConsensusCoreWithMultiSigner(multiSigner crypto.MultiSigner) *Consensus
 		fallbackHeaderValidator: fallbackHeaderValidator,
 		nodeRedundancyHandler:   nodeRedundancyHandler,
 		scheduledProcessor:      scheduledProcessor,
+		signatureHandler:        signatureHandler,
 	}
 
 	return container

consensus/mock/signatureHandlerStub.go

@@ -0,0 +1,100 @@
+package mock
+
+// SignatureHandlerStub implements SignatureHandler interface
+type SignatureHandlerStub struct {
+	ResetCalled                 func(pubKeys []string) error
+	SetMultiSignerByEpochCalled func(epoch uint32) error
+	CreateSignatureShareCalled  func(msg []byte, index uint16) ([]byte, error)
+	StoreSignatureShareCalled   func(index uint16, sig []byte) error
+	SignatureShareCalled        func(index uint16) ([]byte, error)
+	VerifySignatureShareCalled  func(index uint16, sig []byte, msg []byte) error
+	AggregateSigsCalled         func(bitmap []byte) ([]byte, error)
+	SetAggregatedSigCalled      func(_ []byte) error
+	VerifyCalled                func(msg []byte, bitmap []byte) error
+}
+
+// SetMultiSignerByEpoch -
+func (stub *SignatureHandlerStub) SetMultiSignerByEpoch(epoch uint32) error {
+	if stub.SetMultiSignerByEpochCalled != nil {
+		return stub.SetMultiSignerByEpochCalled(epoch)
+	}
+
+	return nil
+}
+
+// Reset -
+func (stub *SignatureHandlerStub) Reset(pubKeys []string) error {
+	if stub.ResetCalled != nil {
+		return stub.ResetCalled(pubKeys)
+	}
+
+	return nil
+}
+
+// CreateSignatureShare -
+func (stub *SignatureHandlerStub) CreateSignatureShare(msg []byte, index uint16) ([]byte, error) {
+	if stub.CreateSignatureShareCalled != nil {
+		return stub.CreateSignatureShareCalled(msg, index)
+	}
+
+	return []byte("sigShare"), nil
+}
+
+// StoreSignatureShare -
+func (stub *SignatureHandlerStub) StoreSignatureShare(index uint16, sig []byte) error {
+	if stub.StoreSignatureShareCalled != nil {
+		return stub.StoreSignatureShareCalled(index, sig)
+	}
+
+	return nil
+}
+
+// SignatureShare -
+func (stub *SignatureHandlerStub) SignatureShare(index uint16) ([]byte, error) {
+	if stub.SignatureShareCalled != nil {
+		return stub.SignatureShareCalled(index)
+	}
+
+	return []byte("sigShare"), nil
+}
+
+// VerifySignatureShare -
+func (stub *SignatureHandlerStub) VerifySignatureShare(index uint16, sig []byte, msg []byte) error {
+	if stub.VerifySignatureShareCalled != nil {
+		return stub.VerifySignatureShareCalled(index, sig, msg)
+	}
+
+	return nil
+}
+
+// AggregateSigs -
+func (stub *SignatureHandlerStub) AggregateSigs(bitmap []byte) ([]byte, error) {
+	if stub.AggregateSigsCalled != nil {
+		return stub.AggregateSigsCalled(bitmap)
+	}
+
+	return []byte("aggSigs"), nil
+}
+
+// SetAggregatedSig -
+func (stub *SignatureHandlerStub) SetAggregatedSig(sig []byte) error {
+	if stub.SetAggregatedSigCalled != nil {
+		return stub.SetAggregatedSigCalled(sig)
+	}
+
+	return nil
+}
+
+// Verify -
+func (stub *SignatureHandlerStub) Verify(msg []byte, bitmap []byte) error {
+	if stub.VerifyCalled != nil {
+		return stub.VerifyCalled(msg, bitmap)
+	}
+
+	return nil
+}
+
+// IsInterfaceNil -
+func (stub *SignatureHandlerStub) IsInterfaceNil() bool {
+	return stub == nil
+}

consensus/signing/errors.go

@@ -29,8 +29,8 @@ var ErrNilPublicKeys = errors.New("public keys are nil")
 // ErrNilSingleSigner singals that a nil single signer has been provided
 var ErrNilSingleSigner = errors.New("single signer is nil")
 
-// ErrNilMultiSigner singals that a nil multi signer has been provided
-var ErrNilMultiSigner = errors.New("multi signer is nil")
+// ErrNilMultiSignerContainer singals that a nil multi signer container has been provided
+var ErrNilMultiSignerContainer = errors.New("multi signer container is nil")
 
 // ErrIndexOutOfBounds is raised when an out of bound index is used
 var ErrIndexOutOfBounds = errors.New("index is out of bounds")

consensus/signing/signing.go

@@ -5,15 +5,16 @@ import (
 
 	"github.com/ElrondNetwork/elrond-go-core/core/check"
 	crypto "github.com/ElrondNetwork/elrond-go-crypto"
+	cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto"
 )
 
 // ArgsSignatureHolder defines the arguments needed to create a new signature holder component
 type ArgsSignatureHolder struct {
-	PubKeys      []string
-	PrivKey      crypto.PrivateKey
-	SingleSigner crypto.SingleSigner
-	MultiSigner  crypto.MultiSigner
-	KeyGenerator crypto.KeyGenerator
+	PubKeys              []string
+	PrivKey              crypto.PrivateKey
+	SingleSigner         crypto.SingleSigner
+	MultiSignerContainer cryptoCommon.MultiSignerContainer
+	KeyGenerator         crypto.KeyGenerator
 }
 
 type signatureHolderData struct {
@@ -24,11 +25,13 @@ type signatureHolderData struct {
 }
 
 type signatureHolder struct {
-	data           *signatureHolderData
-	mutSigningData sync.RWMutex
-	singleSigner   crypto.SingleSigner
-	multiSigner    crypto.MultiSigner
-	keyGen         crypto.KeyGenerator
+	data                 *signatureHolderData
+	mutSigningData       sync.RWMutex
+	singleSigner         crypto.SingleSigner
+	multiSignerContainer cryptoCommon.MultiSignerContainer
+	multiSigner          crypto.MultiSigner
+	mutMultiSigner       sync.RWMutex
+	keyGen               crypto.KeyGenerator
 }
 
 // NewSignatureHolder will create a new signature holder component
@@ -51,21 +54,27 @@ func NewSignatureHolder(args ArgsSignatureHolder) (*signatureHolder, error) {
 		sigShares: sigShares,
 	}
 
+	multiSigner, err := args.MultiSignerContainer.GetMultiSigner(0)
+	if err != nil {
+		return nil, err
+	}
+
 	return &signatureHolder{
-		data:           data,
-		mutSigningData: sync.RWMutex{},
-		singleSigner:   args.SingleSigner,
-		multiSigner:    args.MultiSigner,
-		keyGen:         args.KeyGenerator,
+		data:                 data,
+		mutSigningData:       sync.RWMutex{},
+		singleSigner:         args.SingleSigner,
+		multiSignerContainer: args.MultiSignerContainer,
+		multiSigner:          multiSigner,
+		keyGen:               args.KeyGenerator,
 	}, nil
 }
 
 func checkArgs(args ArgsSignatureHolder) error {
 	if check.IfNil(args.SingleSigner) {
 		return ErrNilSingleSigner
 	}
-	if check.IfNil(args.MultiSigner) {
-		return ErrNilMultiSigner
+	if check.IfNil(args.MultiSignerContainer) {
+		return ErrNilMultiSignerContainer
 	}
 	if check.IfNil(args.PrivKey) {
 		return ErrNilPrivateKey
@@ -87,11 +96,11 @@ func (sh *signatureHolder) Create(pubKeys []string, index uint16) (*signatureHol
 	sh.mutSigningData.RUnlock()
 
 	args := ArgsSignatureHolder{
-		PubKeys:      pubKeys,
-		PrivKey:      privKey,
-		SingleSigner: sh.singleSigner,
-		MultiSigner:  sh.multiSigner,
-		KeyGenerator: sh.keyGen,
+		PubKeys:              pubKeys,
+		PrivKey:              privKey,
+		SingleSigner:         sh.singleSigner,
+		MultiSignerContainer: sh.multiSignerContainer,
+		KeyGenerator:         sh.keyGen,
 	}
 	return NewSignatureHolder(args)
 }
@@ -125,6 +134,20 @@ func (sh *signatureHolder) Reset(pubKeys []string) error {
 	return nil
 }
 
+func (sh *signatureHolder) SetMultiSignerByEpoch(epoch uint32) error {
+	multiSigner, err := sh.multiSignerContainer.GetMultiSigner(epoch)
+	if err != nil {
+		return err
+	}
+
+	sh.mutMultiSigner.RLock()
+	defer sh.mutSigningData.RUnlock()
+
+	sh.multiSigner = multiSigner
+
+	return nil
+}
+
 // CreateSignatureShare returns a signature over a message
 func (sh *signatureHolder) CreateSignatureShare(message []byte, selfIndex uint16) ([]byte, error) {
 	if message == nil {
@@ -139,10 +162,12 @@ func (sh *signatureHolder) CreateSignatureShare(message []byte, selfIndex uint16
 		return nil, err
 	}
 
+	sh.mutMultiSigner.RLock()
 	sigShareBytes, err := sh.multiSigner.CreateSignatureShare(privKeyBytes, message)
 	if err != nil {
 		return nil, err
 	}
+	sh.mutMultiSigner.RUnlock()
 
 	sh.data.sigShares[selfIndex] = sigShareBytes
 
@@ -165,6 +190,9 @@ func (sh *signatureHolder) VerifySignatureShare(index uint16, sig []byte, messag
 
 	pubKey := sh.data.pubKeys[index]
 
+	sh.mutMultiSigner.RLock()
+	defer sh.mutMultiSigner.RUnlock()
+
 	return sh.multiSigner.VerifySignatureShare(pubKey, message, sig)
 }
 
@@ -246,6 +274,9 @@ func (sh *signatureHolder) AggregateSigs(bitmap []byte) ([]byte, error) {
 		pubKeysSigners = append(pubKeysSigners, sh.data.pubKeys[i])
 	}
 
+	sh.mutMultiSigner.RLock()
+	defer sh.mutMultiSigner.RUnlock()
+
 	return sh.multiSigner.AggregateSigs(pubKeysSigners, signatures)
 }
 
@@ -285,6 +316,9 @@ func (sh *signatureHolder) Verify(message []byte, bitmap []byte) error {
 		pubKeys = append(pubKeys, sh.data.pubKeys[i])
 	}
 
+	sh.mutMultiSigner.RLock()
+	defer sh.mutMultiSigner.RUnlock()
+
 	return sh.multiSigner.VerifyAggregatedSig(pubKeys, message, sh.data.aggSig)
 }